@incodetech/core 0.0.0-dev-20260817-acfa6f73 → 0.0.0-dev-20260817-941e76d2

package/dist/{types-Cyiwbg-r.d.ts → types-RMhiEIm9.d.ts}

@@ -1,82 +1,6 @@
-import { n as WasmPipeline } from "./warmup-Dv2alr2-.js";
-import { a as MLProviderConfig, n as IRecordingCapability, t as IStorageCapability } from "./IStorageCapability-ORkQfK3F.js";
-import { t as AvatarAssetsOverrides } from "./IFaceAvatarCapability-BrL19G0s.js";
-import { n as Flow, s as SelfieConcealmentOption } from "./types-CRw2IBPn.js";
-//#region ../infra/src/capabilities/IWasmUtilCapability.d.ts
-type WasmUtilConfig = MLProviderConfig & {
-  pipelines?: WasmPipeline[];
-};
-type VirtualCameraCheckOutput = {
-  canvas: HTMLCanvasElement | null;
-  itr: boolean | null;
-  skipped: boolean | null;
-};
-type IWasmUtilCapability = {
-  /**
-   * Whether the provider has been initialized and is ready to be used.
-   */
-  readonly initialized: boolean;
-  /**
-   * Initializes the provider with the given configuration.
-   * If WASM was already warmed up via `warmupWasm()`, this returns almost instantly.
-   * @param config - Provider configuration including WASM paths
-   */
-  initialize(config: WasmUtilConfig): Promise<void>;
-  /**
-   * Encrypts a base64 image using the WASM utility API.
-   * @param image - Base64 image string (no data URL prefix)
-   * @returns Encrypted string
-   */
-  encryptImage(image: string): string;
-  setSdkVersion(version: string): void;
-  setSdkPlatform(platform: string): void;
-  setDeviceInfo(deviceInfo: object, overrideExisting?: boolean): void;
-  setBrowserInfo(browserInfo: object, overrideExisting?: boolean): void;
-  setCameraInfo(cameraInfo: object, overrideExisting?: boolean): void;
-  setMotionStatus(status: string): void;
-  setBackgroundMode(backgroundMode: boolean): void;
-  /**
-   * Enables on-device mode: the native WASM module skips full fingerprint
-   * collection and keeps only the device-detection DTO. Additive; default off.
-   */
-  setOnDeviceMode(enabled: boolean): void;
-  setZc(zc: string): void;
-  setInspectorOpened(opened: boolean): void;
-  /**
-   * Returns whether the DevTools inspector has been detected as open.
-   * Safe to call before WASM initialization (returns the in-memory flag).
-   */
-  getInspectorOpened(): boolean;
-  /**
-   * 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;
-  /**
-   * Gets the current pipeline state. Must be called before setMotionStatus(),
-   * getCheck(), setBackgroundMode(), and getMetadata() for proper metadata generation.
-   */
-  getPipelineState(): string;
-  estimatePerformance(): string;
-  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>;
-  /**
-   * Disposes of resources and resets initialization state.
-   */
-  dispose(): Promise<void>;
-};
-//#endregion
+import { a as AvatarAssetsOverrides } from "./createFaceAvatar-pUEkdk4X.js";
+import { n as Flow, s as SelfieConcealmentOption } from "./types-s0fF3TpX.js";
+import { a as IRecordingCapability, i as IStorageCapability, t as IWasmUtilCapability } from "./IWasmUtilCapability-5-Pncgma.js";
 //#region src/internal/faceCapture/types.d.ts
 type CameraResolution = {
   width?: number;
@@ -204,4 +128,4 @@ declare const FACE_ERROR_CODES: {
 };
 type FaceErrorCode = (typeof FACE_ERROR_CODES)[keyof typeof FACE_ERROR_CODES];
 //#endregion
-export { FaceCapturedImageData as a, VirtualCameraCheckOutput as c, FaceCaptureOnlyResponse as i, WasmUtilConfig as l, DetectionStatus as n, FaceErrorCode as o, FaceCaptureDependencies as r, IWasmUtilCapability as s, BaseFaceCaptureConfig as t };
+export { FaceCapturedImageData as a, FaceCaptureOnlyResponse as i, DetectionStatus as n, FaceErrorCode as o, FaceCaptureDependencies as r, BaseFaceCaptureConfig as t };

package/dist/types-W5OCjqmi.d.ts

@@ -0,0 +1,10 @@
+import { a as RegulationTypes } from "./types-s0fF3TpX.js";
+//#region src/internal/fingerprint/types.d.ts
+type DeviceFingerprintResult = {
+  success: boolean;
+  sessionStatus: string;
+  showMandatoryConsent?: boolean;
+  regulationType?: RegulationTypes;
+};
+//#endregion
+export { DeviceFingerprintResult as t };

package/dist/{types-CRw2IBPn.d.ts → types-s0fF3TpX.d.ts}

@@ -1,5 +1,6 @@
 import { t as DocumentUploadConfig } from "./types-Vb4P9ovf.js";
 import { s as RiskAddon } from "./types-Bk_6dmDa.js";
+import "./createFaceAvatar-pUEkdk4X.js";
 //#region src/internal/avatar/concealment.d.ts
 /**
  * Backend-aligned selfie/auth face-concealment options. The backend returns a

package/dist/video-selfie.d.ts

@@ -1,10 +1,10 @@
-import { n as WasmPipeline } from "./warmup-Dv2alr2-.js";
+import { c as WasmPipeline } from "./warmup-CXHBgvFC.js";
 import { A as StateMachine, _ as MachineContext, c as AnyEventObject, p as EventObject, v as MetaObject, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
 import "./StateMachine-EDpYWy0i.js";
 import "./Actor-iTq7YY48.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { t as DetectionOrientation } from "./IIdCaptureCapability-DHTT3FC2.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-TyrYWahm.js";
+import { t as DetectionOrientation } from "./IIdCaptureCapability-DDWlQzhi.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-Bw5t6XCU.js";
 //#region src/internal/recordings/multipartRecordingService.d.ts
 type MultipartRecordingResult = {
   /**

package/dist/video-selfie.esm.js

@@ -1,13 +1,13 @@
-import { r as WasmUtilProvider } from "./safeStorage-Ep56I-f_.esm.js";
-import { c as abortVideoSelfieUpload, d as uploadVideoSelfiePart, l as completeVideoSelfieUpload, t as ensureWasmPipelines, u as initiateVideoSelfieUpload } from "./setup-1lLa3WHQ.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-2nOSCCnG.esm.js";
+import { d as initiateVideoSelfieUpload, f as uploadVideoSelfiePart, l as abortVideoSelfieUpload, t as ensureWasmPipelines, u as completeVideoSelfieUpload } from "./setup-y1bXyMoz.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-CCzL3XD_.esm.js";
-import { d as videoSelfieWasmPipelines, l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-Clyz_AFS.esm.js";
+import { d as videoSelfieWasmPipelines, l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-CAz3XO92.esm.js";
 import { c as createManager, o as createActor, r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 import { n as getSupportedMediaRecorderMimeType } from "./mediaRecorderOptions-vXDI73LZ.esm.js";
-import { i as createDefaultStepDetector, n as defaultAcquireCamera, o as isConnectionError, r as CameraCompositor, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-C95ZbuSU.esm.js";
+import { i as createDefaultStepDetector, n as defaultAcquireCamera, o as isConnectionError, r as CameraCompositor, t as createVideoSelfieCameraWarmer } from "./videoSelfieCameraWarmer-Da9lJmK8.esm.js";
 //#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
 /**
 * How often `MediaRecorder` hands us buffered data (incremental blobs).

package/dist/{videoSelfieCameraWarmer-C95ZbuSU.esm.js → videoSelfieCameraWarmer-Da9lJmK8.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-CCzL3XD_.esm.js";
-import { l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-Clyz_AFS.esm.js";
+import { l as facingModeForStep, u as resolveVideoSelfieSteps } from "./flowServices-CAz3XO92.esm.js";
 import { i as requestCameraWithFallback, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
-import { t as checkPermission } from "./permissionServices-B7sMtZ8f.esm.js";
-import { _ as StreamCanvasProcessingSession, a as encryptSelfieImage, l as startDetection, v as FaceDetectionProvider } from "./onDeviceFaceResults-DnxtQAz3.esm.js";
+import { t as checkPermission } from "./permissionServices-BPUkbztJ.esm.js";
+import { _ as StreamCanvasProcessingSession, a as encryptSelfieImage, l as startDetection, v as FaceDetectionProvider } from "./onDeviceFaceResults-DT9SoUq7.esm.js";
 import { n as getBackCameraStream } from "./backCameraStream-BMGalshK.esm.js";
 import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
 import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
 import { a as uploadSelfie, r as processFace, t as getFaceErrorCodeFromUnknown } from "./selfieErrorUtils-ArUCoICg.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 { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-Dowxd3J3.esm.js";
 //#region src/modules/video-selfie/videoSelfieCompareService.ts
 async function postVideoSelfieCompare(endpoint, base64Image) {
 	return (await api.post(endpoint, { base64Image })).data;

package/dist/{videoSelfieStepDetector-TyrYWahm.d.ts → videoSelfieStepDetector-Bw5t6XCU.d.ts}

@@ -1,7 +1,8 @@
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { i as FlowModuleConfig } from "./types-CRw2IBPn.js";
-import { n as DetectionStatus } from "./types-Cyiwbg-r.js";
-import { t as DetectionOrientation } from "./IIdCaptureCapability-DHTT3FC2.js";
+import { i as FlowModuleConfig } from "./types-s0fF3TpX.js";
+import "./IWasmUtilCapability-5-Pncgma.js";
+import { n as DetectionStatus } from "./types-RMhiEIm9.js";
+import { t as DetectionOrientation } from "./IIdCaptureCapability-DDWlQzhi.js";
 //#region src/modules/video-selfie/types.d.ts
 /**
  * The capture steps a Video Selfie session can run, in flow order. Which steps

package/dist/warmup-CXHBgvFC.d.ts

@@ -0,0 +1,117 @@
+//#region ../infra/src/wasm/wasmAssets.d.ts
+type WasmSource = string | ArrayBuffer | Uint8Array;
+type WasmGlueModule = {
+  Module?: unknown;
+};
+type WasmGlueLoader = () => Promise<WasmGlueModule>;
+type WasmPipeline = 'selfie' | 'onDeviceSelfie' | 'idCapture' | 'videoSelfie' | 'videoSelfieId';
+declare const WASM_MODEL_FILES: {
+  readonly idCapture: "id_capture_2_01_fp16.ortmodelv2";
+  readonly idFiqa: "id_fiqa_19a81a0b9bf6492eb03b4667f6db4c85_fp16.ortmodelv2";
+  readonly barcode: "barcode_enhance_896x224_fp16.ortmodelv2";
+  readonly selfie: "selfie_bf_angles_192x192_opset9_fp16.ortmodelv2";
+  readonly faceAttributes: "face_attributes_v1_3_fp16.ortmodelv2";
+  readonly faceOcclusion: "face_occlusion_v0_2_fp16.ortmodelv2";
+  readonly mlsRegressor: "mls_regressor_4773007c657b4f05a460321456740d0f_fp16.ortmodelv2";
+  readonly liveness: "ondevice_physical_liveness_v2_1_fp16.ortmodelv2";
+  readonly ageEstimation: "age_estimation_v2_2_2_fp16.ortmodelv2";
+};
+type WasmModelName = keyof typeof WASM_MODEL_FILES;
+//#endregion
+//#region ../infra/src/wasm/apiUtilities.d.ts
+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>;
+/**
+ * Binary and glue configuration for one WASM module instance.
+ *
+ * The ML pipeline and HTTP client share this object because both consumers
+ * use the same memoized module.
+ */
+type WasmModuleConfig = {
+  /** URL or bytes for the standard WASM binary. */
+  wasmPath: WasmSource;
+  /**
+   * URL or bytes for the SIMD WASM binary.
+   *
+   * When omitted, the loader uses `wasmPath` and skips the SIMD attempt.
+   */
+  wasmSimdPath?: WasmSource;
+  /** URL of the JavaScript glue paired with `wasmPath`. */
+  glueCodePath: string;
+  /**
+   * URL of the JavaScript glue paired with `wasmSimdPath`.
+   *
+   * When omitted or empty, the loader derives a sibling `.js` URL from
+   * `wasmSimdPath`.
+   */
+  glueCodeSimdPath?: string;
+  /** Lazy ES-module loader for the standard JavaScript glue. */
+  loadGlue?: WasmGlueLoader;
+  /** Lazy ES-module loader for the SIMD JavaScript glue. */
+  loadGlueSimd?: WasmGlueLoader;
+  /**
+   * Enables the SIMD-first load attempt.
+   *
+   * Defaults to `true`. If SIMD loading fails, the loader uses the standard
+   * binary and glue pair.
+   */
+  useSimd?: boolean;
+};
+//#endregion
+//#region ../infra/src/wasm/warmup.d.ts
+type WasmModelsConfig = {
+  /** Root URL that contains the model files. */
+  modelsBasePath?: string;
+  /** Fully resolved source for each model filename. */
+  modelUrls?: Readonly<Record<string, WasmSource>>;
+  /** Prevents unresolved models from falling back to the Incode CDN. */
+  selfHosted?: boolean;
+};
+type WarmupConfig = WasmModuleConfig & WasmModelsConfig & {
+  /** Root URL of a directory that contains binaries, glue, and models. */
+  basePath?: string;
+  /** Pipelines whose model bundles load during this warmup. */
+  pipelines?: readonly WasmPipeline[];
+  /** Model filename overrides for individual pipelines. */
+  pipelineModels?: Partial<Record<WasmPipeline, string[]>>;
+  /** Limits native initialization to the on-device device-information mode. */
+  onDeviceMode?: boolean;
+};
+/**
+ * Preloads WASM binary and ML models at app startup.
+ * Runs asynchronously - app can continue while WASM loads in background.
+ *
+ * Model files are automatically loaded based on the pipeline type.
+ * By default, models are expected in a 'models' subdirectory relative to the WASM binary.
+ *
+ * @param config - Configuration for WASM warmup
+ * @returns Promise that resolves when WASM is ready
+ *
+ * @example
+ * ```ts
+ * // Basic usage - models loaded from /wasm/v2/models/
+ * warmupWasm({
+ *   wasmPath: '/wasm/v2/ml-wasm.wasm',
+ *   glueCodePath: '/wasm/v2/ml-wasm.js',
+ *   pipelines: ['selfie', 'idCapture'],
+ * });
+ *
+ * // With explicit models path
+ * warmupWasm({
+ *   wasmPath: '/wasm/v2/ml-wasm.wasm',
+ *   glueCodePath: '/wasm/v2/ml-wasm.js',
+ *   modelsBasePath: 'https://cdn.example.com/wasm/v2/models',
+ *   pipelines: ['selfie'],
+ * });
+ * ```
+ */
+declare function warmupWasm(config: WarmupConfig): Promise<void>;
+//#endregion
+export { WASM_MODEL_FILES as a, WasmPipeline as c, WasmModuleConfig as i, WasmSource as l, WasmModelsConfig as n, WasmGlueLoader as o, warmupWasm as r, WasmModelName as s, WarmupConfig as t };

package/dist/wasm.d.ts

@@ -1,16 +1,34 @@
-import { n as WasmPipeline, r as warmupWasm, t as WarmupConfig } from "./warmup-Dv2alr2-.js";
-import { i as initializeWasmUtil, l as upgradeToWasmHttpClient, n as WasmConfig, r as ensureWasmPipelines, s as setWasmConfig } from "./setup-DywQeePQ.js";
+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-CXHBgvFC.js";
+import { c as setWasmConfig, i as initializeWasmUtil, n as WasmConfig, r as ensureWasmPipelines, s as resolveWasmConfigForPipelines, u as upgradeToWasmHttpClient } from "./setup-BwA7zG5D.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.07-post7-post3";
+type UrlWasmConfig = WarmupConfig & {
+  wasmPath: string;
+  wasmSimdPath: string;
+  glueCodePath: string;
+  glueCodeSimdPath: string;
+  modelsBasePath: string;
+};
 /** Builds a WarmupConfig from a directory that mirrors the ml-wasm-kit CDN layout. */
-declare function buildWasmConfigFromBasePath(basePath: string): WarmupConfig;
+declare function buildWasmConfigFromBasePath(basePath: string): UrlWasmConfig;
 /** Builds the standard WarmupConfig from the Incode CDN. */
-declare function buildDefaultWasmConfig(): WarmupConfig;
+declare function buildDefaultWasmConfig(): UrlWasmConfig;
 /**
  * Merges optional WASM path overrides with CDN defaults. Explicit non-blank
  * paths take precedence. Blank override strings log a warning and fall back to defaults.
  */
 declare function resolveWasmConfig(overrides?: Partial<WarmupConfig>): WarmupConfig;
 //#endregion
-export { DEFAULT_WASM_VERSION, type WasmConfig, type WasmPipeline, buildDefaultWasmConfig, buildWasmConfigFromBasePath, ensureWasmPipelines, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };
+//#region src/defineWasm.d.ts
+type DefineWasmOptions = {
+  pipelines: readonly WasmPipeline[];
+  wasm: WasmSource;
+  wasmSimd?: WasmSource;
+  glue: WasmGlueLoader;
+  glueSimd?: WasmGlueLoader;
+  models: Partial<Record<WasmModelName, WasmSource>>;
+};
+declare function defineWasm(options: DefineWasmOptions): WasmConfig;
+//#endregion
+export { DEFAULT_WASM_VERSION, type DefineWasmOptions, WASM_MODEL_FILES, type WasmConfig, type WasmModelName, type WasmPipeline, type WasmSource, buildDefaultWasmConfig, buildWasmConfigFromBasePath, defineWasm, ensureWasmPipelines, initializeWasmUtil, resolveWasmConfig, resolveWasmConfigForPipelines, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };

package/dist/wasm.esm.js

@@ -1,4 +1,31 @@
-import { a as resolveWasmConfig, n as buildDefaultWasmConfig, r as buildWasmConfigFromBasePath, t as DEFAULT_WASM_VERSION } from "./wasmDefaults-DTUrftxR.esm.js";
-import { s as warmupWasm } from "./safeStorage-Ep56I-f_.esm.js";
-import { a as setWasmConfig, n as initializeWasmUtil, s as upgradeToWasmHttpClient, t as ensureWasmPipelines } from "./setup-1lLa3WHQ.esm.js";
-export { DEFAULT_WASM_VERSION, buildDefaultWasmConfig, buildWasmConfigFromBasePath, ensureWasmPipelines, initializeWasmUtil, resolveWasmConfig, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };
+import { d as WASM_MODEL_FILES, f as WASM_PIPELINE_LAZY_MODEL_NAMES, m as WASM_PIPELINE_MODEL_NAMES } from "./wasmWebClient-BzFsDjU6.esm.js";
+import { a as resolveWasmConfig, n as buildDefaultWasmConfig, r as buildWasmConfigFromBasePath, t as DEFAULT_WASM_VERSION } from "./wasmDefaults-BrwMccqW.esm.js";
+import { s as warmupWasm } from "./safeStorage-2nOSCCnG.esm.js";
+import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-y1bXyMoz.esm.js";
+//#region src/defineWasm.ts
+function requiredModels(pipelines) {
+	const models = /* @__PURE__ */ new Set();
+	for (const pipeline of pipelines) {
+		for (const model of WASM_PIPELINE_MODEL_NAMES[pipeline]) models.add(model);
+		for (const model of WASM_PIPELINE_LAZY_MODEL_NAMES[pipeline]) models.add(model);
+	}
+	return models;
+}
+function defineWasm(options) {
+	if (options.wasmSimd === void 0 !== (options.glueSimd === void 0)) throw new Error("[Incode SDK] wasmSimd and glueSimd must be provided together.");
+	for (const model of requiredModels(options.pipelines)) if (options.models[model] === void 0) throw new Error(`[Incode SDK] The self-hosted WASM configuration is missing the "${model}" model.`);
+	const modelUrls = {};
+	for (const [name, source] of Object.entries(options.models)) if (source !== void 0) modelUrls[WASM_MODEL_FILES[name]] = source;
+	return {
+		wasmPath: options.wasm,
+		wasmSimdPath: options.wasmSimd,
+		loadGlue: options.glue,
+		loadGlueSimd: options.glueSimd,
+		useSimd: options.wasmSimd !== void 0,
+		pipelines: [...options.pipelines],
+		modelUrls,
+		selfHosted: true
+	};
+}
+//#endregion
+export { DEFAULT_WASM_VERSION, WASM_MODEL_FILES, buildDefaultWasmConfig, buildWasmConfigFromBasePath, defineWasm, ensureWasmPipelines, initializeWasmUtil, resolveWasmConfig, resolveWasmConfigForPipelines, setWasmConfig, upgradeToWasmHttpClient, warmupWasm };

package/dist/{wasmDefaults-DTUrftxR.esm.js → wasmDefaults-BrwMccqW.esm.js}

@@ -1,4 +1,4 @@
-import { u as deriveSiblingJsPath } from "./wasmWebClient-DM8lkb0z.esm.js";
+import { d as WASM_MODEL_FILES, u as deriveSiblingJsPath } from "./wasmWebClient-BzFsDjU6.esm.js";
 //#region ../infra/src/wasm/wasmDefaults.ts
 const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
 /** The WASM version bundled and tested with this SDK release. */
@@ -67,6 +67,19 @@ function pickPath(key, overrides, defaultValue) {
 	}
 	return raw.trim();
 }
