@incodetech/core 2.1.1 → 2.2.0-rc.1

package/dist/IIdCaptureCapability-DHTT3FC2.d.ts

@@ -0,0 +1,237 @@
+import { a as MLProviderConfig, i as IMLProviderCapability, o as IncodeCanvas } from "./IStorageCapability-ORkQfK3F.js";
+//#region ../infra/src/wasm/apiUtilities.d.ts
+/**
+ * Shared WASM module loader.
+ *
+ * The pinned `webLib.wasm` (see `wasmDefaults.ts`) bundles BOTH the ML pipeline
+ * APIs (used by `mlWasmJSApi.ts`) AND a C++ `WebClient` HTTP client (used by
+ * `wasmWebClient.ts`). Both consumers must share a single instantiated
+ * `wasmModule` — calling the glue `Module()` factory twice would re-instantiate
+ * the WASM heap and produce divergent state.
+ *
+ * This module memoizes the load: the first caller (whichever arrives first —
+ * ML init or HTTP init) triggers the fetch + glue load, and subsequent callers
+ * await the same promise. Idempotent on success; on failure, the singleton is
+ * cleared so the next caller retries.
+ *
+ * SIMD fallback mirrors the legacy behavior: try the SIMD binary + SIMD glue
+ * (`webLibSimd.js` + `webLibSimd.wasm`) first, fall back to the non-SIMD pair
+ * (`webLib.js` + `webLib.wasm`) on instantiation failure. Each binary MUST be
+ * paired with its matching glue — the CDN ships them as paired artifacts and
+ * mixing them produces an unusable module.
+ */
+declare global {
+  interface Window {
+    Module?: WasmGlueFactory;
+    wasmArrayBuffer: Uint8Array | null;
+  }
+}
+/** Opaque handle for the loaded WASM module instance. */
+type WasmModule = Record<string, unknown>;
+type WasmGlueFactory = () => Promise<WasmModule>;
+//#endregion
+//#region ../infra/src/wasm/mlWasmBridgeTypes.d.ts
+/**
+ * Decoded PDF417 barcode surfaced from the WASM ID-capture pipeline during
+ * US Smart Capture. Mirrors SDK 1's `Pdf417DecodeResult`.
+ */
+type Pdf417DecodeResult = {
+  text: string;
+  ecLevel: string;
+  rowNumber: number;
+  columnNumber: number;
+  codewordLengthInPixelsMin: number;
+  codewordLengthInPixelsMax: number;
+  correctedErrorsCount: number;
+};
+//#endregion
+//#region ../infra/src/capabilities/IIdCaptureCapability.d.ts
+/**
+ * Configuration for ID capture provider.
+ * Extends base ML provider config with ID-capture specific options.
+ */
+interface IdCaptureConfig extends MLProviderConfig {
+  /**
+   * Load the video-selfie ID workflow (`IdVideoSelfiePipeline`, the simplified
+   * ID-capture pipeline without a capturing-manager timer, used by the
+   * video-selfie flow) instead of the default blur/glare ID pipeline.
+   */
+  videoSelfie?: boolean;
+}
+interface IdCaptureThresholds {
+  blurThreshold: number;
+  blurChangeThreshold: number;
+  glareThreshold: number;
+  clsThreshold: number;
+  sideThreshold: number;
+  iouThreshold: number;
+  idDetectedTimeout: number;
+  autocaptureTimeout: number;
+  framesAggregationInterval: number;
+}
+interface IdCaptureGeometry {
+  areaDown: number;
+  areaUp: number;
+  areaIOSPassportUp: number;
+  areaIOSPassportDown: number;
+  widthIOSUp: number;
+  widthIOSDown: number;
+  widthDown: number;
+  widthUp: number;
+  windowOuterWidth: number;
+  windowOuterHeight: number;
+  windowInnerWidth: number;
+  windowInnerHeight: number;
+}
+interface IdCaptureSettings {
+  isFixedMask: boolean;
+  isIPhone14OrHigher: boolean;
+  idType: string;
+  blurCheckEnabled: boolean;
+  glareCheckEnabled: boolean;
+  faceQualityCheckEnabled: boolean;
+  iouCheckEnabled: boolean;
+  fpsLimitEnabled: boolean;
+}
+type IdCaptureModelType = 'v1' | 'v2' | 'v3';
+type DetectionOrientation = 'horizontal' | 'vertical';
+interface IdCaptureCallbacks {
+  onFarAway?: () => void;
+  onDetectionStarted?: () => void;
+  onMaskChange?: (show: boolean, mask: boolean, top: number, orientation: DetectionOrientation) => void;
+  onBlur?: () => void;
+  onGlare?: () => void;
+  onCapturing?: () => void;
+  onCapture?: () => void;
+  onBestFrame?: (blur: number, glare: number, orientation: string) => void;
+  onIdNotDetected?: () => void;
+  onSwitchToManualCapture?: () => void;
+  onIdTypeChange?: (idType: string) => void;
+  onIdSideChange?: (side: string) => void;
+  onCapturingCounterValueChange?: (value: number) => void;
+  /**
+   * Fires when the WASM pipeline decodes a PDF417 barcode from the back of the
+   * ID during US Smart Capture. Only fires when barcode capture is enabled via
+   * `setBarcodeCaptureEnabled(true)`.
+   */
+  onBarcodeDecoded?: (decoded: Pdf417DecodeResult) => void;
+}
+/**
+ * WASM array type for quad coordinates.
+ * Use .get(index) instead of [index] to access elements.
+ */
+interface QuadArray {
+  get(index: number): {
+    x: number;
+    y: number;
+  };
+  size?(): number;
+  length?: number;
+}
+interface IdCaptureProcessResult {
+  cls: number;
+  blur: number;
+  glare: number;
+  quad: QuadArray;
+  barQuad: QuadArray;
+  side: string;
+  size: number;
+  idType: string;
+  networkInferenceTime: number;
+}
+/**
+ * Capability interface for ID document capture.
+ * Extends the base ML provider capability with ID-capture specific methods.
+ */
+interface IIdCaptureCapability extends IMLProviderCapability<IdCaptureConfig> {
+  /**
+   * Sets callbacks for ID capture events.
+   * @param callbacks - Object containing callback functions for various capture events
+   */
+  setCallbacks(callbacks: IdCaptureCallbacks): void;
+  /**
+   * Sets detection thresholds for quality checks.
+   * @param thresholds - Threshold values for blur, glare, and other quality metrics
+   */
+  setThresholds(thresholds: IdCaptureThresholds): void;
+  /**
+   * Sets geometry constraints for ID detection.
+   * @param geometry - Geometry parameters for ID positioning
+   */
+  setGeometry(geometry: IdCaptureGeometry): void;
+  /**
+   * Sets capture settings.
+   * @param settings - Configuration for capture behavior
+   */
+  setSettings(settings: IdCaptureSettings): void;
+  /**
+   * Sets the ML model type to use for ID detection.
+   * @param modelType - Model version ('v1', 'v2', or 'v3')
+   */
+  setModelType(modelType: IdCaptureModelType): void;
+  /**
+   * Gets the last process result from the most recent frame processing.
+   * Returns null if no frame has been processed yet.
+   * @returns The last process result with quad coordinates, or null if not available
+   */
+  getLastProcessResult(): IdCaptureProcessResult | null;
+  /**
+   * Transforms the canvas using perspective correction based on frame coordinates.
+   * @param canvas - The canvas to transform
+   * @param frameRect - Frame rectangle in canvas coordinates (x, y, w, h)
+   * @returns The transformed canvas
+   */
+  transformPerspective(canvas: IncodeCanvas, frameRect: {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  }): IncodeCanvas;
+  /**
+   * Gets the captured canvas (transformed for preview).
+   * @returns The captured canvas, or null if not available
+   */
+  getCapturedCanvas(): IncodeCanvas | null;
+  /**
+   * Gets the original captured canvas (full frame for upload).
+   * @returns The original captured canvas, or null if not available
+   */
+  getOriginalCapturedCanvas(): IncodeCanvas | null;
+  /**
+   * Sets the captured canvases (original and transformed).
+   * Called by the state machine after capture and transformation.
+   * @param original - The original full-frame canvas (for upload)
+   * @param transformed - The transformed canvas (for preview)
+   */
+  setCapturedCanvases(original: IncodeCanvas, transformed: IncodeCanvas): void;
+  /**
+   * Resets WASM detection state while preserving the captured canvases.
+   * Use `reset()` when starting a new capture attempt and the captured result
+   * must also be discarded.
+   */
+  resetDetectionState(): void;
+  /**
+   * Enables/disables on-device PDF417 barcode capture on the detection loop.
+   * Used by US Smart Capture (enabled only on the back side).
+   */
+  setBarcodeCaptureEnabled(enabled: boolean): void;
+  /**
+   * When true, the WASM pipeline auto-captures the frame on barcode decode. The
+   * Flow keeps this false so the JS layer owns the submit decision.
+   */
+  setBarcodeAutoCaptureOnDecode(enabled: boolean): void;
+  /**
+   * Lazily loads the PDF417 enhancement model, resolved from the active WASM
+   * config's models base path (so self-hosted deployments resolve it too).
+   * Resolves to whether the model was applied — best-effort; decode still works
+   * without it. Loaded at most once per provider instance.
+   */
+  setBarcodeEnhancementModel(): Promise<boolean>;
+  /**
+   * The most recently decoded PDF417 barcode, or null if none decoded since the
+   * last reset. Complements the `onBarcodeDecoded` callback.
+   */
+  getLastDecodedBarcode(): Pdf417DecodeResult | null;
+}
+//#endregion
+export { Pdf417DecodeResult as i, IIdCaptureCapability as n, IdCaptureSettings as r, DetectionOrientation as t };

