@incodetech/core 2.0.1 → 2.1.0-rc.1

package/dist/deepsightService-CrHmvx8X.esm.js

@@ -0,0 +1,276 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as addDeviceStats } from "./stats-BMNUG1AU.esm.js";
+import { n as getThumbmarkId, r as getParsedUserAgent, t as isBrowserSimulation } from "./browserSimulation-B1dWiXp7.esm.js";
+import { t as getUserAgent } from "./getBrowser-C8DP7oTB.esm.js";
+import { i as stopCameraStream, r as requestCameraAccess } from "./camera-DJWm3V4g.esm.js";
+import { t as IncodeCanvas } from "./canvas-SKcRBxsk.esm.js";
+import { t as getDeviceInfo } from "./getDeviceClass-C0olyNFS.esm.js";
+
+//#region ../infra/src/media/video.ts
+/**
+* Creates a hidden video element for a stream and appends it to document.body.
+*/
+function createHiddenVideoElement(stream) {
+	if (typeof document === "undefined") throw new Error("Document not available");
+	const video = document.createElement("video");
+	video.autoplay = true;
+	video.playsInline = true;
+	video.muted = true;
+	video.srcObject = stream;
+	video.style.width = "0px";
+	video.style.height = "0px";
+	video.style.position = "absolute";
+	video.style.top = "0";
+	video.style.left = "0";
+	video.style.zIndex = "-1";
+	document.body.appendChild(video);
+	return {
+		element: video,
+		dispose: () => {
+			const current = video.srcObject;
+			if (current instanceof MediaStream) for (const track of current.getTracks()) track.stop();
+			video.srcObject = null;
+			if (video.parentElement) video.parentElement.removeChild(video);
+		}
+	};
+}
+
+//#endregion
+//#region src/internal/deepsight/metadataService.ts
+function createMetadataService(wasmUtil, visibility, browserEnv, ipLookup) {
+	return {
+		async initialize(sdkVersion, disableIpify = false) {
+			wasmUtil.setSdkPlatform("WEBAPP");
+			wasmUtil.setSdkVersion(sdkVersion);
+			const ua = getUserAgent();
+			const parsedUa = getParsedUserAgent(ua);
+			const isMobile = /Android|iPhone|iPad|iPod/i.test(ua);
+			const deviceInfo = getDeviceInfo();
+			let fingerprintHash = "";
+			try {
+				fingerprintHash = await getThumbmarkId();
+			} catch {
+				fingerprintHash = browserEnv.generateCanvasFingerprint();
+			}
+			const ip = disableIpify ? "" : await ipLookup.getIp();
+			const screenDimensions = browserEnv.getScreenDimensions();
+			const model = [parsedUa.device.vendor, parsedUa.device.model].filter(Boolean).join(" ");
+			const deviceMetadata = {
+				kind: isMobile ? "mobile" : "desktop",
+				model,
+				os: parsedUa.os.name ?? "",
+				osVersion: parsedUa.os.version ?? "",
+				screenDimensions,
+				numTouchPoints: deviceInfo.maxTouchPoints,
+				fingerprintHash,
+				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();
+		},
+		getPipelineState() {
+			return wasmUtil.getPipelineState();
+		},
+		preparePipelineState() {
+			wasmUtil.getPipelineState();
+		}
+	};
+}
+
+//#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, config.ipLookup);
+	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();
+		},
+		async primeWasmMotionSensor() {
+			await config.wasmUtil.rsp();
+			config.wasmUtil.ssl();
+		},
+		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) {
+			const prcStream = await requestCameraAccess(params.constraints);
+			const hiddenVideo = createHiddenVideoElement(prcStream);
+			try {
+				await config.wasmUtil.prc();
+			} finally {
+				hiddenVideo.dispose();
+				stopCameraStream(prcStream);
+			}
+		},
+		async analyzeFrame(imageData) {
+			await motion.start();
+			await metadata.analyzeFrame(imageData);
+			metadata.preparePipelineState();
+			const motionStatus = motion.check();
+			metadata.setMotionStatus(motionStatus);
+			metadata.getCheck();
+			metadata.setBackgroundMode(false);
+		},
+		getMetadata() {
+			return metadata.getMetadata();
+		},
+		getMotionStatus() {
+			return motion.check();
+		},
+		getAnalysisStatus() {
+			return metadata.getCheck();
+		},
+		getPipelineState() {
+			return metadata.getPipelineState();
+		},
+		cleanup() {
+			motion.stop();
+		}
+	};
+}
+
+//#endregion
+export { createDeepsightService as t };