+function pickSource(key, overrides, defaultValue) {
+	if (!(key in overrides) || overrides[key] === void 0) return defaultValue;
+	const source = overrides[key];
+	if (typeof source !== "string") return source;
+	return pickPath(key, overrides, String(defaultValue));
+}
+function resolveBasePath(overrides) {
+	const defaultValue = `${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`;
+	if (!("basePath" in overrides) || overrides.basePath === void 0) return defaultValue;
+	const basePath = overrides.basePath;
+	if (typeof basePath !== "string" || isBlank(basePath) || isMalformedPath(basePath)) throw new Error("[Incode SDK] wasm.basePath is invalid.");
+	return basePath.trim();
+}
 /** Builds a WarmupConfig from a directory that mirrors the ml-wasm-kit CDN layout. */
 function buildWasmConfigFromBasePath(basePath) {
 	const base = basePath.endsWith("/") ? basePath.slice(0, -1) : basePath;
@@ -82,7 +95,7 @@ function buildWasmConfigFromBasePath(basePath) {
 function buildDefaultWasmConfig() {
 	return buildWasmConfigFromBasePath(`${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`);
 }
-const BARCODE_ENHANCE_MODEL_FILE = "barcode_enhance_896x224_fp16.ortmodelv2";
+const BARCODE_ENHANCE_MODEL_FILE = WASM_MODEL_FILES.barcode;
 /**
 * URL of the lazily-loaded PDF417 barcode enhancement model (US Smart Capture).
 * Derived from the resolved `modelsBasePath` so self-hosted / air-gapped
@@ -100,23 +113,25 @@ function getBarcodeEnhanceModelUrl(modelsBasePath) {
 */
 function resolveWasmConfig(overrides) {
 	if (!overrides) return buildDefaultWasmConfig();
-	const defaults = buildWasmConfigFromBasePath(pickPath("basePath", overrides, `${WASM_CDN_BASE_URL}/${DEFAULT_WASM_VERSION}`));
-	const simdDefault = defaults.wasmSimdPath ?? defaults.wasmPath;
-	const modelsDefault = defaults.modelsBasePath ?? (() => {
-		const lastSlash = defaults.wasmPath.lastIndexOf("/");
-		return lastSlash === -1 ? "models" : `${defaults.wasmPath.substring(0, lastSlash)}/models`;
-	})();
-	const resolvedWasmSimdPath = pickPath("wasmSimdPath", overrides, simdDefault);
-	const glueCodeSimdDefault = deriveSiblingJsPath(resolvedWasmSimdPath);
+	const defaults = buildWasmConfigFromBasePath(resolveBasePath(overrides));
+	const resolvedWasmPath = pickSource("wasmPath", overrides, defaults.wasmPath);
+	const simdDefault = overrides.selfHosted ? resolvedWasmPath : defaults.wasmSimdPath;
+	const modelsDefault = defaults.modelsBasePath;
+	const resolvedWasmSimdPath = pickSource("wasmSimdPath", overrides, simdDefault);
+	const glueCodeSimdDefault = typeof resolvedWasmSimdPath === "string" ? deriveSiblingJsPath(resolvedWasmSimdPath) : defaults.glueCodeSimdPath;
 	const merged = {
-		wasmPath: pickPath("wasmPath", overrides, defaults.wasmPath),
+		wasmPath: resolvedWasmPath,
 		wasmSimdPath: resolvedWasmSimdPath,
 		glueCodePath: pickPath("glueCodePath", overrides, defaults.glueCodePath),
 		glueCodeSimdPath: pickPath("glueCodeSimdPath", overrides, glueCodeSimdDefault),
 		modelsBasePath: pickPath("modelsBasePath", overrides, modelsDefault),
 		useSimd: overrides.useSimd,
 		pipelines: overrides.pipelines,
-		pipelineModels: overrides.pipelineModels
+		pipelineModels: overrides.pipelineModels,
+		modelUrls: overrides.modelUrls,
+		loadGlue: overrides.loadGlue,
+		loadGlueSimd: overrides.loadGlueSimd,
+		selfHosted: overrides.selfHosted
 	};
 	validateWasmPaths(merged);
 	return merged;

package/dist/{wasmDsFlagSync-BqUCwLY8.esm.js → wasmDsFlagSync-Dd7Yj25O.esm.js}

@@ -1,4 +1,4 @@
-import { c as mlWasmJSApi_default } from "./safeStorage-Ep56I-f_.esm.js";
+import { c as mlWasmJSApi_default } from "./safeStorage-2nOSCCnG.esm.js";
 //#region ../infra/src/wasm/wasmDsFlagSync.ts
 /**
 * Sets the Deepsight (ds) flag that the WASM utility API receives on every

package/dist/{wasmWebClient-DM8lkb0z.esm.js → wasmWebClient-BzFsDjU6.esm.js}

@@ -1,3 +1,70 @@
+//#region ../infra/src/wasm/wasmAssets.ts
+const WASM_MODEL_FILES = {
+	idCapture: "id_capture_2_01_fp16.ortmodelv2",
+	idFiqa: "id_fiqa_19a81a0b9bf6492eb03b4667f6db4c85_fp16.ortmodelv2",
+	barcode: "barcode_enhance_896x224_fp16.ortmodelv2",
+	selfie: "selfie_bf_angles_192x192_opset9_fp16.ortmodelv2",
+	faceAttributes: "face_attributes_v1_3_fp16.ortmodelv2",
+	faceOcclusion: "face_occlusion_v0_2_fp16.ortmodelv2",
+	mlsRegressor: "mls_regressor_4773007c657b4f05a460321456740d0f_fp16.ortmodelv2",
+	liveness: "ondevice_physical_liveness_v2_1_fp16.ortmodelv2",
+	ageEstimation: "age_estimation_v2_2_2_fp16.ortmodelv2"
+};
+const WASM_PIPELINE_MODEL_NAMES = {
+	selfie: [
+		"selfie",
+		"faceAttributes",
+		"mlsRegressor",
+		"faceOcclusion"
+	],
+	onDeviceSelfie: [
+		"selfie",
+		"faceAttributes",
+		"mlsRegressor",
+		"faceOcclusion",
+		"liveness",
+		"ageEstimation"
+	],
+	idCapture: ["idCapture", "idFiqa"],
+	videoSelfie: [
+		"selfie",
+		"faceAttributes",
+		"mlsRegressor",
+		"faceOcclusion"
+	],
+	videoSelfieId: ["idCapture"]
+};
+const WASM_PIPELINE_LAZY_MODEL_NAMES = {
+	selfie: [],
+	onDeviceSelfie: [],
+	idCapture: ["barcode"],
+	videoSelfie: [],
+	videoSelfieId: []
+};
+const WASM_PIPELINE_MODELS = {
+	selfie: WASM_PIPELINE_MODEL_NAMES.selfie.map((model) => WASM_MODEL_FILES[model]),
+	onDeviceSelfie: WASM_PIPELINE_MODEL_NAMES.onDeviceSelfie.map((model) => WASM_MODEL_FILES[model]),
+	idCapture: WASM_PIPELINE_MODEL_NAMES.idCapture.map((model) => WASM_MODEL_FILES[model]),
+	videoSelfie: WASM_PIPELINE_MODEL_NAMES.videoSelfie.map((model) => WASM_MODEL_FILES[model]),
+	videoSelfieId: WASM_PIPELINE_MODEL_NAMES.videoSelfieId.map((model) => WASM_MODEL_FILES[model])
+};
+async function resolveWasmSource(source, kind) {
+	if (source instanceof Uint8Array) return source;
+	if (source instanceof ArrayBuffer) return new Uint8Array(source);
+	let response;
+	try {
+		response = await fetch(source);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw new Error(`[Incode SDK] Could not load the WASM ${kind} at ${source}: ${detail}`);
+	}
+	if (!response.ok) throw new Error(`[Incode SDK] Could not load the WASM ${kind} at ${source}: ${response.status} ${response.statusText}`);
+	return new Uint8Array(await response.arrayBuffer());
+}
+function missingWasmModelError(fileName, pipeline) {
+	return /* @__PURE__ */ new Error(`[Incode SDK] The "${pipeline}" pipeline needs ${fileName}, but the self-hosted WASM configuration does not provide it.`);
+}
+//#endregion
 //#region ../infra/src/wasm/wasmPathUtils.ts
 function deriveSiblingJsPath(wasmPath) {
 	const index = wasmPath.lastIndexOf(".wasm");
@@ -130,7 +197,7 @@ var SemaphoreProvider = class {
 if (typeof window !== "undefined" && window.wasmArrayBuffer === void 0) window.wasmArrayBuffer = null;
 let loadPromise = null;
 let loadedResult = null;
-async function importGlue(glueCodePath) {
+async function importGlueAt(glueCodePath) {
 	const mod = await import(
 		/* @vite-ignore */
 		/* webpackIgnore: true */
@@ -139,14 +206,17 @@ async function importGlue(glueCodePath) {
 	if (typeof mod.Module !== "function") throw new Error(`WASM glue at ${glueCodePath} did not export a Module factory`);
 	return mod.Module;
 }
-async function fetchWasmBinary(libPath) {
-	const response = await fetch(libPath);
-	if (!response.ok) throw new Error(`Failed to fetch WASM binary at ${libPath}: ${response.status} ${response.statusText}`);
-	const buffer = await response.arrayBuffer();
-	return new Uint8Array(buffer);
+async function resolveGlue(loader, glueCodePath) {
+	if (loader) {
+		const module = await loader();
+		if (typeof module.Module !== "function") throw new Error("[Incode SDK] WASM glue module did not export a Module factory.");
+		return module.Module;
+	}
+	if (!glueCodePath) throw new Error("WASM glue code is required");
+	return await importGlueAt(glueCodePath);
 }
 async function instantiate(factory, libPath) {
-	window.wasmArrayBuffer = await fetchWasmBinary(libPath);
+	window.wasmArrayBuffer = await resolveWasmSource(libPath, "binary");
 	return await factory();
 }
 /**
@@ -165,7 +235,7 @@ async function loadWasmModule(config) {
 			const wantSimd = config.useSimd !== false;
 			const simdBinary = config.wasmSimdPath ?? config.wasmPath;
 			if (wantSimd && simdBinary !== config.wasmPath) try {
-				const simdFactory = await importGlue(config.glueCodeSimdPath ?? deriveSiblingJsPath(simdBinary));
+				const simdFactory = await resolveGlue(config.loadGlueSimd, typeof simdBinary === "string" ? config.glueCodeSimdPath || deriveSiblingJsPath(simdBinary) : config.glueCodeSimdPath);
 				window.Module = simdFactory;
 				const result = {
 					wasmModule: await instantiate(simdFactory, simdBinary),
@@ -176,7 +246,7 @@ async function loadWasmModule(config) {
 			} catch (simdError) {
 				console.warn("[Incode SDK] SIMD WASM load failed, falling back to non-SIMD", simdError);
 			}
-			const nonSimdFactory = await importGlue(config.glueCodePath);
+			const nonSimdFactory = await resolveGlue(config.loadGlue, config.glueCodePath);
 			window.Module = nonSimdFactory;
 			const result = {
 				wasmModule: await instantiate(nonSimdFactory, config.wasmPath),
@@ -273,23 +343,13 @@ const toStringRecord = (obj) => {
 /**
 * Loads the shared WASM module (if not already loaded) and instantiates the
 * C++ `WebClient`. Idempotent — repeated calls reuse the existing instance.
-*
-* `glueCodeSimdPath` is paired with `wasmSimdPath` (`webLibSimd.js` for
-* `webLibSimd.wasm`). Pass `''` to derive it automatically from
-* `wasmSimdPath` by replacing the `.wasm` extension with `.js`.
 */
-async function initializeWasmWebClient(wasmPath, wasmSimdPath, glueCodePath, glueCodeSimdPath, useSimd) {
+async function initializeWasmWebClient(config) {
 	if (webClientApi) return;
 	if (initPromise) return initPromise;
 	initPromise = (async () => {
 		try {
-			const { wasmModule } = await loadWasmModule({
-				wasmPath,
-				wasmSimdPath,
-				glueCodePath,
-				glueCodeSimdPath: glueCodeSimdPath || void 0,
-				useSimd
-			});
+			const { wasmModule } = await loadWasmModule(config);
 			if (!isWebClientWasm(wasmModule)) throw new Error("WASM module does not expose a WebClient class. Update webLib.wasm to a build that includes WebClient.");
 			webClientApi = new wasmModule.WebClient();
 		} catch (error) {
@@ -404,4 +464,4 @@ function ensureReady() {
 	return webClientApi;
 }
 //#endregion
-export { setWebApiHttpTransport as a, loadWasmModule as c, initializeWasmWebClient as i, SemaphoreProvider as l, createWebApiHostAdapter as n, setupWasmConnection as o, executeWasmRequest as r, wasmCallWrapper as s, WasmWebClientError as t, deriveSiblingJsPath as u };
+export { setWebApiHttpTransport as a, loadWasmModule as c, WASM_MODEL_FILES as d, WASM_PIPELINE_LAZY_MODEL_NAMES as f, resolveWasmSource as g, missingWasmModelError as h, initializeWasmWebClient as i, SemaphoreProvider as l, WASM_PIPELINE_MODEL_NAMES as m, createWebApiHostAdapter as n, setupWasmConnection as o, WASM_PIPELINE_MODELS as p, executeWasmRequest as r, wasmCallWrapper as s, WasmWebClientError as t, deriveSiblingJsPath as u };

package/dist/workflow.d.ts

@@ -3,7 +3,7 @@ import { t as CallbackActorLogic } from "./callback-645_omgz.js";
 import "./StateMachine-EDpYWy0i.js";
 import { t as Manager } from "./Manager-CQQ99QOI.js";
 import { a as TotalScore, i as GetTotalScoreStatusFn, n as FinishStatus, r as GetFinishStatusFn } from "./flowCompletionService-BlAHsKyv.js";
-import { o as FlowEventSubscribable } from "./index-Bivs6yJF.js";
+import { o as FlowEventSubscribable } from "./index-BwudEtre.js";
 import { a as WorkflowModuleRegistry, i as RunChildModuleInput, r as RunChildModuleEvent, t as ModuleConfigMappers } from "./types-BfgmV7s7.js";
 //#region src/modules/workflow/types.d.ts
 /** Possible node types returned by the workflow server. */
@@ -334,6 +334,10 @@ declare const workflowMachine: StateMachine<WorkflowContext, {
     id: string | undefined;
   };
 }>, Values<{
+  setError: {
+    type: "setError";
+    params: NonReducibleUnknown;
+  };
   setLoadingResult: {
     type: "setLoadingResult";
     params: NonReducibleUnknown;
@@ -366,10 +370,6 @@ declare const workflowMachine: StateMachine<WorkflowContext, {
     type: "setFinishStatusFailed";
     params: NonReducibleUnknown;
   };
-  setError: {
-    type: "setError";
-    params: NonReducibleUnknown;
-  };
   setModuleError: {
     type: "setModuleError";
     params: NonReducibleUnknown;