@incodetech/core 2.3.0-rc.9 → 2.3.1-rc.0

package/dist/video-selfie.d.ts

@@ -5,7 +5,7 @@ import "./Actor-iTq7YY48.js";
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
 import { t as DetectionOrientation } from "./IIdCaptureCapability-RNiFhvXR.js";
-import { a as FacingMode, i as CameraCompositor, n as VideoSelfieDetectionStatus, o as VideoSelfieConfig, r as VideoSelfieValidationFailure, s as VideoSelfieStep, t as StepDetector } from "./videoSelfieStepDetector-Co0Gu2k2.js";
+import { a as FacingMode, i as CameraCompositor, n as VideoSelfieDetectionStatus, o as VideoSelfieConfig, r as VideoSelfieValidationFailure, s as VideoSelfieStep, t as StepDetector } from "./videoSelfieStepDetector-CAqAG2G3.js";
 //#region ../infra/src/capabilities/ITimerCapability.d.ts
 type TimerHandle = ReturnType<typeof setTimeout>;
 type ITimerCapability = {
@@ -15,6 +15,62 @@ type ITimerCapability = {
   clearInterval(handle: TimerHandle): void;
 };
 //#endregion
+//#region ../infra/src/capabilities/IMultipartRecordingCapability.d.ts
+/**
+ * A single chunk of a recording, ready to be uploaded as one S3 multipart
+ * part. `partNumber` is 1-based and strictly increasing across a recording.
+ */
+type MultipartRecordingPart = {
+  partNumber: number;
+  chunk: Blob;
+};
+/**
+ * Records a `MediaStream` and emits it as a sequence of size-bounded parts
+ * (suitable for S3 multipart upload) instead of one blob at the end. Every
+ * part except the last is guaranteed to be at least the S3 minimum part size;
+ * the final part (flushed on stop) may be smaller.
+ *
+ * The capability owns only the recording/buffering mechanics — it has no
+ * knowledge of HTTP. Callers upload each emitted part themselves via `onPart`.
+ */
+type IMultipartRecordingCapability = {
+  readonly isRecording: boolean;
+  readonly hasError: boolean;
+  readonly error: string | null;
+  /**
+   * Start recording `stream`. `onPart` fires once per part: whenever the
+   * internal buffer crosses the part-size threshold during recording, and once
+   * more for the remaining buffer when `stopRecording` is called.
+   */
+  startRecording(stream: MediaStream, onPart: (part: MultipartRecordingPart) => void): void;
+  /**
+   * Temporarily stop gathering media into the current recording without
+   * finalizing its container. Returns whether the recorder is paused.
+   * Video Selfie requires this operation; omission is treated as a failed
+   * pause. It remains optional for compatibility with other consumers.
+   */
+  pauseRecording?(): boolean;
+  /**
+   * Continue gathering media into a recording previously paused with
+   * `pauseRecording`. Returns whether the recorder is recording again.
+   * Video Selfie requires this operation; omission is treated as a failed
+   * resume. It remains optional for compatibility with other consumers.
+   */
+  resumeRecording?(): boolean;
+  /**
+   * Stop recording, flush the remaining buffer as the final part (via the
+   * `onPart` callback passed to `startRecording`), and resolve once the
+   * recorder has fully stopped and that final part has been emitted.
+   */
+  stopRecording(): Promise<void>;
+  /**
+   * Discard an in-progress recording without flushing: stops the recorder and
+   * releases its (cloned) stream tracks, drops buffered data, and clears error
+   * state. Idempotent — safe after `stopRecording` or when never started.
+   */
+  reset(): void;
+};
+//#endregion
 //#region src/internal/recordings/videoSelfieUploadService.d.ts
 /** What the multipart upload records. Must be sent on every protocol call. */
 type VideoUploadScope = 'videoselfie' | 'selfie' | 'frontId' | 'backId';
@@ -46,14 +102,16 @@ type MultipartRecordingResult = {
  */
 declare class MultipartRecordingService {
   private readonly scope;
-  private recorder;
+  private readonly recorder;
   private timer;
   private session;
   private uploader;
   private chunksEmitted;
   private stopPromise;
   private abandonRequested;
-  constructor(scope?: VideoUploadScope);
+  constructor(scope?: VideoUploadScope,
+  /** Recordings encoded in the compositor worker pass their own recorder. */
+  recorder?: IMultipartRecordingCapability);
   get isRecording(): boolean;
   start(stream: MediaStream): Promise<void>;
   /** Pause the current media container without finalizing its upload. */

package/dist/video-selfie.esm.js

@@ -1,15 +1,15 @@
-import { r as WasmUtilProvider } from "./safeStorage-B-trhxg6.esm.js";
-import { t as ensureWasmPipelines } from "./setup-BttZ27hw.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-BdU9_m2E.esm.js";
+import { t as ensureWasmPipelines } from "./setup-B7SYuqoY.esm.js";
 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-B-3Q-LUw.esm.js";
-import { d as facingModeForStep, f as resolveVideoSelfieSteps, p as videoSelfieWasmPipelines } from "./flowServices-C8CBt9j3.esm.js";
+import { d as facingModeForStep, f as resolveVideoSelfieSteps, p as videoSelfieWasmPipelines } from "./flowServices-CNiY5wWB.esm.js";
 import { i as assign, r as sendTo, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-BrJN1B8A.esm.js";
-import { n as CameraCompositor, t as MultipartRecordingService } from "./multipartRecordingService-DDAOXQKm.esm.js";
+import { i as createRecordingCompositor, n as WorkerEncoderRecordingProvider, t as MultipartRecordingService } from "./multipartRecordingService-mwKFTlhR.esm.js";
 import { t as VIDEO_SELFIE_VALIDATION_ATTEMPTS_EXHAUSTED_CODE } from "./advanceableErrors-CpF2cBy6.esm.js";
-import { a as isConnectionError, n as defaultAcquireCamera, r as createDefaultStepDetector, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-BpaLtLvD.esm.js";
+import { a as isConnectionError, n as defaultAcquireCamera, r as createDefaultStepDetector, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-BkqnZgEK.esm.js";
 import { t as videoSelfieFlowModuleMachine } from "./videoSelfieFlowModuleMachine-BUe2uACW.esm.js";
 //#region src/modules/video-selfie/videoSelfieWasm.ts
 function warmupVideoSelfieWasm(config, steps = resolveVideoSelfieSteps(config)) {
@@ -28,6 +28,17 @@ function recordingIdFromEvent(event) {
 function errorFromEvent(event) {
 	return String(event.error);
 }
+/**
+* Chromium reports a camera the device cannot open right now as
+* `NotReadableError` ("Could not start video source") or `AbortError`
+* ("Starting videoinput failed") — the same pair the rear-camera acquire
+* retries on. Anything else (permission, no device) will not clear by
+* releasing our own camera.
+*/
+function isCameraBusyError(error) {
+	const name = typeof error === "object" && error !== null && "name" in error ? error.name : void 0;
+	return name === "NotReadableError" || name === "AbortError";
+}
 function detectionStatusFromEvent(event) {
 	return event.status;
 }
@@ -47,6 +58,12 @@ function orientationFromEvent(event) {
 	return event.orientation;
 }
 const SWITCHING_CAMERA_MIN_DWELL_MS = 3e3;
+/**
+* How long a just-stopped camera gets to release before another one is
+* opened (see `releasingCamera`). Same settle the rear-camera acquire uses
+* on a busy device; a hardware knob, not a protocol value.
+*/
+const CAMERA_RELEASE_SETTLE_MS = 300;
 const ID_FLIP_DWELL_MS = 4e3;
 const FINAL_SUCCESS_DWELL_MS = 3e3;
 const MAX_VIDEO_LENGTH_ERROR_DWELL_MS = 3e3;
@@ -86,6 +103,9 @@ function waitForDwell(ms, signal) {
 *                                                        │
 *                                                        ▼
 *                              recording ⇄ switchingCamera
+*                                  │            │ busy camera (ENG-57332)
+*                                  │            ▼
+*                                  │      releasingCamera ─settle▶ retry once
 *                                  │ (capture validated → DETECTION_DONE,
 *                                  │  or manual NEXT_STEP)
 *                         last step ─▶ finalizing ─▶ finished
@@ -110,7 +130,8 @@ const videoSelfieRecordingSetup = setup({
 		ID_FLIP_DWELL: ID_FLIP_DWELL_MS,
 		FINAL_SUCCESS_DWELL: FINAL_SUCCESS_DWELL_MS,
 		MAX_VIDEO_LENGTH_ERROR_DWELL: MAX_VIDEO_LENGTH_ERROR_DWELL_MS,
-		VALIDATION_FEEDBACK_DWELL: VALIDATION_FEEDBACK_DWELL_MS
+		VALIDATION_FEEDBACK_DWELL: VALIDATION_FEEDBACK_DWELL_MS,
+		CAMERA_RELEASE_SETTLE: CAMERA_RELEASE_SETTLE_MS
 	},
 	actors: {
 		prepareWasm: fromPromise(async ({ input }) => input.ensure()),
@@ -219,7 +240,8 @@ const videoSelfieRecordingSetup = setup({
 		advanceStep: assign({
 			stepIndex: ({ context }) => context.stepIndex + 1,
 			attemptsRemaining: ({ context }) => context.attemptsPerStep,
-			validationFailure: () => void 0
+			validationFailure: () => void 0,
+			cameraSwitchRetried: () => false
 		}),
 		setDetectionStatus: assign({ detectionStatus: ({ event }) => detectionStatusFromEvent(event) }),
 		setOrientation: assign({ orientation: ({ event }) => orientationFromEvent(event) }),
@@ -263,6 +285,7 @@ const videoSelfieRecordingSetup = setup({
 		}),
 		resetSession: assign(({ context }) => ({
 			stepIndex: 0,
+			cameraSwitchRetried: false,
 			stream: void 0,
 			composite: void 0,
 			detectionStatus: void 0,
@@ -299,7 +322,10 @@ const videoSelfieRecordingSetup = setup({
 		setPauseError: assign({
 			error: () => "Recording could not be paused before backgrounding",
 			errorKind: () => "technical"
-		})
+		}),
+		releaseCurrentVideo: ({ context }) => {
+			context.stream?.getVideoTracks().forEach((track) => track.stop());
+		}
 	},
 	guards: {
 		shouldEnterWasmGate: ({ context }) => context.ensureWasmReady !== void 0 && context.errorKind !== "maxVideoLengthReached" && context.errorKind !== "validationAttemptsExhausted",
@@ -311,6 +337,7 @@ const videoSelfieRecordingSetup = setup({
 		maxVideoLengthWasReached: ({ context }) => context.errorKind === "maxVideoLengthReached",
 		validationAttemptsWereExhausted: ({ context }) => context.errorKind === "validationAttemptsExhausted",
 		errorIsRetryable: ({ context }) => context.errorKind !== "maxVideoLengthReached" && context.errorKind !== "validationAttemptsExhausted",
+		canRetryCameraSwitchAfterRelease: ({ context, event }) => !context.cameraSwitchRetried && isCameraBusyError(event.error),
 		pageIsHidden: ({ context }) => !context.isPageVisible,
 		pauseFailed: ({ event }) => !event.output,
 		pauseSucceededWhileVisible: ({ context, event }) => context.isPageVisible && event.output,
@@ -347,9 +374,10 @@ const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 	initial: "idle",
 	context: ({ input }) => {
 		const visibilityObserver = input.visibilityObserver;
+		const compositor = input.dependencies?.createCompositor?.() ?? createRecordingCompositor();
 		return {
-			service: input.dependencies?.createRecordingService?.() ?? new MultipartRecordingService(),
-			compositor: input.dependencies?.createCompositor?.() ?? new CameraCompositor(),
+			service: input.dependencies?.createRecordingService?.() ?? new MultipartRecordingService("videoselfie", new WorkerEncoderRecordingProvider(compositor)),
+			compositor,
 			acquireCamera: input.dependencies?.acquireCamera ?? defaultAcquireCamera,
 			ensureWasmReady: input.ensureWasmReady,
 			detect: input.dependencies?.detect ?? manualStepDetector,
@@ -371,7 +399,8 @@ const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 			recordingId: null,
 			error: void 0,
 			errorKind: void 0,
-			switchingCameraMinDwellMs: input.dependencies?.switchingCameraMinDwellMs ?? SWITCHING_CAMERA_MIN_DWELL_MS
+			switchingCameraMinDwellMs: input.dependencies?.switchingCameraMinDwellMs ?? SWITCHING_CAMERA_MIN_DWELL_MS,
+			cameraSwitchRetried: false
 		};
 	},
 	invoke: [{
@@ -542,12 +571,29 @@ const videoSelfieRecordingMachine = videoSelfieRecordingSetup.createMachine({
 						context.compositor.switchVideo(eventOutputStream(event));
 					}, assign({ stream: ({ event }) => eventOutputStream(event) })]
 				},
-				onError: {
+				onError: [{
+					target: "releasingCamera",
+					guard: "canRetryCameraSwitchAfterRelease"
+				}, {
 					target: "error",
 					actions: assign({ error: ({ event }) => errorFromEvent(event) })
-				}
+				}]
 			}
 		},
+		releasingCamera: {
+			entry: ["releaseCurrentVideo", assign({ cameraSwitchRetried: () => true })],
+			on: {
+				BACKGROUND: {
+					target: "pausing",
+					actions: ["markPageHidden", assign({ resumeState: () => "switchingCamera" })]
+				},
+				MAX_VIDEO_LENGTH_REACHED: {
+					target: "finalizing",
+					actions: "setMaxVideoLengthReached"
+				}
+			},
+			after: { CAMERA_RELEASE_SETTLE: { target: "switchingCamera" } }
+		},
 		pausing: {
 			on: { MAX_VIDEO_LENGTH_REACHED: { actions: "setMaxVideoLengthReached" } },
 			invoke: {
@@ -838,7 +884,7 @@ function createVideoSelfieRecordingActor(visibilityObserver, options = {}) {
 function mapState(snapshot) {
 	const value = typeof snapshot.value === "string" ? snapshot.value : "idle";
 	const { context } = snapshot;
-	const status = value === "preparingWasm" || value === "acquiringCamera" ? "starting" : value === "pausing" || value === "suspended" || value === "resumingCompositor" || value === "reacquiringCamera" || value === "validatingRecoveredCamera" || value === "resumingRecorder" ? "recording" : value;
+	const status = value === "preparingWasm" || value === "acquiringCamera" ? "starting" : value === "pausing" || value === "suspended" || value === "resumingCompositor" || value === "reacquiringCamera" || value === "validatingRecoveredCamera" || value === "resumingRecorder" ? "recording" : value === "releasingCamera" ? "switchingCamera" : value;
 	const steps = context.steps;
 	const stepIndex = context.stepIndex;
 	return {

package/dist/{videoSelfieCameraWarmer-BpaLtLvD.esm.js → videoSelfieCameraWarmer-BkqnZgEK.esm.js}

@@ -1,16 +1,16 @@
 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-B-3Q-LUw.esm.js";
-import { d as facingModeForStep, f as resolveVideoSelfieSteps } from "./flowServices-C8CBt9j3.esm.js";
+import { d as facingModeForStep, f as resolveVideoSelfieSteps } from "./flowServices-CNiY5wWB.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-C7bUZsH9.esm.js";
+import { t as checkPermission } from "./permissionServices-EY3_Vx6c.esm.js";
+import { n as encryptSelfieImage, o as startDetection, t as FaceDetectionProvider } from "./FaceDetectionProvider-D8jRHN4h.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
-import { t as StreamCanvasProcessingSession } from "./StreamCanvasProcessingSession-CBnbTnOr.esm.js";
+import { o as StreamCanvasProcessingSession } from "./multipartRecordingService-mwKFTlhR.esm.js";
 import { n as getBackCameraStream } from "./backCameraStream-B0-YgP_y.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-DCmwAxkz.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-DVLnrTXL.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-C9jtgBdT.esm.js";
 //#region src/modules/video-selfie/videoSelfieCompareService.ts
 async function postVideoSelfieCompare(endpoint, base64Image) {

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

@@ -29,6 +29,19 @@ type FacingMode = 'user' | 'environment';
 //#region ../infra/src/media/CameraCompositor.d.ts
 type CameraCompositorOptions = {
   fps?: number;
+  maxLongEdge?: number;
+  maxShortEdge?: number;
+  /** Worker transport: drop frames to hold the output at `fps`. */
+  paceWorkerFrames?: boolean;
+  /**
+   * Worker transport: record by encoding inside the worker (see
+   * {@link CameraCompositor.startWorkerRecording}) instead of handing the
+   * composite stream to a `MediaRecorder`.
+   */
+  encodeInWorker?: {
+    bitrate: number;
+    timesliceMs: number;
+  };
   resumeTimeoutMs?: number;
 };
 type CameraCompositorResumeResult = 'resumed' | 'video-ended' | 'audio-ended' | 'timed-out';
@@ -50,6 +63,10 @@ type CameraCompositorResumeResult = 'resumed' | 'video-ended' | 'audio-ended' |
  *    `captureStream`, for Safari, Firefox and strict-CSP hosts that block blob
  *    workers.
  *
+ * With `encodeInWorker`, the worker transport also records: it encodes and
+ * muxes the WebM itself (see `startWorkerRecording`), so no `MediaRecorder`
+ * — which needs the main thread for every frame — is involved.
+ *
  * 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
@@ -62,6 +79,14 @@ declare class CameraCompositor {
   private readonly fps;
   private readonly frameIntervalMs;
   private readonly resumeTimeoutMs;
+  private readonly maxLongEdge;
+  private readonly maxShortEdge;
+  private readonly paceWorkerFrames;
+  private readonly encodeInWorker;
+  private workerEncoding;
+  private onWorkerPart;
+  private workerRecordingError;
+  private workerRecordingStopped;
   private canvas;
   private ctx;
   private video;
@@ -90,6 +115,30 @@ declare class CameraCompositor {
    * video track is stopped.
    */
   switchVideo(stream: CameraStream): void;
+  /**
+   * True when this compositor records by itself: the worker transport started
+   * with `encodeInWorker` and the browser has `VideoEncoder`. Use the
+   * `*WorkerRecording` methods instead of a `MediaRecorder` then; the
+   * composite stream receives no frames.
+   */
+  get encodesInWorker(): boolean;
+  /** Last in-worker encoder error, if any. */
+  get workerRecordingErrorMessage(): string | null;
+  /**
+   * Start a new WebM recording inside the worker. `onPart` receives whole
+   * WebM clusters (~`timesliceMs` each, keyframe first; the first part also
+   * carries the header), in order. Returns false when not encoding in-worker.
+   */
+  startWorkerRecording(onPart: (chunk: Blob) => void): boolean;
+  pauseWorkerRecording(): boolean;
+  resumeWorkerRecording(): boolean;
+  /**
+   * Flush the encoder and resolve once every part has reached `onPart`.
+   * Resolves at once if the worker is gone (its buffered frames are lost).
+   */
+  stopWorkerRecording(): Promise<void>;
+  /** Stop in-worker recording and drop whatever it still emits. */
+  cancelWorkerRecording(): void;
   /** The composite stream being recorded, if compositing is active. */
   get stream(): MediaStream | undefined;
   /** Pause source playback and drawing while the page is backgrounded. */

package/dist/{warmup-CUUnwYxe.esm.js → warmup-ChDwHSel.esm.js}

@@ -363,6 +363,11 @@ var WasmRuntime = class WasmRuntime {
 	captureProtectedFrame(target) {
 		return this.requireCameraCycleApi("Unable to capture protected frame, cpp API hasn't been initialized").mcp(target);
 	}
+	/**
+	* @deprecated Unused by SDK 2 production flows.
+	* Retained for compatibility; avoid new uses.
+	* Candidate for removal after a compatibility review.
+	*/
 	paintFrameToCanvas(canvas, options) {
 		return this.requireCameraCycleApi("Unable to paint frame, cpp API hasn't been initialized").pfc(canvas, options);
 	}

package/dist/wasm.d.ts

@@ -1,5 +1,5 @@
 import { a as WASM_MODEL_FILES, c as WasmPipeline, l as WasmSource, o as WasmGlueLoader, r as warmupWasm, s as WasmModelName, t as WarmupConfig } from "./warmup-Cis2p6O0.js";
-import { c as setWasmConfig, i as initializeWasmUtil, n as WasmConfig, r as ensureWasmPipelines, s as resolveWasmConfigForPipelines, u as upgradeToWasmHttpClient } from "./setup-CLfBztP0.js";
+import { c as setWasmConfig, i as initializeWasmUtil, n as WasmConfig, r as ensureWasmPipelines, s as resolveWasmConfigForPipelines, u as upgradeToWasmHttpClient } from "./setup-Cyko6cAn.js";
 //#region ../infra/src/wasm/wasmDefaults.d.ts
 /** The WASM version bundled and tested with this SDK release. */
 declare const DEFAULT_WASM_VERSION = "v2.14.50-post1";

package/dist/wasm.esm.js

@@ -1,7 +1,7 @@
 import { g as WASM_PIPELINE_MODEL_NAMES, m as WASM_PIPELINE_LAZY_MODEL_NAMES, p as WASM_MODEL_FILES } from "./wasmWebClient-B7baE-Wf.esm.js";
-import { D as buildWasmConfigFromBasePath, E as buildDefaultWasmConfig, T as DEFAULT_WASM_VERSION, k as resolveWasmConfig } from "./trueSightService-C1JG8gAU.esm.js";
-import { o as warmupWasm } from "./warmup-CUUnwYxe.esm.js";
-import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-BttZ27hw.esm.js";
+import { C as DEFAULT_WASM_VERSION, D as resolveWasmConfig, T as buildWasmConfigFromBasePath, w as buildDefaultWasmConfig } from "./trueSightService-C8uCAIC0.esm.js";
+import { o as warmupWasm } from "./warmup-ChDwHSel.esm.js";
+import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-B7SYuqoY.esm.js";
 //#region src/defineWasm.ts
 function requiredModels(pipelines) {
 	const models = /* @__PURE__ */ new Set();

package/dist/{wasmDsFlagSync-B2e8p268.esm.js → wasmDsFlagSync-DYrLUEII.esm.js}

@@ -1,4 +1,4 @@
-import { a as utilityWasmApi } from "./safeStorage-B-trhxg6.esm.js";
+import { a as utilityWasmApi } from "./safeStorage-BdU9_m2E.esm.js";
 //#region ../infra/src/wasm/wasmDsFlagSync.ts
 /**
 * Sets the Deepsight (ds) flag that the WASM utility API receives on every

package/dist/workflow.d.ts

@@ -334,10 +334,6 @@ declare const workflowMachine: StateMachine<WorkflowContext, {
     id: string | undefined;
   };
 }>, Values<{
-  setError: {
-    type: "setError";
-    params: NonReducibleUnknown;
-  };
   setLoadingResult: {
     type: "setLoadingResult";
     params: NonReducibleUnknown;
@@ -370,6 +366,10 @@ declare const workflowMachine: StateMachine<WorkflowContext, {
     type: "setFinishStatusFailed";
     params: NonReducibleUnknown;
   };
+  setError: {
+    type: "setError";
+    params: NonReducibleUnknown;
+  };
   setModuleError: {
     type: "setModuleError";
     params: NonReducibleUnknown;

package/dist/workflow.esm.js

@@ -1,29 +1,29 @@
-import { l as trueSightLog } from "./trueSightService-C1JG8gAU.esm.js";
-import { E as updateFeatureManagementUser } from "./feature-management-BjROP6fF.esm.js";
+import { l as trueSightLog } from "./trueSightService-C8uCAIC0.esm.js";
+import { E as updateFeatureManagementUser } from "./feature-management-Dcf2FRH5.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { n as eventModuleNames, o as createManagerInstrumentation, v as addEvent } from "./events-ijlbX_Wx.esm.js";
-import { i as initializeSession, r as getSessionFingerprintResult } from "./sessionInitializer-DSf0jyab.esm.js";
+import { i as initializeSession, r as getSessionFingerprintResult } from "./sessionInitializer-Dibh2aVX.esm.js";
 import { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
-import { i as toIncodeApiError } from "./apiError-BWlcyGbw.esm.js";
-import { v as toEkybConfig } from "./flowServices-C8CBt9j3.esm.js";
+import { i as toIncodeApiError } from "./apiError-DU8CQkWE.esm.js";
+import { v as toEkybConfig } from "./flowServices-CNiY5wWB.esm.js";
 import { i as toEkycConfig } from "./ekycUtils-Dew1rBG0.esm.js";
 import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { r as electronicSignatureMachine } from "./electronicSignatureManager-BnlLBzH6.esm.js";
+import { r as electronicSignatureMachine } from "./electronicSignatureManager-BtqP3PP0.esm.js";
 import "./ae-signature.esm.js";
 import { t as antifraudMachine } from "./antifraudStateMachine-DBeq47D2.esm.js";
-import { t as authenticationMachine } from "./authenticationStateMachine-CSJtf13E.esm.js";
+import { t as authenticationMachine } from "./authenticationStateMachine-DSw9ZBW1.esm.js";
 import { t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-CxqS_nD-.esm.js";
 import { t as consentMachine } from "./consentStateMachine-DTSfdGiW.esm.js";
 import { t as curpValidationMachine } from "./curpValidationStateMachine-g5kMfuLj.esm.js";
 import { t as customWatchlistMachine } from "./customWatchlistStateMachine-DOQou6TW.esm.js";
-import { t as documentCaptureMachine } from "./documentCaptureStateMachine-DN2YOxdu.esm.js";
-import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-B00MVHEa.esm.js";
-import { t as ekybMachine } from "./ekybStateMachine-DHCg1B5d.esm.js";
+import { t as documentCaptureMachine } from "./documentCaptureStateMachine-D312sSIu.esm.js";
+import { t as dynamicFormsMachine } from "./dynamicFormsStateMachine-BCfL75y-.esm.js";
+import { t as ekybMachine } from "./ekybStateMachine-CzQJIO_S.esm.js";
 import { t as ekycMachine } from "./ekycStateMachine-CshSNJhh.esm.js";
 import { t as emailMachine } from "./emailStateMachine-Bc_6oIYw.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-BhzbXmKN.esm.js";
-import { t as idCaptureMachine } from "./idCaptureStateMachine-Du4Q40uJ.esm.js";
+import { t as selfieMachine } from "./selfieStateMachine-ZL9XxTzt.esm.js";
+import { t as idCaptureMachine } from "./idCaptureStateMachine-C24Jr35L.esm.js";
 import { t as phoneMachine } from "./phoneStateMachine-CXdXufKg.esm.js";
 import { t as watchlistMachine } from "./watchlistStateMachine-CBqk2w-h.esm.js";
 import { t as watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-CJ-MvUre.esm.js";
@@ -32,12 +32,12 @@ import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-DC5
 import { t as idOcrStateMachine } from "./idOcrStateMachine-ClDEP-VI.esm.js";
 import { n as redirectToMobileMachine } from "./redirectToMobileStateMachine-CSWWgUTO.esm.js";
 import { t as signatureMachine } from "./signatureStateMachine-ce_XMA3l.esm.js";
-import { t as geolocationMachine } from "./geolocationStateMachine-BfNIvTHA.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-DAy93DQ2.esm.js";
 import { t as governmentValidationMachine } from "./governmentValidationStateMachine-CoaZOSTP.esm.js";
 import { t as idVerificationMachine } from "./idVerificationStateMachine-DbDVIh9t.esm.js";
 import { t as faceMatchMachine } from "./faceMatchStateMachine-mRIHQ3dA.esm.js";
-import { n as getFinishStatus, r as getTotalScoreStatus } from "./flowCompletionService-iyH7fw8r.esm.js";
-import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-CHjWYSMf.esm.js";
+import { n as getFinishStatus, r as getTotalScoreStatus } from "./flowCompletionService-CbWu7-Vz.esm.js";
+import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-AxF5Q7ag.esm.js";
 import { n as isAdvanceableError } from "./advanceableErrors-CpF2cBy6.esm.js";
 import "./qe-signature.esm.js";
 import { t as videoSelfieFlowModuleMachine } from "./videoSelfieFlowModuleMachine-BUe2uACW.esm.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@incodetech/core",
-  "version": "2.3.0-rc.9",
+  "version": "2.3.1-rc.0",
   "license": "ISC",
   "repository": {
     "type": "git",
@@ -50,11 +50,6 @@
       "types": "./dist/id-selfie-flow.d.ts",
       "import": "./dist/id-selfie-flow.esm.js"
     },
-    "./personhood": {
-      "source": "./src/modules/personhood/index.ts",
-      "types": "./dist/personhood.d.ts",
-      "import": "./dist/personhood.esm.js"
-    },
     "./authentication": {
       "source": "./src/modules/authentication/index.ts",
       "types": "./dist/authentication.d.ts",
@@ -277,7 +272,7 @@
     "typescript": "^5.9.3",
     "vitest": "4.1.10",
     "@incodetech/config": "1.0.2",
-    "@incodetech/infra": "1.3.0"
+    "@incodetech/infra": "1.4.0"
   },
   "scripts": {
     "build": "tsdown -c tsdown.config.ts",

package/dist/FaceDetectionProvider-LdZ47bWy.d.ts

@@ -1,36 +0,0 @@
-import { c as FaceAttributesThresholds, d as FaceDetectionCallbacks, f as FaceDetectionConfig, h as IFaceDetectionCapability, l as FaceChecksConfig, m as FacePositionConstraints, p as FaceDetectionThresholds, v as WebApiHostRequestConfig } from "./createFaceAvatar-BlcTYgJv.js";
-import { t as BaseWasmProvider } from "./BaseWasmProvider-Dyi6dKp1.js";
-//#region ../infra/src/providers/wasm/FaceDetectionProvider.d.ts
-declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
-  private defaultThresholds;
-  private currentThresholds;
-  private currentFrame;
-  private onFaceDataCallback;
-  constructor();
-  processFrame(image: ImageData): Promise<void>;
-  initialize(config: FaceDetectionConfig): Promise<void>;
-  /**
-   * Last-registered onCapture callback — captured into a private
-   * field so `forceCapture()` (called from outside the WASM-callback
-   * lifecycle) can re-fire the same wrapper. `setCallbacks` rebinds
-   * this on each invocation, so the field always reflects the
-   * current consumer.
-   */
-  private currentOnCaptureWrapper;
-  processPhoto(canvas: HTMLCanvasElement): void;
-  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
-  setCallbacks(callbacks: FaceDetectionCallbacks): void;
-  setPositionConstraints(constraints: FacePositionConstraints): void;
-  applyDefaults(autocaptureInterval?: number): void;
-  setAutocaptureInterval(interval: number): void;
-  setThresholds(thresholds: FaceDetectionThresholds): void;
-  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
-  setChecksEnabled(config: FaceChecksConfig): void;
-  setVideoSelfieMode(enabled: boolean): void;
-  forceCapture(): void;
-  reset(): void;
-  private createDefaultFaceCoordinates;
-  private formatFaceCoordinates;
-}
-//#endregion
-export { FaceDetectionProvider as t };

package/dist/StreamCanvasProcessingSession-CBnbTnOr.esm.js

@@ -1,42 +0,0 @@
-//#region ../infra/src/media/StreamCanvasProcessingSession.ts
-var StreamCanvasProcessingSession = class {
-	/**
-	* Creates a processing session that reacts to `StreamCanvasCapture` frame events
-	* and drives a provider's `processFrame()` method with backpressure.
-	*/
-	constructor(params) {
-		this.disposed = false;
-		this.isProcessing = false;
-		this.onFrameEvent = () => {
-			if (this.disposed || this.isProcessing) return;
-			const frame = this.capturer.getLatestFrame();
-			if (!frame) return;
-			this.onFrame?.(frame);
-			this.isProcessing = true;
-			this.provider.processFrame(frame).catch(() => {}).finally(() => {
-				this.isProcessing = false;
-			});
-		};
-		this.capturer = params.capturer;
-		this.provider = params.provider;
-		this.onFrame = params.onFrame;
-		this.capturer.addEventListener("frame", this.onFrameEvent);
-	}
-	/**
-	* Unsubscribes from frame events and resets the provider.
-	*/
-	dispose() {
-		if (this.disposed) return;
-		this.disposed = true;
-		this.capturer.removeEventListener("frame", this.onFrameEvent);
-		this.provider.reset();
-	}
-	/**
-	* Returns whether the session has been disposed.
-	*/
-	isDisposed() {
-		return this.disposed;
-	}
-};
-//#endregion
-export { StreamCanvasProcessingSession as t };