package/dist/{deepsightService-CEVxzehb.d.ts → deepsightService-Dh5P-hLf.d.ts}

@@ -1,5 +1,4 @@
-import { n as WasmPipeline } from "./warmup-CEcppFiS.js";
-import { t as CameraStream } from "./camera-DBSxa6ML.js";
+import { n as WasmPipeline } from "./warmup-Dg8Lh-50.js";
 
 //#region ../infra/src/capabilities/IRecordingCapability.d.ts
 type RecordingPublisher = {
@@ -166,6 +165,11 @@ type IWasmUtilCapability = {
   setBackgroundMode(backgroundMode: boolean): void;
   setZc(zc: string): void;
   setInspectorOpened(opened: boolean): void;
+  /**
+   * Toggles the WASM module's production mode. When `true`, the native module
+   * suppresses its verbose debug logging/console output.
+   */
+  setProductionMode(productionMode: boolean): Promise<void>;
   getMetadata(): string;
   analyzeFrame(image: ImageData): Promise<void>;
   getCheck(): string;
@@ -178,6 +182,11 @@ type IWasmUtilCapability = {
   isVirtualCamera(label: string | null): boolean;
   prc(): Promise<void>;
   poc(output: VirtualCameraCheckOutput): Promise<void>;
+  rsp(): Promise<void>;
+  ssl(): void;
+  stl(): void;
+  osv(): void;
+  oev(): void;
   ckvcks(data: ArrayBuffer): void;
   getVersions(): Promise<unknown>;
   /**
@@ -186,166 +195,9 @@ type IWasmUtilCapability = {
   dispose(): Promise<void>;
 };
 //#endregion
-//#region ../infra/src/media/canvas.d.ts
-/**
- * Class representing a canvas element for image capture and manipulation.
- */
-declare class IncodeCanvas {
-  canvas: HTMLCanvasElement;
-  private base64Image;
-  private blobData;
-  /**
-   * Creates an {@link IncodeCanvas} from a raw {@link ImageData} frame.
-   * @param imageData - Frame pixels in RGBA format
-   * @returns An {@link IncodeCanvas} containing the provided pixels
-   */
-  static fromImageData(imageData: ImageData): IncodeCanvas;
-  /**
-   * Create a new canvas element.
-   * @param canvas_ - The canvas element to clone.
-   */
-  constructor(canvas_: HTMLCanvasElement);
-  /**
-   * Check if the current canvas is valid.
-   */
-  private checkCanvas;
-  /**
-   * Disposes of resources, including revoking object URLs to prevent memory leaks.
-   */
-  dispose(): void;
-  /**
-   * Release the data stored by IncodeCanvas.
-   */
-  release(): void;
-  /**
-   * Revokes the object URL if one exists, preventing memory leaks.
-   * Use this when you no longer need the preview image URL.
-   */
-  revokeObjectURL(): void;
-  /**
-   * Get the width of the canvas.
-   */
-  width(): number | null;
-  /**
-   * Get the height of the canvas.
-   */
-  height(): number | null;
-  /**
-   * Set the width of the canvas.
-   */
-  setWidth(width: number): void;
-  /**
-   * Set the height of the canvas.
-   */
-  setHeight(height: number): void;
-  /**
-   * Clone the current canvas.
-   */
-  clone(): IncodeCanvas | null;
-  /**
-   * Deep clone the current IncodeCanvas including blob data.
-   */
-  deepClone(): Promise<IncodeCanvas | null>;
-  /**
-   * Returns the drawing context on the canvas.
-   */
-  getContext(contextId: '2d', contextAttributes?: CanvasRenderingContext2DSettings): CanvasRenderingContext2D | null;
-  /**
-   * Retrieves the image data from the canvas.
-   */
-  getImageData(): ImageData | null;
-  /**
-   * Updates the base64 representation of the current canvas image.
-   */
-  updateBase64Image(jpegQuality?: number): void;
-  /**
-   * Converts the current canvas element to a base64 string.
-   */
-  getBase64Image(jpegQuality?: number, includeDataURLPrefix?: boolean): string | null;
-  /**
-   * Sets the base64 representation of the current canvas image.
-   */
-  setBase64Image(base64Image: string | null): void;
-  /**
-   * Updates the Blob representation of the current canvas image.
-   */
-  updateBlob(jpegQuality?: number, includeDataURLPrefix?: boolean): void;
-  /**
-   * Converts a base64 string to a Blob and creates a URL for it.
-   */
-  static base64ToBlob(base64: string): {
-    blob: Blob;
-    url: string;
-  } | null;
-  /**
-   * Retrieves the Blob data and its URL from the current canvas.
-   */
-  getBlobData(jpegQuality?: number, includeDataURLPrefix?: boolean): {
-    blob: Blob;
-    url: string;
-  } | null;
-  /**
-   * Sets the Blob data of the current canvas image.
-   */
-  setBlobData(blobData: {
-    blob: Blob;
-    url: string;
-  }): Promise<void>;
-  /**
-   * Returns a resized canvas according to video element size.
-   */
-  getResizedCanvas(videoElementWidth: number, videoElementHeight: number): IncodeCanvas | null;
-}
-//#endregion
-//#region ../infra/src/media/StreamCanvasCapture.d.ts
-type StreamCanvasCaptureOptions = {
-  fps?: number;
-  width?: number;
-  height?: number;
-};
-type StreamCanvasCaptureEventMap = {
-  frame: Event;
-};
-declare class StreamCanvasCapture {
-  private video;
-  private canvas;
-  private ctx;
-  private rafId;
-  private lastFrameTimeSeconds;
-  private lastTickTimeMs;
-  private hasFrame;
-  private disposed;
-  private eventTarget;
-  constructor(stream: CameraStream, options?: StreamCanvasCaptureOptions);
-  addEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
-  removeEventListener(type: keyof StreamCanvasCaptureEventMap, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
-  /**
-   * Returns the latest cached frame as an {@link IncodeCanvas}.
-   */
-  getLatestCanvas(): IncodeCanvas | null;
-  /**
-   * Returns the latest cached frame as raw {@link ImageData}.
-   */
-  getLatestFrame(): ImageData | null;
-  /**
-   * Disposes internal resources and stops the capture loop.
-   */
-  dispose(): void;
-  private rafLoop;
-  private tick;
-}
-//#endregion
 //#region ../infra/src/capabilities/IMotionSensorCapability.d.ts
 type MotionStatus = 'PASS' | 'FAIL' | 'UNCLEAR';
 type MotionPermissionState = 'granted' | 'denied' | 'not-required';
-type IMotionSensorCapability = {
-  requestPermission(): Promise<MotionPermissionState>;
-  start(): Promise<void>;
-  stop(): void;
-  check(): MotionStatus;
-  readonly isRunning: boolean;
-  readonly hasPermission: boolean;
-};
 //#endregion
 //#region src/internal/deepsight/metadataService.d.ts
 type MetadataService = {
@@ -391,6 +243,7 @@ type DeepsightService = {
   initialize(disableIpify?: boolean): Promise<void>;
   requestMotionPermission(): Promise<'granted' | 'denied' | 'not-required'>;
   startMotionSensors(): Promise<void>;
+  primeWasmMotionSensor(): Promise<void>;
   stopMotionSensors(): void;
   checkVirtualCamera(videoTrack: MediaStreamTrack): Promise<boolean>;
   performVirtualCameraCheck(sessionToken: string | null, source: FrameSource): Promise<void>;
@@ -409,4 +262,4 @@ type DeepsightPrcCheckParams = {
   constraints: MediaStreamConstraints;
 };
 //#endregion
-export { IWasmUtilCapability as a, IMLProviderCapability as c, IRecordingCapability as d, RecordingConnection as f, IncodeCanvas as i, MLProviderConfig as l, IMotionSensorCapability as n, VirtualCameraCheckOutput as o, StreamCanvasCapture as r, WasmUtilConfig as s, DeepsightService as t, IStorageCapability as u };
+export { IMLProviderCapability as a, IRecordingCapability as c, WasmUtilConfig as i, RecordingConnection as l, IWasmUtilCapability as n, MLProviderConfig as o, VirtualCameraCheckOutput as r, IStorageCapability as s, DeepsightService as t };

package/dist/device.esm.js

@@ -1,6 +1,7 @@
-import { i as isIPad } from "./platform-CfrjKhmi.esm.js";
-import { t as getUserAgent } from "./getBrowser-BSXUTWXw.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-BSntT9_j.esm.js";
+import { i as isIPad } from "./platform-SKvEfCBh.esm.js";
+import { t as getUserAgent } from "./getBrowser-C8DP7oTB.esm.js";
+import "./getDeviceClass-C0olyNFS.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-C8Do2qYu.esm.js";
 
 //#region src/internal/device/getBrowser.ts
 function getBrowser() {