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

package/dist/flow.d.ts

@@ -1,6 +1,6 @@
-import { t as WasmPipeline } from "./warmup-CEJTfxQr.js";
-import { t as Manager } from "./Manager-BGfxEmyv.js";
-import { t as AnyStateMachine } from "./StateMachine-DRE1oH2B.js";
+import { t as WasmPipeline } from "./warmup-Cijuyvoc.js";
+import { t as Manager } from "./Manager-Cy9-TMC9.js";
+import { t as AnyStateMachine } from "./StateMachine-BqPpBhOz.js";
 
 //#region src/modules/flow/types.d.ts
 type EmptyConfig = Record<string, never>;

package/dist/flow.esm.js

@@ -1,5 +1,5 @@
-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 { b as createManager, n as api, t as endpoints } from "./endpoints-B0ltwtb5.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-2T5fOCTq.esm.js";
 
 //#region src/modules/flow/flowAnalyzer.ts
 const WASM_MODULE_PIPELINES = {

package/dist/getBrowser-CLEzz0Hi.esm.js

@@ -0,0 +1,8 @@
+//#region ../infra/src/device/getBrowser.ts
+function getUserAgent() {
+	if (typeof navigator === "undefined") return "";
+	return navigator.userAgent;
+}
+
+//#endregion
+export { getUserAgent as t };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { n as warmupWasm, t as WasmPipeline } from "./warmup-CEJTfxQr.js";
-import { n as PermissionStatus, t as PermissionResult } from "./types-iZi2rawo.js";
+import { n as warmupWasm, t as WasmPipeline } from "./warmup-Cijuyvoc.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-Dif6MQmX.js";
 
 //#region ../infra/src/http/types.d.ts
 type CreateApiConfig = {

package/dist/index.esm.js

@@ -1,5 +1,6 @@
-import { i as getBrowser, n as requestPermission, r as getDeviceClass, t as checkPermission } from "./permissionServices-I6vX6DBy.esm.js";
-import { _ as createApi_default, a as setClient, i as resetApi, l as warmupWasm, n as api, o as setToken, r as getApi, s as WasmUtilProvider, t as endpoints } from "./endpoints-BSTFaHYo.esm.js";
+import { a as resetApi, c as WasmUtilProvider, n as api, o as setClient, r as getApi, s as setToken, t as endpoints, u as warmupWasm, x as createApi_default } from "./endpoints-B0ltwtb5.esm.js";
+import "./getBrowser-CLEzz0Hi.esm.js";
+import { i as getBrowser, n as requestPermission, r as getDeviceClass, t as checkPermission } from "./permissionServices-BhD0KxsO.esm.js";
 
 //#region src/internal/session/sessionService.ts
 /**

package/dist/{lib-Bu9XGMBW.esm.js → lib-CykGFCEr.esm.js}

@@ -1,5 +1,5 @@
 import { i as __toCommonJS, n as __esm, r as __export, t as __commonJS } from "./chunk-C_Yo44FK.esm.js";
-import { n as require_jsnlog, t as require_OpenViduLogger } from "./OpenViduLogger-CQyDxBvM.esm.js";
+import { n as require_jsnlog, t as require_OpenViduLogger } from "./OpenViduLogger-5b7KqNTo.esm.js";
 
 //#region ../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Enums/LocalRecorderState.js
 var require_LocalRecorderState = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/openvidu-browser@2.32.1/node_modules/openvidu-browser/lib/OpenViduInternal/Enums/LocalRecorderState.js": ((exports) => {

package/dist/{permissionServices-I6vX6DBy.esm.js → permissionServices-BhD0KxsO.esm.js}

@@ -1,12 +1,6 @@
-import { h as stopCameraStream, m as requestCameraAccess, p as queryCameraPermission } from "./endpoints-BSTFaHYo.esm.js";
+import { _ as queryCameraPermission, v as requestCameraAccess, y as stopCameraStream } from "./endpoints-B0ltwtb5.esm.js";
+import { t as getUserAgent } from "./getBrowser-CLEzz0Hi.esm.js";
 
-//#region ../infra/src/device/getBrowser.ts
-function getUserAgent() {
-	if (typeof navigator === "undefined") return "";
-	return navigator.userAgent;
-}
-
-//#endregion
 //#region ../infra/src/device/getDeviceClass.ts
 function getDeviceInfo() {
 	if (typeof navigator === "undefined") return {

package/dist/phone.d.ts

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

package/dist/phone.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 { b as createManager, n as api, t as endpoints } from "./endpoints-B0ltwtb5.esm.js";
+import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-2T5fOCTq.esm.js";
+import { t as addEvent } from "./addEvent-s2Za-pK3.esm.js";
 
 //#region src/modules/phone/phoneServices.ts
 async function fetchPhone(signal) {

package/dist/recordingsRepository-CTjaf-ER.esm.js

@@ -0,0 +1,256 @@
+import { n as api, t as endpoints } from "./endpoints-B0ltwtb5.esm.js";
+import { t as getUserAgent } from "./getBrowser-CLEzz0Hi.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
+//#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(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 (error) {
+		console.error("Error uploading deepsight video:", error);
+		return "";
+	}
+}
+
+//#endregion
+export { createDeepsightService as a, uploadDeepsightVideo as i, startRecording as n, stopRecording as r, createRecordingSession as t };

package/dist/selfie.d.ts

@@ -1,7 +1,7 @@
-import { t as WasmPipeline } from "./warmup-CEJTfxQr.js";
-import { t as Manager } from "./Manager-BGfxEmyv.js";
-import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-DRE1oH2B.js";
-import { n as PermissionStatus, t as PermissionResult } from "./types-iZi2rawo.js";
+import { t as WasmPipeline } from "./warmup-Cijuyvoc.js";
+import { t as Manager } from "./Manager-Cy9-TMC9.js";
+import { n as StateMachine, t as AnyStateMachine } from "./StateMachine-BqPpBhOz.js";
+import { n as PermissionStatus, t as PermissionResult } from "./types-Dif6MQmX.js";
 
 //#region ../infra/src/media/canvas.d.ts
 /**
@@ -299,6 +299,24 @@ interface IFaceDetectionCapability extends IMLProviderCapability<FaceDetectionCo
   setVideoSelfieMode(enabled: boolean): void;
 }
 //#endregion
+//#region ../infra/src/capabilities/IDeepsightRecordingCapability.d.ts
+type DeepsightRecordingResult = {
+  trimmedBlob: Blob;
+  encryptedVideo: string;
+};
+type IDeepsightRecordingCapability = {
+  readonly isRecording: boolean;
+  readonly hasError: boolean;
+  readonly error: string | null;
+  startRecording(stream: MediaStream): void;
+  stopRecording(trimSeconds: number, encrypt: (base64: string) => string, generateChecksum: (buffer: ArrayBuffer) => void): Promise<DeepsightRecordingResult>;
+  reset(): void;
+};
+//#endregion
+//#region ../infra/src/capabilities/IMotionSensorCapability.d.ts
+type MotionStatus = 'PASS' | 'FAIL' | 'UNCLEAR';
+type MotionPermissionState = 'granted' | 'denied' | 'not-required';
+//#endregion
 //#region ../infra/src/capabilities/IRecordingCapability.d.ts
 type RecordingPublisher = {
   getStreamId: () => string | undefined;
@@ -480,6 +498,49 @@ declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDet
   private formatFaceCoordinates;
 }
 //#endregion
+//#region src/internal/deepsight/metadataService.d.ts
+type MetadataService = {
+  initialize(sdkVersion: string, disableIpify?: boolean): Promise<void>;
+  updateCameraInfo(videoTrack: MediaStreamTrack): void;
+  checkForVirtualCameraByLabel(videoTrack: MediaStreamTrack | null): Promise<boolean>;
+  analyzeFrame(imageData: ImageData): Promise<void>;
+  setMotionStatus(status: string): void;
+  setBackgroundMode(backgroundMode: boolean): void;
+  estimatePerformance(): string;
+  getMetadata(): string;
+  getCheck(): string;
+};
+//#endregion
+//#region src/internal/deepsight/motionStatusService.d.ts
+type MotionStatusService = {
+  requestPermission(): Promise<MotionPermissionState>;
+  start(): Promise<void>;
+  stop(): void;
+  check(): MotionStatus;
+  readonly isRunning: boolean;
+  readonly hasPermission: boolean;
+};
+//#endregion
+//#region src/internal/deepsight/deepsightService.d.ts
+type DeepsightCaptureResult = {
+  metadata: string;
+  recordingId: string | null;
+};
+type DeepsightService = {
+  readonly metadata: MetadataService;
+  readonly motion: MotionStatusService;
+  readonly recorder: IDeepsightRecordingCapability;
+  initialize(disableIpify?: boolean): Promise<void>;
+  requestMotionPermission(): Promise<'granted' | 'denied' | 'not-required'>;
+  startMotionSensors(): Promise<void>;
+  stopMotionSensors(): void;
+  startRecording(stream: MediaStream): void;
+  checkVirtualCamera(videoTrack: MediaStreamTrack): Promise<boolean>;
+  performVirtualCameraCheck(): Promise<void>;
+  performCapture(sessionToken: string, imageData: ImageData): Promise<DeepsightCaptureResult>;
+  cleanup(): void;
+};
+//#endregion
 //#region src/modules/selfie/types.d.ts
 type SelfieConfig = {
   showTutorial: boolean;
@@ -569,6 +630,7 @@ type SelfieContext = {
   uploadError: FaceErrorCode | undefined;
   permissionResult: PermissionResult | 'refresh' | undefined;
   resetDetection: (() => void) | undefined;
+  deepsightService: DeepsightService | undefined;
 };
 type SelfieEvent = {
   type: 'LOAD';
@@ -756,4 +818,4 @@ declare function createSelfieManager(options: CreateSelfieActorOptions): Manager
 };
 type SelfieManager = ReturnType<typeof createSelfieManager>;
 //#endregion
-export { type CameraStream, type DetectionStatus, type FaceErrorCode, type PermissionResult, type PermissionStatus, type SelfieConfig, type SelfieMachine, type SelfieManager, type SelfieState, createSelfieManager, selfieMachine };
+export { type CameraStream, type DeepsightService, type DetectionStatus, type FaceErrorCode, type PermissionResult, type PermissionStatus, type SelfieConfig, type SelfieMachine, type SelfieManager, type SelfieState, createSelfieManager, selfieMachine };