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

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

@@ -1,4 +1,4 @@
-import { t as __commonJS } from "./chunk-FbsBJI8u.esm.js";
+import { t as __commonJS } from "./chunk-V5DOKNPJ.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-DyqID_-7.esm.js

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

package/dist/api-DfRLAneb.esm.js

@@ -0,0 +1,53 @@
+//#region src/internal/http/api.ts
+let client = null;
+let currentToken = null;
+function setClient(httpClient) {
+	client = 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;
+}
+function isApiConfigured() {
+	return client !== null;
+}
+function resetApi() {
+	client = null;
+	currentToken = null;
+}
+function addTokenHeader(config) {
+	if (!currentToken) return config ?? {};
+	return {
+		...config,
+		headers: {
+			...config?.headers,
+			"X-Incode-Hardware-Id": currentToken
+		}
+	};
+}
+const api = {
+	get(url, config) {
+		return getApi().get(url, addTokenHeader(config));
+	},
+	post(url, data, config) {
+		return getApi().post(url, data, addTokenHeader(config));
+	},
+	put(url, data, config) {
+		return getApi().put(url, data, addTokenHeader(config));
+	},
+	patch(url, data, config) {
+		return getApi().patch(url, data, addTokenHeader(config));
+	},
+	delete(url, config) {
+		return getApi().delete(url, addTokenHeader(config));
+	}
+};
+
+//#endregion
+export { resetApi as a, isApiConfigured as i, getApi as n, setClient as o, getToken as r, setToken as s, api as t };

package/dist/deepsightLoader-BMT0FSg6.esm.js

@@ -0,0 +1,24 @@
+import { l as MotionSensorProvider, p as BrowserEnvironmentProvider, r as WasmUtilProvider, s as VisibilityProvider } from "./src-DYtpbFY5.esm.js";
+import "./getDeviceClass-DkfbtsIJ.esm.js";
+import "./api-DfRLAneb.esm.js";
+import { t as createDeepsightService } from "./deepsightService-j5zMt6wf.esm.js";
+import "./stats-DnU4uUFv.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(),
+		browserEnv: new BrowserEnvironmentProvider(),
+		motionSensor: new MotionSensorProvider()
+	});
+	await service.initialize();
+	await service.requestMotionPermission();
+	await service.startMotionSensors();
+	return service;
+}
+
+//#endregion
+export { loadDeepsightSession };

package/dist/deepsightService-j5zMt6wf.esm.js