package/dist/IStorageCapability-ORkQfK3F.d.ts

@@ -0,0 +1,242 @@
+//#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/capabilities/IMLProviderCapability.d.ts
+/**
+ * Base configuration shared by all ML provider capabilities.
+ */
+interface MLProviderConfig {
+  /** Path to the WASM binary */
+  wasmPath?: string;
+  /** Path to the SIMD-optimized WASM binary (optional) */
+  wasmSimdPath?: string;
+  /** Path to the WASM glue code (paired with `wasmPath`) */
+  glueCodePath?: string;
+  /**
+   * Path to the SIMD-optimized WASM glue code (paired with `wasmSimdPath`).
+   * If omitted, defaults to a sibling `.js` derived from `wasmSimdPath`.
+   */
+  glueCodeSimdPath?: string;
+  /** Whether to use SIMD optimizations (default: true) */
+  useSimd?: boolean;
+  /**
+   * Base path for ML model files. Models will be loaded from `${modelsBasePath}/${modelFileName}`.
+   * If not provided, models are expected in a 'models' subdirectory relative to the WASM binary.
+   */
+  modelsBasePath?: string;
+}
+/**
+ * Base interface for ML provider capabilities.
+ * Provides common lifecycle and frame processing methods shared by
+ * FaceDetectionCapability and IdCaptureCapability.
+ */
+interface IMLProviderCapability<TConfig extends MLProviderConfig> {
+  /**
+   * Whether the provider has been initialized and is ready to process frames.
+   */
+  readonly initialized: boolean;
+  /**
+   * Initializes the provider with the given configuration.
+   * If WASM was already warmed up via `setup()` or `warmupWasm()`, this returns almost instantly.
+   * @param config - Provider configuration including WASM paths
+   */
+  initialize(config: TConfig): Promise<void>;
+  /**
+   * Processes a frame through the ML pipeline.
+   * Callbacks set via `setCallbacks()` will be invoked based on the analysis results.
+   * @param image - Image data to process
+   * @throws Error if provider is not initialized
+   */
+  processFrame(image: ImageData): Promise<void>;
+  /**
+   * Resets the pipeline to its initial state.
+   * Safe to call even if not initialized (no-op in that case).
+   */
+  reset(): void;
+  /**
+   * Disposes of resources and resets initialization state.
+   * Safe to call even if not initialized.
+   */
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region ../infra/src/capabilities/IRecordingCapability.d.ts
+type RecordingPublisher = {
+  getStreamId: () => string | undefined;
+  replaceVideoTrack: (track: MediaStreamTrack) => Promise<void>;
+  destroy: () => void;
+};
+type RecordingConnection = {
+  sessionId: string | undefined;
+  publisher: RecordingPublisher;
+  disconnect: () => Promise<void>;
+};
+type RecordingConnectionEvents = {
+  onSessionConnected?: (sessionId: string | undefined) => void;
+  onSessionDisconnected?: (sessionId: string | undefined) => void;
+  onSessionException?: (params: {
+    name?: string;
+    message?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherCreated?: (params: {
+    streamId?: string;
+    sessionId?: string;
+  }) => void;
+  onPublisherError?: (params: {
+    message?: string;
+    sessionId?: string;
+    streamId?: string;
+  }) => void;
+};
+type ConnectRecordingParams = {
+  sessionToken: string;
+  stream: MediaStream;
+  events?: RecordingConnectionEvents;
+};
+type IRecordingCapability = {
+  /**
+   * Connects to a recording session and publishes the provided media stream.
+   * Returns a connection handle that can be disconnected and used to manage the publisher.
+   */
+  connect: (params: ConnectRecordingParams) => Promise<RecordingConnection>;
+};
+//#endregion
+//#region ../infra/src/capabilities/IStorageCapability.d.ts
+/**
+ * Storage capability interface for abstracting storage operations.
+ * Enables swapping between browser localStorage and future WASM-based storage.
+ */
+interface IStorageCapability {
+  /**
+   * Retrieves a value from storage.
+   * @param key - The storage key
+   * @returns The stored value or null if not found
+   */
+  get<T>(key: string): Promise<T | null>;
+  /**
+   * Stores a value in storage.
+   * @param key - The storage key
+   * @param value - The value to store (will be serialized)
+   */
+  set<T>(key: string, value: T): Promise<void>;
+  /**
+   * Removes a value from storage.
+   * @param key - The storage key to remove
+   */
+  remove(key: string): Promise<void>;
+  /**
+   * Clears all values from storage.
+   */
+  clear(): Promise<void>;
+}
+//#endregion
+export { MLProviderConfig as a, IMLProviderCapability as i, IRecordingCapability as n, IncodeCanvas as o, RecordingConnection as r, IStorageCapability as t };

package/dist/{ITimerCapability-DJ73P4RK.esm.js → ITimerCapability-DgdDzp8G.esm.js}

@@ -2,6 +2,5 @@
 function sleep(ms) {
 	return new Promise((resolve) => setTimeout(resolve, ms));
 }
-
 //#endregion
-export { sleep as t };
+export { sleep as t };

package/dist/{Manager-goNPc_h_.d.ts → Manager-CQQ99QOI.d.ts}

@@ -1,3 +1,4 @@
+import "./StateMachine-EDpYWy0i.js";
 //#region ../infra/src/manager/Manager.d.ts
 /**
  * Base manager interface providing state access, subscriptions, and lifecycle control.

package/dist/{MotionSensorProvider-BHuHoYvJ.esm.js → MotionSensorProvider-DGiV77J_.esm.js}

@@ -1,38 +1,4 @@
-//#region ../infra/src/storage/safeStorage.ts
-/**
-* Storage resolvers that tolerate hosts which make Web Storage unreachable.
-*
-* Two hostile shapes occur in the field, and they fail differently:
-*
-* 1. **Deleted bare global** — a page mitigates self-XSS with
-*    `delete window.localStorage` and keeps a module-private reference. Since
-*    `window` *is* the global object, the identifier stops resolving: a bare
-*    read throws `ReferenceError`. `typeof` is the only safe probe, because it
-*    is the one operator that tolerates an unresolvable identifier.
-* 2. **Blocked storage** — a webview or a cross-origin/partitioned context
-*    makes the accessor itself throw (`SecurityError`). Here `typeof` is *not*
-*    enough: it invokes the getter, so the throw escapes the guard.
-*
-* Handling only one shape leaves the other live, so always go through these
-* resolvers instead of touching the globals directly. A `null` return means
-* "no storage in this host" — callers degrade, they do not throw.
-*/
-function resolveLocalStorage() {
-	try {
-		return typeof localStorage === "undefined" ? null : localStorage;
-	} catch {
-		return null;
-	}
-}
-function resolveSessionStorage() {
-	try {
-		return typeof sessionStorage === "undefined" ? null : sessionStorage;
-	} catch {
-		return null;
-	}
-}
-
-//#endregion
+import { n as resolveSessionStorage } from "./safeStorage-Ep56I-f_.esm.js";
 //#region ../infra/src/providers/browser/MotionSensorProvider.ts
 const MOTION_PERMISSION_GRANTED_KEY = "motionSensorsPermissionsGranted";
 const MOTION_PERMISSION_DENIED_KEY = "motionSensorsPermissionsDenied";
@@ -337,6 +303,5 @@ var MotionSensorProvider = class MotionSensorProvider {
 		return mae.x < threshold && mae.y < threshold && mae.z < threshold;
 	}
 };
-
 //#endregion
-export { resolveLocalStorage as n, resolveSessionStorage as r, MotionSensorProvider as t };
+export { MotionSensorProvider as t };

package/dist/{OpenViduRecordingProvider-CK6A5kiU.esm.js → OpenViduRecordingProvider-Du98qevC.esm.js}

@@ -1,5 +1,4 @@
-import { t as loadOpenVidu } from "./openviduLazy-wEojM41w.esm.js";
-
+import { loadOpenVidu } from "./openviduLazy-CCDpFWg1.esm.js";
 //#region ../infra/src/providers/browser/OpenViduRecordingProvider.ts
 function createHiddenContainer() {
 	const id = `inc_rec_${Math.random().toString(36).slice(2)}`;
@@ -82,6 +81,5 @@ var OpenViduRecordingProvider = class {
 		};
 	}
 };
-
 //#endregion
-export { OpenViduRecordingProvider };
+export { OpenViduRecordingProvider };