@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/{videoSelfieCameraWarmer-NEhFZvWx.esm.js → videoSelfieCameraWarmer-B8PcYqmz.esm.js}

@@ -1,16 +1,17 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-f5Ruz7R9.esm.js";
-import { i as requestCameraWithFallback, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
-import { t as checkPermission } from "./permissionServices-UvUcOSRb.esm.js";
-import { _ as StreamCanvasProcessingSession, a as encryptSelfieImage, l as startDetection, v as FaceDetectionProvider } from "./onDeviceFaceResults-CUHwyZT4.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-CUeYm5eu.esm.js";
-import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
+import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
+import { d as facingModeForStep, f as resolveVideoSelfieSteps } from "./flowServices-DjPFGs_D.esm.js";
+import { a as requestCameraWithFallback, i as requestCameraAccess } from "./camera-sIa9ceW2.esm.js";
+import { t as checkPermission } from "./permissionServices-Bj_fyWtv.esm.js";
+import { n as encryptSelfieImage, o as startDetection, t as FaceDetectionProvider } from "./FaceDetectionProvider-BfhWkK90.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { i as uploadSelfie, r as processFace, t as getFaceErrorCodeFromUnknown } from "./selfieErrorUtils-C2PYBVsp.esm.js";
-import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
-import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-WeHbQM7W.esm.js";
+import { t as StreamCanvasProcessingSession } from "./StreamCanvasProcessingSession-CBnbTnOr.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-BOtyQowf.esm.js";
+import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
+import { a as uploadSelfie, r as processFace, t as getFaceErrorCodeFromUnknown } from "./selfieErrorUtils-UiQ46EBa.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-CbPA-Auz.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-C9jtgBdT.esm.js";
 //#region src/modules/video-selfie/videoSelfieCompareService.ts
 async function postVideoSelfieCompare(endpoint, base64Image) {
 	return (await api.post(endpoint, { base64Image })).data;
@@ -434,146 +435,6 @@ async function validateIdFrame(step, config, base64Image) {
 	return { outcome: "success" };
 }
 //#endregion
-//#region ../infra/src/media/CameraCompositor.ts
-const MAX_COMPOSITE_LONG_EDGE = 1280;
-const MAX_COMPOSITE_SHORT_EDGE = 720;
-const FRAME_INTERVAL_TOLERANCE_RATIO = .9;
-/**
-* Composites the *active* camera into a canvas and exposes the canvas as a
-* single, stable `MediaStream` to record. Switching cameras (front ↔ back)
-* just repoints what the canvas draws — the output stream and its audio track
-* are never replaced — so a single `MediaRecorder` produces one continuous
-* video that follows the camera switches (V1 parity), instead of restarting
-* per camera.
-*
-* The audio track from the initial stream is carried through unchanged across
-* video switches, so there's no audio glitch when the camera flips.
-*/
-var CameraCompositor = class {
-	constructor(options = {}) {
-		this.canvas = null;
-		this.ctx = null;
-		this.video = null;
-		this.frameRequestId = null;
-		this.frameRequestKind = null;
-		this.lastDrawTimeMs = null;
-		this.lastVideoTimeSeconds = null;
-		this.audioTrack = null;
-		this.videoTrack = null;
-		this.composite = null;
-		this.fps = options.fps ?? 30;
-		this.frameIntervalMs = this.fps > 0 ? 1e3 / this.fps : 0;
-	}
-	/**
-	* Begin compositing `stream` and return the composite stream to record. The
-	* stream's audio track (if any) is carried through unchanged across later
-	* `switchVideo` calls.
-	*/
-	start(stream) {
-		this.canvas = document.createElement("canvas");
-		this.ctx = this.canvas.getContext("2d");
-		this.video = document.createElement("video");
-		this.video.muted = true;
-		this.video.playsInline = true;
-		this.audioTrack = stream.getAudioTracks()[0] ?? null;
-		this.setVideoSource(stream);
-		const composite = this.canvas.captureStream(this.fps);
-		if (this.audioTrack) composite.addTrack(this.audioTrack);
-		this.composite = composite;
-		this.startDrawLoop();
-		return composite;
-	}
-	/**
-	* Swap the camera feeding the canvas without interrupting the composite
-	* stream. Pass a video-only stream (audio is kept from `start`). The previous
-	* video track is stopped.
-	*/
-	switchVideo(stream) {
-		if (!this.composite) return;
-		const previousVideoTrack = this.videoTrack;
-		this.setVideoSource(stream);
-		this.startDrawLoop();
-		if (previousVideoTrack) previousVideoTrack.stop();
-	}
-	/** The composite stream being recorded, if compositing is active. */
-	get stream() {
-		return this.composite ?? void 0;
-	}
-	/** Stop compositing and release the canvas, audio, and video tracks. */
-	stop() {
-		this.cancelDrawLoop();
-		this.videoTrack?.stop();
-		this.audioTrack?.stop();
-		this.composite?.getTracks().forEach((track) => track.stop());
-		if (this.video) this.video.srcObject = null;
-		this.canvas = null;
-		this.ctx = null;
-		this.video = null;
-		this.videoTrack = null;
-		this.audioTrack = null;
-		this.composite = null;
-	}
-	setVideoSource(stream) {
-		this.videoTrack = stream.getVideoTracks()[0] ?? null;
-		const video = this.video;
-		if (!video) return;
-		video.srcObject = new MediaStream(stream.getVideoTracks());
-		video.play().catch(() => {});
-	}
-	startDrawLoop() {
-		this.cancelDrawLoop();
-		this.lastDrawTimeMs = null;
-		this.lastVideoTimeSeconds = null;
-		const draw = (timeMs) => {
-			const elapsed = this.lastDrawTimeMs === null ? Infinity : timeMs - this.lastDrawTimeMs;
-			if ((this.frameIntervalMs === 0 || elapsed >= this.frameIntervalMs * FRAME_INTERVAL_TOLERANCE_RATIO) && this.drawCurrentFrame()) this.lastDrawTimeMs = timeMs;
-			this.scheduleNextFrame(draw);
-		};
-		this.scheduleNextFrame(draw);
-	}
-	scheduleNextFrame(callback) {
-		const video = this.video;
-		if (video && typeof video.requestVideoFrameCallback === "function") {
-			this.frameRequestKind = "video";
-			this.frameRequestId = video.requestVideoFrameCallback(callback);
-			return;
-		}
-		this.frameRequestKind = "animation";
-		this.frameRequestId = requestAnimationFrame(callback);
-	}
-	cancelDrawLoop() {
-		if (this.frameRequestId === null) return;
-		if (this.frameRequestKind === "video" && this.video && typeof this.video.cancelVideoFrameCallback === "function") this.video.cancelVideoFrameCallback(this.frameRequestId);
-		else cancelAnimationFrame(this.frameRequestId);
-		this.frameRequestId = null;
-		this.frameRequestKind = null;
-	}
-	drawCurrentFrame() {
-		const video = this.video;
-		const canvas = this.canvas;
-		const ctx = this.ctx;
-		if (!video || !canvas || !ctx || video.videoWidth <= 0) return false;
-		if (this.lastVideoTimeSeconds === video.currentTime) return false;
-		const dimensions = this.getBoundedDimensions(video.videoWidth, video.videoHeight);
-		if (canvas.width !== dimensions.width || canvas.height !== dimensions.height) {
-			canvas.width = dimensions.width;
-			canvas.height = dimensions.height;
-		}
-		ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-		this.lastVideoTimeSeconds = video.currentTime;
-		return true;
-	}
-	getBoundedDimensions(width, height) {
-		const longEdge = Math.max(width, height);
-		const shortEdge = Math.min(width, height);
-		const scale = Math.min(1, MAX_COMPOSITE_LONG_EDGE / longEdge, MAX_COMPOSITE_SHORT_EDGE / shortEdge);
-		return {
-			width: Math.max(1, Math.round(width * scale)),
-			height: Math.max(1, Math.round(height * scale))
-		};
-	}
-};
-//#endregion
 //#region src/modules/video-selfie/videoSelfieCameraWarmer.ts
 /**
 * Acquire the camera for a Video Selfie step. The rear (`environment`) steps
@@ -609,8 +470,8 @@ function stopStream(stream) {
 * camera (and whether it needs audio) is derived from the resolved step order —
 * the same first acquire the recording machine performs on `START`.
 */
-function createVideoSelfieCameraWarmer(config) {
-	const firstFacing = facingModeForStep(resolveVideoSelfieSteps(config)[0] ?? "selfie");
+function createVideoSelfieCameraWarmer(config, steps = resolveVideoSelfieSteps(config)) {
+	const firstFacing = facingModeForStep(steps[0] ?? "selfie");
 	let warming = null;
 	let warmed = null;
 	let consumed = false;
@@ -648,4 +509,4 @@ function createVideoSelfieCameraWarmer(config) {
 	};
 }
 //#endregion
-export { delay as a, isWrongVideoSelfieIdSide as c, createDefaultStepDetector as i, defaultAcquireCamera as n, isConnectionError as o, CameraCompositor as r, isSelfieValidationError as s, createVideoSelfieCameraWarmer as t };
+export { isConnectionError as a, delay as i, defaultAcquireCamera as n, isSelfieValidationError as o, createDefaultStepDetector as r, isWrongVideoSelfieIdSide as s, createVideoSelfieCameraWarmer as t };

package/dist/videoSelfieFlowModuleMachine-BUe2uACW.esm.js

@@ -0,0 +1,32 @@
+import { t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
+//#region src/modules/video-selfie/videoSelfieFlowModuleMachine.ts
+/**
+* Parked flow-module machine for the `VIDEO_ONBOARDING` step.
+*
+* The video-selfie UI component owns the entire capture / streaming / upload
+* lifecycle (it creates its own {@link createVideoSelfieRecordingManager}) and
+* signals completion to the flow via `flowManager.completeModule()`
+* (`MODULE_COMPLETE`). This machine therefore only needs to hold the step open:
+* it starts in a non-final `running` state and never transitions, so the
+* orchestrated flow stays in `runningModule` until the UI advances it.
+*
+* **Completion contract:** the L2 `incode-video-selfie` web component calls
+* `flowManager.completeModule()` once the recording manager reaches `finished`.
+* Recoverable errors stay inside the module until the user retries.
+*
+* **Abort / unmount:** if the user closes the module or the web component
+* unmounts before completion, the orchestrated flow manager's existing close /
+* abort path (`MODULE_CLOSE` / session teardown) is responsible for exiting the
+* step. This parked machine does not model those paths itself.
+*
+* Contrast {@link noOpFlowModuleMachine}, whose initial state is `final` — that
+* is used for headless steps (e.g. `IP_ADDRESS`) that must complete instantly
+* with no UI. Using a no-op here would skip the video-selfie UI entirely.
+*/
+const videoSelfieFlowModuleMachine = setup({}).createMachine({
+	id: "videoSelfieFlowModule",
+	initial: "running",
+	states: { running: {} }
+});
+//#endregion
+export { videoSelfieFlowModuleMachine as t };

package/dist/{videoSelfieStepDetector-D3oo2ofo.d.ts → videoSelfieStepDetector-Co0Gu2k2.d.ts}

@@ -1,7 +1,8 @@
+import { i as FlowModuleConfig } from "./types-Do5rEXij.js";
+import "./IWasmUtilCapability-CNWRl7jr.js";
+import { n as DetectionStatus } from "./types-Bnl58jUQ.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { i as FlowModuleConfig } from "./types-KPvmag_B.js";
-import { n as DetectionStatus } from "./types-Hmd7U0JA.js";
-import { t as DetectionOrientation } from "./IIdCaptureCapability-DHTT3FC2.js";
+import { t as DetectionOrientation } from "./IIdCaptureCapability-RNiFhvXR.js";
 //#region src/modules/video-selfie/types.d.ts
 /**
  * The capture steps a Video Selfie session can run, in flow order. Which steps
@@ -15,10 +16,12 @@ type VideoSelfieStep = 'selfie' | 'frontId' | 'backId' | 'poa' | 'questions' | '
  *
  * The whole session is recorded on-device and streamed to the backend via S3
  * multipart upload (`internal/recordings/multipartRecordingService`) — the
- * client-side replacement for V1's server-side OpenVidu recording. See
+ * client-side replacement for V1's server-side recording. See
  * `docs/features/VIDEO_SELFIE.md`.
  */
-type VideoSelfieConfig = FlowModuleConfig['VIDEO_ONBOARDING'];
+type VideoSelfieConfig = FlowModuleConfig['VIDEO_ONBOARDING'] & {
+  steps?: VideoSelfieStep[];
+};
 //#endregion
 //#region ../infra/src/capabilities/ICameraCapability.d.ts
 type FacingMode = 'user' | 'environment';
@@ -26,14 +29,31 @@ type FacingMode = 'user' | 'environment';
 //#region ../infra/src/media/CameraCompositor.d.ts
 type CameraCompositorOptions = {
   fps?: number;
+  resumeTimeoutMs?: number;
 };
+type CameraCompositorResumeResult = 'resumed' | 'video-ended' | 'audio-ended' | 'timed-out';
 /**
- * Composites the *active* camera into a canvas and exposes the canvas as a
- * single, stable `MediaStream` to record. Switching cameras (front ↔ back)
- * just repoints what the canvas draws — the output stream and its audio track
- * are never replaced — so a single `MediaRecorder` produces one continuous
- * video that follows the camera switches (V1 parity), instead of restarting
- * per camera.
+ * Composites the *active* camera into a single, stable `MediaStream` to
+ * record. Switching cameras (front ↔ back) just repoints the source — the
+ * output stream and its audio track are never replaced — so a single
+ * `MediaRecorder` produces one continuous video that follows the camera
+ * switches (V1 parity), instead of restarting per camera.
+ *
+ * Two transports (ENG-55397):
+ *  - **Worker (preferred, Chromium 94+):** camera track →
+ *    `MediaStreamTrackProcessor` → worker scales on an `OffscreenCanvas` →
+ *    `MediaStreamTrackGenerator`. The main thread is not in the frame path, so
+ *    the recording stays at camera rate while the synchronous ID detection
+ *    tick saturates the main thread (measured: 4–9 fps main-thread vs 30 fps
+ *    worker on a Galaxy S21 under the same load).
+ *  - **Main thread (fallback):** hidden `<video>` → rVFC/rAF → canvas →
+ *    `captureStream`, for Safari, Firefox and strict-CSP hosts that block blob
+ *    workers.
+ *
+ * A worker that dies mid-recording (GPU-process crash, OOM) is released at
+ * once; the composite track stays valid but receives no further frames, and
+ * the next `resume()` reports `timed-out` so the caller reacquires the camera
+ * instead of talking to a dead worker.
  *
  * The audio track from the initial stream is carried through unchanged across
  * video switches, so there's no audio glitch when the camera flips.
@@ -41,16 +61,22 @@ type CameraCompositorOptions = {
 declare class CameraCompositor {
   private readonly fps;
   private readonly frameIntervalMs;
+  private readonly resumeTimeoutMs;
   private canvas;
   private ctx;
   private video;
+  private transport;
+  /** Worker-transport output track; outlives a crashed worker until stop(). */
+  private generator;
   private frameRequestId;
   private frameRequestKind;
+  private sourceExceedsTargetFps;
   private lastDrawTimeMs;
   private lastVideoTimeSeconds;
   private audioTrack;
   private videoTrack;
   private composite;
+  private resumeWaiter;
   constructor(options?: CameraCompositorOptions);
   /**
    * Begin compositing `stream` and return the composite stream to record. The
@@ -59,17 +85,37 @@ declare class CameraCompositor {
    */
   start(stream: CameraStream): MediaStream;
   /**
-   * Swap the camera feeding the canvas without interrupting the composite
+   * Swap the camera feeding the composite without interrupting the composite
    * stream. Pass a video-only stream (audio is kept from `start`). The previous
    * video track is stopped.
    */
   switchVideo(stream: CameraStream): void;
   /** The composite stream being recorded, if compositing is active. */
   get stream(): MediaStream | undefined;
-  /** Stop compositing and release the canvas, audio, and video tracks. */
+  /** Pause source playback and drawing while the page is backgrounded. */
+  pause(): void;
+  /**
+   * Restart source playback and wait for a genuinely new camera frame to reach
+   * the stable composite stream. The caller must not resume encoding until
+   * this resolves with `resumed`.
+   */
+  resume(signal?: AbortSignal): Promise<CameraCompositorResumeResult>;
+  /** Stop compositing and release the worker, canvas, audio and video tracks. */
   stop(): void;
+  /**
+   * Worker transport. Returns `null` — and leaves nothing behind — when the
+   * browser lacks insertable streams or a strict `worker-src` CSP blocks blob
+   * workers, so `start` falls through to the main-thread path. Never throws.
+   */
+  private startWorkerTransport;
+  /** Terminates the worker and frees its blob; idempotent. */
+  private releaseWorker;
+  private startMainThread;
+  private postToWorker;
+  private onWorkerMessage;
   private setVideoSource;
   private startDrawLoop;
+  private finishResume;
   private scheduleNextFrame;
   private cancelDrawLoop;
   private drawCurrentFrame;

package/dist/virtualCameraCheck-Cjab7FTI.esm.js

@@ -0,0 +1,48 @@
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as addDeviceStats } from "./stats-CZcy2J53.esm.js";
+import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
+//#region src/internal/virtualCameraCheck.ts
+const frameSources = {
+	front: "FRONT_ID",
+	back: "BACK_ID",
+	selfie: "SELFIE"
+};
+/**
+* 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) logFrame({
+			source,
+			base64Image,
+			token
+		});
+	}
+	if (output.itr === true) {
+		addDeviceStats({ virtualCameraDetected: true });
+		wasmUtil.setZc("FAIL");
+	} else if (output.itr === false) wasmUtil.setZc("PASS");
+}
+//#endregion
+export { runVirtualCameraCheck as n, frameSources as t };