@@ -0,0 +1,236 @@
+import { S as stopCameraStream, _ as createHiddenVideoElement, v as IncodeCanvas, x as requestCameraAccess } from "./src-DYtpbFY5.esm.js";
+import { r as getUserAgent, t as getDeviceInfo } from "./getDeviceClass-DkfbtsIJ.esm.js";
+import { t as api } from "./api-DfRLAneb.esm.js";
+import { t as addDeviceStats } from "./stats-DnU4uUFv.esm.js";
+
+//#region src/internal/deepsight/metadataService.ts
+const AUTOMATION_MARKERS = {
+	window: [
+		"callPhantom",
+		"_phantom",
+		"phantom",
+		"__nightmare",
+		"domAutomation",
+		"domAutomationController"
+	],
+	navigator: ["webdriver"]
+};
+const IP_PROVIDER_URL = "https://api.ipify.org?format=json";
+function isBrowserSimulation(browserEnv) {
+	for (const prop of AUTOMATION_MARKERS.window) if (browserEnv.getWindowProperty(prop)) return true;
+	for (const prop of AUTOMATION_MARKERS.navigator) if (browserEnv.getNavigatorProperty(prop)) return true;
+	return false;
+}
+async function fetchPublicIp(browserEnv) {
+	return (await browserEnv.fetchJson(IP_PROVIDER_URL, 3e3))?.ip || "";
+}
+function createMetadataService(wasmUtil, visibility, browserEnv) {
+	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 deviceInfo = getDeviceInfo();
+			const visitorId = browserEnv.generateCanvasFingerprint();
+			const ip = disableIpify ? "" : await fetchPublicIp(browserEnv);
+			const screenDimensions = browserEnv.getScreenDimensions();
+			const deviceMetadata = {
+				kind: isMobile ? "mobile" : "desktop",
+				model: "",
+				os: void 0,
+				osVersion: void 0,
+				screenDimensions,
+				numTouchPoints: deviceInfo.maxTouchPoints,
+				fingerprintHash: visitorId,
+				ip,
+				backgroundMode: false
+			};
+			wasmUtil.setDeviceInfo(deviceMetadata);
+			const navigatorPrefixes = browserEnv.getNavigatorPrefixes();
+			const browserInfo = {
+				userAgent: ua,
+				getUserMediaAvailability: {
+					webkit: navigatorPrefixes.webkit,
+					moz: navigatorPrefixes.moz,
+					o: navigatorPrefixes.o,
+					ms: navigatorPrefixes.ms
+				},
+				webglFingerprint: browserEnv.getWebGLRenderer(),
+				inspectorOpened: false,
+				isMockedBrowser: isBrowserSimulation(browserEnv)
+			};
+			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 labels = await browserEnv.enumerateVideoDeviceLabels();
+					for (const label of labels) if (wasmUtil.isVirtualCamera(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/virtualCameraCheck.ts
+/**
+* Sends the analyzed frame image to the backend for logging.
+*/
+async function logFrame({ source, base64Image, token }) {
+	try {
+		return (await api.post("/omni/log/frame/v2", { base64Image }, {
+			query: { source },
+			headers: { "X-Incode-Hardware-Id": token }
+		})).data;
+	} catch {
+		return;
+	}
+}
+/**
+* Runs the WASM virtual camera check and handles logging and stats.
+*/
+async function runVirtualCameraCheck({ wasmUtil, source, token }) {
+	const output = {
+		canvas: null,
+		itr: null,
+		skipped: null
+	};
+	await wasmUtil.poc(output);
+	if (output.skipped !== false) return;
+	if (output.canvas && token) {
+		const base64Image = new IncodeCanvas(output.canvas).getBase64Image();
+		if (base64Image) await logFrame({
+			source,
+			base64Image,
+			token
+		});
+	}
+	if (output.itr === true) {
+		addDeviceStats({ virtualCameraDetected: true });
+		wasmUtil.setZc("FAIL");
+	} else if (output.itr === false) wasmUtil.setZc("PASS");
+}
+
+//#endregion
+//#region src/internal/deepsight/deepsightService.ts
+function createDeepsightService(config) {
+	const metadata = createMetadataService(config.wasmUtil, config.visibility, config.browserEnv);
+	const motion = createMotionStatusService(config.motionSensor);
+	return {
+		metadata,
+		motion,
+		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();
+		},
+		async checkVirtualCamera(videoTrack) {
+			metadata.updateCameraInfo(videoTrack);
+			return metadata.checkForVirtualCameraByLabel(videoTrack);
+		},
+		async performVirtualCameraCheck(sessionToken, source) {
+			await runVirtualCameraCheck({
+				wasmUtil: config.wasmUtil,
+				source,
+				token: sessionToken
+			});
+		},
+		async performPrcCheck(params) {
+			await params.storage.set("ds", params.ds ? 1 : 0);
+			const prcStream = await requestCameraAccess(params.constraints);
+			const hiddenVideo = createHiddenVideoElement(prcStream);
+			try {
+				await config.wasmUtil.prc();
+			} finally {
+				hiddenVideo.dispose();
+				stopCameraStream(prcStream);
+			}
+		},
+		async analyzeFrame(imageData) {
+			await metadata.analyzeFrame(imageData);
+			const motionStatus = motion.check();
+			metadata.setMotionStatus(motionStatus);
+			metadata.getCheck();
+			metadata.setBackgroundMode(false);
+		},
+		getMetadata() {
+			return metadata.getMetadata();
+		},
+		cleanup() {
+			motion.stop();
+		}
+	};
+}
+
+//#endregion
+export { createDeepsightService as t };

package/dist/email.d.ts

@@ -1,4 +1,4 @@
-import { t as Manager } from "./Manager-BZUZTRPx.js";
+import { t as Manager } from "./Manager-Co-PsiG9.js";
 
 //#region src/modules/email/types.d.ts
 
@@ -110,9 +110,9 @@ type EmailOtpErrorState = {
   error: string;
   attemptsRemaining: number;
 };
-/** Email verification completed successfully - call `reset()` to start over */
-type EmailSuccessState = {
-  status: 'success';
+/** Email verification completed successfully */
+type EmailFinishedState = {
+  status: 'finished';
 };
 /**
  * Fatal error occurred - call `reset()` to start over
@@ -135,7 +135,7 @@ type EmailErrorState = {
  * }
  * ```
  */
-type EmailState = EmailIdleState | EmailLoadingPrefillState | EmailInputtingState | EmailSubmittingState | EmailSendingOtpState | EmailAwaitingOtpState | EmailVerifyingOtpState | EmailOtpErrorState | EmailSuccessState | EmailErrorState;
+type EmailState = EmailIdleState | EmailLoadingPrefillState | EmailInputtingState | EmailSubmittingState | EmailSendingOtpState | EmailAwaitingOtpState | EmailVerifyingOtpState | EmailOtpErrorState | EmailFinishedState | EmailErrorState;
 /**
  * Creates an email verification manager for headless or UI-driven usage.
  *

package/dist/email.esm.js

@@ -1,6 +1,7 @@
-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";
+import { d as addEvent, n as eventModuleNames, r as eventScreenNames } from "./events-B8ZkhAZo.esm.js";
+import { C as createManager, d as BrowserTimerProvider } from "./src-DYtpbFY5.esm.js";
+import { a as fromPromise, i as fromCallback, n as setup, o as createActor, r as assign, t as endpoints } from "./endpoints-BUsSVoJV.esm.js";
+import { t as api } from "./api-DfRLAneb.esm.js";
 
 //#region src/modules/email/emailServices.ts
 async function fetchEmail(signal) {
@@ -46,13 +47,14 @@ const emailMachine = setup({
 			return verifyEmailOtp(input.code, signal);
 		}),
 		resendTimer: fromCallback(({ sendBack }) => {
+			const timer = BrowserTimerProvider.getInstance();
 			let seconds = RESEND_TIMER_SECONDS;
-			const interval = setInterval(() => {
+			const interval = timer.setInterval(() => {
 				seconds -= 1;
 				sendBack({ type: "TICK" });
-				if (seconds <= 0) clearInterval(interval);
+				if (seconds <= 0) timer.clearInterval(interval);
 			}, 1e3);
-			return () => clearInterval(interval);
+			return () => timer.clearInterval(interval);
 		})
 	},
 	actions: {
@@ -115,8 +117,8 @@ const emailMachine = setup({
 		sendEmailSubmitEvent: () => {
 			addEvent({
 				code: "continue",
-				module: "email",
-				screen: "emailInput"
+				module: eventModuleNames.email,
+				screen: eventScreenNames.emailInput
 			});
 		}
 	},
@@ -176,7 +178,7 @@ const emailMachine = setup({
 				guard: "hasOtpVerification",
 				actions: "sendEmailSubmitEvent"
 			}, {
-				target: "success",
+				target: "finished",
 				actions: "sendEmailSubmitEvent"
 			}],
 			onError: {
@@ -216,7 +218,7 @@ const emailMachine = setup({
 			input: ({ context }) => ({ code: context.otpCode }),
 			onDone: [
 				{
-					target: "success",
+					target: "finished",
 					guard: ({ event }) => event.output.success === true
 				},
 				{
@@ -252,10 +254,7 @@ const emailMachine = setup({
 			},
 			BACK: { target: "inputting" }
 		} },
-		success: { on: { RESET: {
-			target: "idle",
-			actions: "resetContext"
-		} } },
+		finished: { type: "final" },
 		error: { on: { RESET: {
 			target: "idle",
 			actions: "resetContext"
@@ -302,7 +301,7 @@ function createEmailActor(options) {
 * // 3. Subscribe to state changes (optional but recommended)
 * emailManager.subscribe((state) => {
 *   console.log('Email state:', state.status);
-*   if (state.status === 'success') {
+*   if (state.status === 'finished') {
 *     console.log('Email verified successfully!');
 *   }
 *   if (state.status === 'error') {
@@ -345,7 +344,7 @@ function createEmailActor(options) {
 *       // Get OTP from user or external source
 *       emailManager.submitOtp(otpCode);
 *       break;
-*     case 'success':
+*     case 'finished':
 *       clearInterval(interval);
 *       emailManager.stop();
 *       break;
@@ -382,7 +381,7 @@ function mapState(snapshot) {
 		error: context.otpError ?? "Invalid OTP code",
 		attemptsRemaining: context.attemptsRemaining
 	};
-	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
 	if (typedSnapshot.matches("error")) return {
 		status: "error",
 		error: context.error ?? "An error occurred"

package/dist/{xstate.esm-2hDiAXvZ.esm.js → endpoints-BUsSVoJV.esm.js}

@@ -3258,4 +3258,31 @@ function setup({ schemas, actors, actions, guards, delays }) {
 }
 
 //#endregion
-export { createActor as a, fromPromise as i, assign as n, fromCallback as r, setup as t };
+//#region src/internal/http/endpoints.ts
+const endpoints = {
+	createSession: "/omni/start",
+	flow: "/omni/onboarding/flow",
+	events: "/omni/interview-events",
+	selfie: "/omni/add/face",
+	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",
+	startInfo: "/omni/start-info",
+	sendSmsOtp: "/omni/send/sms-otp",
+	compareOtp: "/omni/compare/otp",
+	email: "/omni/add/email",
+	getEmail: "/omni/get/email",
+	frontId: "/omni/add/front-id/v2",
+	backId: "/omni/add/back-id/v2",
+	getImages: "/omni/get/images",
+	processId: "/omni/process/id",
+	processSecondId: "/omni/process/second-id",
+	processFace: "/omni/process/face"
+};
+
+//#endregion
+export { fromPromise as a, fromCallback as i, setup as n, createActor as o, assign as r, endpoints as t };