@incodetech/core 0.0.0-dev-20260910-30fb659a → 0.0.0-dev-20260911-d4e8be9f

package/dist/{idCaptureStateMachine-CL_f4BrG.esm.js → idCaptureStateMachine-CBELAdUH.esm.js}

@@ -1,28 +1,28 @@
-import { l as BrowserStorageProvider } from "./setup-CxO2a0J_.esm.js";
+import { l as BrowserStorageProvider } from "./setup-BQ5-0CB6.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { s as exposeExperimentOnce } from "./feature-management-B1auhoHt.esm.js";
+import { s as exposeExperimentOnce } from "./feature-management-DJHtBpsz.esm.js";
 import { n as revokeObjectURL } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
 import { r as getToken, t as api } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-BTf2KSpq.esm.js";
+import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-CGUA9dm6.esm.js";
 import { n as eventModuleNames, s as recordExperimentAssignmentOnce } from "./events-ijlbX_Wx.esm.js";
-import { t as getDisableIpify } from "./sessionInitializer-Gw37lpQ_.esm.js";
+import { t as getDisableIpify } from "./sessionInitializer-BpyJ5y2B.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { t as addDeviceStats } from "./stats-DkK-f8JT.esm.js";
 import { a as isIOS, s as isIPad, t as isAndroid, u as isMacOsSafari } from "./platform-DkcRc9JV.esm.js";
-import "./session-B-b1IjuR.esm.js";
+import "./session-BxzK5bo1.esm.js";
 import { c as not, i as assign, l as raise, n as enqueueActions, o as and, r as sendTo, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { n as getUrlSearchParam, t as buildUrlWithSearchParams } from "./urlUtils-D6phjq1-.esm.js";
-import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-J5S1dEIf.esm.js";
+import { n as invokeRequestPermissionActor, t as checkPermission } from "./permissionServices-f7nBnW5P.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
 import { a as StreamCanvasProcessingSession } from "./recordingsRepository-CCWy13M-.esm.js";
 import { t as getBrowser } from "./getBrowser-Cbe1C4Tn.esm.js";
 import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
-import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-BHw_SD3h.esm.js";
+import { n as needsMotionPrimeOnlyFromPermission, r as resolveStoredPermissionResult, t as isReadyForCaptureFromPermission } from "./permissionGuards-DxbvOoZJ.esm.js";
 import { r as flagIdManualReview, t as imageFileToDataUrl } from "./imageFile-CLaua6xO.esm.js";
-import { _ as CAPTURE_OPTIMIZING, c as startRecordingSession, d as uploadIdImage, f as uploadManualIdFile, g as resolveIdCaptureThresholds, i as pauseRecordingForAttempt, l as stopRecording, m as ID_ERROR_CODES, o as prepareRecordingForCameraRetry, p as validateUploadResponse, r as initializeIdCapture, s as processId, t as addBarcode, u as stopStream, v as OPTIMIZING_WATCHDOG_MARGIN_MS, y as getIdCameraStream } from "./idCaptureServices-D_mcjCtz.esm.js";
+import { _ as CAPTURE_OPTIMIZING, c as startRecordingSession, d as uploadIdImage, f as uploadManualIdFile, g as resolveIdCaptureThresholds, i as pauseRecordingForAttempt, l as stopRecording, m as ID_ERROR_CODES, o as prepareRecordingForCameraRetry, p as validateUploadResponse, r as initializeIdCapture, s as processId, t as addBarcode, u as stopStream, v as OPTIMIZING_WATCHDOG_MARGIN_MS, y as getIdCameraStream } from "./idCaptureServices-0b3RJwM_.esm.js";
 //#region src/modules/id/digitalUpload/digitalUploadErrors.ts
 const TERMINAL_FAIL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 function isKnownFailReason(reason) {
@@ -2133,7 +2133,7 @@ const startRecordingActor = fromPromise(async ({ input }) => {
 });
 const initializeDeepsightSessionActor = fromPromise(async ({ input }) => {
 	if (!input.dependencies) return;
-	const { loadDeepsightSession } = await import("./deepsightLoader-CgAY2Xik.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-HcpfFvrJ.esm.js");
 	return loadDeepsightSession({
 		ds: input.ds,
 		storage: input.dependencies.storage,

package/dist/identity-reuse.d.ts

@@ -1,2 +1,2 @@
-import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-BFDI7iFK.js";
+import { c as identityReuseMachine, d as ReusableDocument, f as SubmitResponse, i as createIdentityReuseManagerFromActor, l as FetchDocumentsResponse, n as IdentityReuseState, o as SCAN_NEW_DOCUMENT, r as createIdentityReuseManager, s as SelectedDocumentId, t as IdentityReuseManager, u as IdentityReuseConfig } from "./identityReuseManager-v2TH5g7e.js";
 export { type FetchDocumentsResponse, type IdentityReuseConfig, type IdentityReuseManager, type IdentityReuseState, type ReusableDocument, SCAN_NEW_DOCUMENT, type SelectedDocumentId, type SubmitResponse, createIdentityReuseManager, createIdentityReuseManagerFromActor, identityReuseMachine };

package/dist/{identityReuseManager-BFDI7iFK.d.ts → identityReuseManager-v2TH5g7e.d.ts}

@@ -108,14 +108,14 @@ declare const identityReuseMachine: StateMachine<IdentityReuseContext, {
     type: "setError";
     params: NonReducibleUnknown;
   };
-  setSelectedDocument: {
-    type: "setSelectedDocument";
-    params: NonReducibleUnknown;
-  };
   clearError: {
     type: "clearError";
     params: NonReducibleUnknown;
   };
+  setSelectedDocument: {
+    type: "setSelectedDocument";
+    params: NonReducibleUnknown;
+  };
 }>, Values<{
   hasDocuments: {
     type: "hasDocuments";

package/dist/index.esm.js

@@ -1,2 +1,2 @@
-import { i as reset, r as isConfigured, s as setup } from "./setup-CxO2a0J_.esm.js";
+import { i as reset, r as isConfigured, s as setup } from "./setup-BQ5-0CB6.esm.js";
 export { isConfigured, reset, setup };

package/dist/mandatory-consent.d.ts

@@ -1,3 +1,3 @@
 import { r as MandatoryConsentConfig } from "./types-DJ2OM9rw.js";
-import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-CSh8HjSF.js";
+import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, t as MandatoryConsentManager } from "./mandatoryConsentManager-BxrRrlBs.js";
 export { type MandatoryConsentActor, type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/{mandatoryConsentManager-CSh8HjSF.d.ts → mandatoryConsentManager-BxrRrlBs.d.ts}

@@ -57,14 +57,14 @@ declare const mandatoryConsentMachine: StateMachine<MandatoryConsentContext, {
     type: "setError";
     params: NonReducibleUnknown;
   };
-  clearError: {
-    type: "clearError";
-    params: NonReducibleUnknown;
-  };
   toggleSigned: {
     type: "toggleSigned";
     params: NonReducibleUnknown;
   };
+  clearError: {
+    type: "clearError";
+    params: NonReducibleUnknown;
+  };
   resetContext: {
     type: "resetContext";
     params: NonReducibleUnknown;

package/dist/{onDeviceFaceResults-BtD_Dij3.esm.js → onDeviceFaceResults-C10QzrYa.esm.js}

@@ -1,8 +1,9 @@
-import { t as ensureWasmPipelines } from "./setup-CxO2a0J_.esm.js";
-import { i as BaseWasmProvider, l as wasmRuntime } from "./safeStorage-0bZuUtSP.esm.js";
+import { t as ensureWasmPipelines } from "./setup-BQ5-0CB6.esm.js";
+import { s as wasmRuntime } from "./warmup-BOM-sD-6.esm.js";
+import { i as BaseWasmProvider } from "./safeStorage-Dp9m6aOh.esm.js";
 import { r as getToken } from "./api-Bx3gKW_y.esm.js";
-import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-BTf2KSpq.esm.js";
-import "./sessionInitializer-Gw37lpQ_.esm.js";
+import { c as trueSightHintTransition, l as trueSightLog, r as noteTrueSightCaptureActivity } from "./trueSightService-CGUA9dm6.esm.js";
+import { v as yieldUntilNextPaint } from "./sessionInitializer-BpyJ5y2B.esm.js";
 import { t as addDeviceStats } from "./stats-DkK-f8JT.esm.js";
 import { c as isIPhone14OrHigher, i as isDesktop } from "./platform-DkcRc9JV.esm.js";
 import { a as stopCameraStream, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
@@ -10,54 +11,6 @@ import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
 import { t as IncodeCanvas } from "./canvas-E1zGkel4.esm.js";
 import { a as StreamCanvasProcessingSession, n as startRecording, r as stopRecording$1, t as createRecordingSession } from "./recordingsRepository-CCWy13M-.esm.js";
 import { i as hasBackCamera, n as getBackCameraStream, r as getDesktopCameraStream, t as ensureFrontCameraStream } from "./backCameraStream-DE_5qY04.esm.js";
-//#region ../infra/src/scheduling/yieldUntilNextPaint.ts
-/**
-* Resolves after the browser has had a chance to commit and paint a queued
-* render.
-*
-* Strategy:
-* - `requestAnimationFrame` callbacks fire BEFORE the paint of the frame
-*   they belong to (per the HTML5 "update the rendering" step). If we
-*   resolve the promise inside a rAF callback, the await-continuation
-*   runs as a microtask immediately after the callback returns — still
-*   before the paint phase of that frame. A caller that then blocks the
-*   main thread (e.g. synchronous WASM `processPhoto`) starves the paint.
-* - We therefore chain rAF → setTimeout: the rAF fires before frame N's
-*   paint, the setTimeout runs as a macrotask scheduled after frame N's
-*   "update the rendering" step, which the browser will only get to once
-*   the paint actually lands. By the time setTimeout fires, the paint
-*   for the queued render is on screen.
-* - In environments where rAF never ticks (jsdom, happy-dom, backgrounded
-*   tabs), a parallel `setTimeout` fallback at 100 ms resolves instead.
-*   100 ms is comfortably longer than two real-browser frames so rAF +
-*   setTimeout wins reliably in any foregrounded browser. (An earlier
-*   implementation raced rAF against a `MessageChannel` macrotask, but
-*   MessageChannel drains immediately after the current task's
-*   microtasks — before the next paint — so it resolved the promise too
-*   early and defeated the whole point of the helper.)
-*
-* Lives in infra because it touches browser APIs (`requestAnimationFrame`,
-* `setTimeout`) that the architecture rules forbid from core. Core modules
-* that need to yield to the browser render loop should import this helper
-* directly via its file path.
-*/
-function yieldUntilNextPaint() {
-	return new Promise((resolve) => {
-		let resolved = false;
-		const done = () => {
-			if (resolved) return;
-			resolved = true;
-			resolve();
-		};
-		if (typeof requestAnimationFrame === "function") requestAnimationFrame(() => {
-			requestAnimationFrame(() => {
-				setTimeout(done, 0);
-			});
-		});
-		setTimeout(done, 100);
-	});
-}
-//#endregion
 //#region ../infra/src/wasm/faceProcessingWasmApi.ts
 var FaceProcessingWasmApi = class {
 	constructor(runtime = wasmRuntime) {
@@ -516,7 +469,7 @@ async function stopRecording(session) {
 	}
 }
 async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-CgAY2Xik.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-HcpfFvrJ.esm.js");
 	return loadDeepsightSession({
 		ds: options.ds,
 		storage: options.storage

package/dist/{permissionGuards-BHw_SD3h.esm.js → permissionGuards-DxbvOoZJ.esm.js}

@@ -1,4 +1,4 @@
-import { a as isWasmMotionPrimedForModule } from "./permissionServices-J5S1dEIf.esm.js";
+import { a as isWasmMotionPrimedForModule } from "./permissionServices-f7nBnW5P.esm.js";
 //#region src/internal/permissions/permissionGuards.ts
 function resolveStoredPermissionResult(fromEvent, fromContext) {
 	if (fromEvent === "granted" || fromEvent === "denied" || fromEvent === "prompt" || fromEvent === "refresh") return fromEvent;

package/dist/{permissionServices-J5S1dEIf.esm.js → permissionServices-f7nBnW5P.esm.js}

@@ -1,6 +1,6 @@
-import { r as WasmUtilProvider } from "./safeStorage-0bZuUtSP.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-Dp9m6aOh.esm.js";
 import { n as isAndroidWebView } from "./platform-DkcRc9JV.esm.js";
-import { t as MotionSensorProvider } from "./MotionSensorProvider-nnSH-kVd.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-Vlyhbcty.esm.js";
 import { a as stopCameraStream, o as clearCameraGrantedInDocument, r as requestCameraAccess, s as isCameraGrantedInDocument } from "./camera-_2sXMXiF.esm.js";
 //#region ../infra/src/media/permissions.ts
 async function queryPermission(name) {

package/dist/personhood.esm.js

@@ -1,17 +1,17 @@
-import { l as BrowserStorageProvider } from "./setup-CxO2a0J_.esm.js";
-import { r as WasmUtilProvider } from "./safeStorage-0bZuUtSP.esm.js";
+import { l as BrowserStorageProvider } from "./setup-BQ5-0CB6.esm.js";
+import { r as WasmUtilProvider } from "./safeStorage-Dp9m6aOh.esm.js";
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { C as createApi$1, v as randomUUID, y as getStoredHttpConfig } from "./trueSightService-BTf2KSpq.esm.js";
+import { C as createApi$1, v as randomUUID, y as getStoredHttpConfig } from "./trueSightService-CGUA9dm6.esm.js";
 import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
-import { _ as getThumbmarkId, m as isBrowserSimulation, n as getFingerprintEnabled, v as getDeviceFingerprintInfo, y as BrowserEnvironmentProvider } from "./sessionInitializer-Gw37lpQ_.esm.js";
+import { _ as getThumbmarkId, b as BrowserEnvironmentProvider, m as isBrowserSimulation, n as getFingerprintEnabled, y as getDeviceFingerprintInfo } from "./sessionInitializer-BpyJ5y2B.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.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, t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { a as stopCameraStream, r as requestCameraAccess } from "./camera-_2sXMXiF.esm.js";
-import { i as requestPermission, t as checkPermission } from "./permissionServices-J5S1dEIf.esm.js";
-import { f as stopStream, l as startDetection, p as FaceDetectionProvider, s as initializeDeepsightSession } from "./onDeviceFaceResults-BtD_Dij3.esm.js";
+import { i as requestPermission, t as checkPermission } from "./permissionServices-f7nBnW5P.esm.js";
 import { t as sleep } from "./ITimerCapability-DgdDzp8G.esm.js";
+import { f as stopStream, l as startDetection, p as FaceDetectionProvider, s as initializeDeepsightSession } from "./onDeviceFaceResults-C10QzrYa.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-D2XcXCZ4.esm.js";
 //#region src/modules/personhood/personhoodServices.ts
 /**

package/dist/qe-signature.esm.js

@@ -1,4 +1,4 @@
-import { a as NAMIRIAL_QES_CONSENT_KEYS, c as areAllConsented, o as NAMIRIAL_QES_PROVIDER_CODE, r as electronicSignatureMachine, s as QE_CONSENT_KEYS, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-BO07Vfiv.esm.js";
+import { a as NAMIRIAL_QES_CONSENT_KEYS, c as areAllConsented, o as NAMIRIAL_QES_PROVIDER_CODE, r as electronicSignatureMachine, s as QE_CONSENT_KEYS, t as createElectronicSignatureManager, u as getDefaultConsentChecks } from "./electronicSignatureManager-Bf6B6pEU.esm.js";
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/{runChildModule-DL_BwJt5.esm.js → runChildModule-BvxjSxjZ.esm.js}

@@ -1,5 +1,5 @@
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-BTf2KSpq.esm.js";
+import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-CGUA9dm6.esm.js";
 import { C as createEventBus } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
 import { t as fromCallback } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";

package/dist/safeStorage-Dp9m6aOh.esm.js

@@ -0,0 +1,422 @@
+import { c as wasmCallWrapper, s as ML_CALL_MAX_POLLS } from "./wasmWebClient-BJCaFeBL.esm.js";
+import { a as waitForWasm, n as getWasmStatus, o as warmupWasm, r as isWasmReady, s as wasmRuntime } from "./warmup-BOM-sD-6.esm.js";
+//#region ../infra/src/wasm/utilityWasmApi.ts
+/**
+* Utility / metadata domain facade over {@link WasmRuntime}.
+*
+* Holds no WASM state — the runtime owns every handle and buffer. The one
+* qualification: it owns exactly two JS-side flags that the C++ side does not
+* persist and that must be replayed into it at call time —
+*
+* - `dsEnabled_` (deepsight) is passed as an argument on every
+*   `prc`/`poc`/`rsp`/`ssl` call;
+* - `inspectorOpened_` is pushed into C++ inside {@link getMetadata}, right
+*   before reading the metadata, because `setInspectorOpened` may legitimately be
+*   called before WASM is initialized.
+*
+* Both are deliberately **unguarded** setters: they never throw, so the SDK can
+* record them during setup and have them honored once WASM comes up.
+*
+* `prc`/`poc`/`rsp` are the only methods here that hold the ML semaphore.
+* `ssl`/`stl`/`osv`/`oev`/`ckvcks` and everything else are unlocked **by design**
+* (decision D6) — never add locking.
+*
+* Method names, argument order and the pre-initialization error strings are
+* copied verbatim from the mirrored upstream `wasmApi.ts` so a WASM version bump
+* stays a diff against upstream (`docs/processes/WASM_VERSION_MIGRATION.md`).
+* `setSdkPlatform`'s message says "device type" on purpose — do not "fix" it.
+*/
+var UtilityWasmApi = class {
+	constructor(runtime = wasmRuntime) {
+		this.runtime = runtime;
+		this.inspectorOpened_ = false;
+		this.dsEnabled_ = false;
+	}
+	ens(image) {
+		return this.runtime.requireUtilityApi("Unable to encrypt the image, cpp API hasn't been initialized").ens(image);
+	}
+	isVirtualCamera(label) {
+		const utilityApi = this.runtime.requireUtilityApi("Unable to check if the camera is virtual, cpp API hasn't been initialized");
+		if (label) return utilityApi.isVirtualCamera(label);
+		return false;
+	}
+	estimatePerformance() {
+		return this.runtime.requireUtilityApi("Unable to estimate performance, cpp API hasn't been initialized").estimatePerformance();
+	}
+	async analyzeFrame(image) {
+		const message = "Unable to analyze the frame, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await this.runtime.allocateImageBuffers(image.width, image.height);
+		this.runtime.writeFrame(image);
+		this.runtime.requireUtilityApi(message).analyzeFrame();
+	}
+	/**
+	* Sets the native (C++) utility API's production mode. When `true`, the WASM
+	* module suppresses its verbose debug logging; when `false`, it emits it.
+	*
+	* @param productionMode - `true` to silence WASM logs, `false` to emit them.
+	* @throws If the WASM C++ API has not been initialized yet.
+	*/
+	async setProductionMode(productionMode) {
+		this.runtime.requireUtilityApi("Unable to set production mode, cpp API hasn't been initialized").setProductionMode(productionMode);
+	}
+	setSdkVersion(sdkVersion) {
+		this.runtime.requireUtilityApi("Unable to set sdk version, cpp API hasn't been initialized").setSdkVersion(sdkVersion);
+	}
+	setSdkPlatform(sdkPlatform) {
+		this.runtime.requireUtilityApi("Unable to set device type, cpp API hasn't been initialized").setSdkPlatform(sdkPlatform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set device info, cpp API hasn't been initialized").setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set browser info, cpp API hasn't been initialized").setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.runtime.requireUtilityApi("Unable to set camera info, cpp API hasn't been initialized").setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setZc(zc) {
+		this.runtime.requireUtilityApi("Unable to set zc, cpp API hasn't been initialized").setZc(zc);
+	}
+	setMotionStatus(motionStatus) {
+		this.runtime.requireUtilityApi("Unable to set motion status, cpp API hasn't been initialized").setMotionStatus(motionStatus);
+	}
+	setInspectorOpened(inspectorOpened) {
+		this.inspectorOpened_ = inspectorOpened;
+	}
+	getInspectorOpened() {
+		return this.inspectorOpened_;
+	}
+	setBackgroundMode(backgroundMode) {
+		this.runtime.requireUtilityApi("Unable to set background mode, cpp API hasn't been initialized").setBackgroundMode(backgroundMode);
+	}
+	setDsEnabled(enabled) {
+		this.dsEnabled_ = enabled;
+	}
+	getCheck() {
+		return this.runtime.requireUtilityApi("Unable to get check, cpp API hasn't been initialized").getCheck();
+	}
+	getMetadata() {
+		const utilityApi = this.runtime.requireUtilityApi("Unable to get metadata, cpp API hasn't been initialized");
+		utilityApi.setInspectorOpened(this.inspectorOpened_);
+		return utilityApi.getMetadata();
+	}
+	async prc() {
+		const message = "Unable to prc, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).prc(this.dsEnabled_, false), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "prc"
+		});
+	}
+	async poc(output) {
+		const message = "Unable to poc, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).poc(this.dsEnabled_, output), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "poc"
+		});
+	}
+	async rsp() {
+		const message = "Unable to rsp, cpp API hasn't been initialized";
+		this.runtime.requireUtilityApi(message);
+		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).rsp(this.dsEnabled_), true, {
+			maxPolls: ML_CALL_MAX_POLLS,
+			label: "rsp"
+		});
+	}
+	ssl() {
+		this.runtime.requireUtilityApi("Unable to ssl, cpp API hasn't been initialized").ssl(this.dsEnabled_);
+	}
+	stl() {
+		this.runtime.requireUtilityApi("Unable to stl, cpp API hasn't been initialized").stl();
+	}
+	osv() {
+		this.runtime.requireUtilityApi("Unable to set sensor beginning timestamp, cpp API hasn't been initialized").osv();
+	}
+	oev() {
+		this.runtime.requireUtilityApi("Unable to set sensor ending timestamp, cpp API hasn't been initialized").oev();
+	}
+	ckvcks(data) {
+		this.runtime.requireUtilityApi("Unable to ckvcks, cpp API hasn't been initialized").ckvcks(data);
+	}
+	/**
+	* Clear all states, not related to ml pipelines
+	*/
+	resetOther() {
+		this.runtime.requireUtilityApi("Unable to reset other states, cpp API hasn't been initialized").resetOther();
+	}
+	/**
+	* Full reset. Pipelines first, then the non-pipeline state — the order the
+	* mirrored upstream wrapper uses.
+	*/
+	reset() {
+		this.runtime.resetAllPipelines();
+		this.resetOther();
+	}
+};
+const utilityWasmApi = new UtilityWasmApi();
+//#endregion
+//#region ../infra/src/providers/wasm/BaseWasmProvider.ts
+/**
+* Base provider class that abstracts common WASM functionality.
+* This serves as a foundation for specific ML capability providers
+* like FaceDetectionProvider and IdCaptureProvider.
+*/
+var BaseWasmProvider = class {
+	/**
+	* Creates a new BaseWasmProvider
+	* @param pipelineType - The WASM pipeline type this provider uses
+	*/
+	constructor(pipelineType) {
+		this._isInitialized = false;
+		this.pipelineType = pipelineType;
+	}
+	/**
+	* Returns whether this provider has been initialized.
+	*/
+	get initialized() {
+		return this._isInitialized;
+	}
+	getPipelineType() {
+		if (this.pipelineType === void 0) throw new Error(`${this.constructor.name} has no pipeline type configured.`);
+		return this.pipelineType;
+	}
+	/**
+	* Initializes the provider by ensuring WASM is loaded
+	* @param config - Provider configuration
+	* @param pipeline - The pipeline type to warm up ('selfie', 'idCapture', etc.)
+	*/
+	async initializeBase(config, pipeline) {
+		if (this._isInitialized) return;
+		const status = getWasmStatus();
+		if (status.isLoading || isWasmReady() || status.error) {
+			if (!(status.isLoading && status.loadedPipelines.includes(pipeline))) await waitForWasm();
+			if (this.pipelineType !== void 0 && !getWasmStatus().loadedPipelines.includes(pipeline)) throw new Error(`WASM pipeline "${pipeline}" is not loaded.`);
+		} else {
+			if (!config.wasmPath || !config.glueCodePath && !config.loadGlue) throw new Error("WASM path and glue code path are required. Call warmupWasm() first.");
+			await warmupWasm({
+				...config,
+				wasmPath: config.wasmPath,
+				glueCodePath: config.glueCodePath ?? "",
+				pipelines: [pipeline]
+			});
+		}
+		this._isInitialized = true;
+	}
+	/**
+	* Ensures the provider is initialized before performing operations.
+	* @throws Error if not initialized
+	*/
+	ensureInitialized() {
+		if (!this._isInitialized) throw new Error(`${this.constructor.name} not initialized. Call initialize() first.`);
+	}
+	/**
+	* Processes a frame through the WASM pipeline
+	* @param image - Image data to process
+	* @returns The pipeline result (type depends on pipeline - WASM returns any)
+	*/
+	async processFrameWasm(image) {
+		this.ensureInitialized();
+		const pipelineType = this.getPipelineType();
+		await wasmRuntime.allocateImageBuffers(image.width, image.height);
+		await wasmRuntime.handleDetectionCallAndUpdateState(pipelineType);
+		return await wasmRuntime.process(image, pipelineType);
+	}
+	/**
+	* Resets the pipeline to its initial state.
+	* Safe to call even if not initialized (no-op in that case).
+	*/
+	reset() {
+		if (this._isInitialized && this.pipelineType !== void 0) wasmRuntime.resetPipeline(this.pipelineType);
+	}
+	/**
+	* Disposes of resources and resets initialization state.
+	* Safe to call even if not initialized.
+	*/
+	async dispose() {
+		this.reset();
+		this._isInitialized = false;
+	}
+};
+//#endregion
+//#region ../infra/src/providers/wasm/WasmUtilProvider.ts
+var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
+	static async getInstance() {
+		if (WasmUtilProvider.instance) return WasmUtilProvider.instance;
+		if (WasmUtilProvider.initPromise) return WasmUtilProvider.initPromise;
+		WasmUtilProvider.initPromise = (async () => {
+			const instance = new WasmUtilProvider();
+			await instance.initializeBase({}, "selfie");
+			WasmUtilProvider.instance = instance;
+			return instance;
+		})();
+		return WasmUtilProvider.initPromise;
+	}
+	static resetInstance() {
+		WasmUtilProvider.instance = void 0;
+		WasmUtilProvider.initPromise = void 0;
+	}
+	constructor() {
+		super(void 0);
+	}
+	async initialize(config) {
+		if (this.initialized) return;
+		const pipeline = config.pipelines?.[0] ?? "selfie";
+		await this.initializeBase(config, pipeline);
+	}
+	async processFrame(_image) {
+		throw new Error("WasmUtilProvider does not support frame processing. Use encryptImage() instead.");
+	}
+	encryptImage(image) {
+		this.ensureInitialized();
+		return utilityWasmApi.ens(image);
+	}
+	setSdkVersion(version) {
+		this.ensureInitialized();
+		utilityWasmApi.setSdkVersion(version);
+	}
+	setSdkPlatform(platform) {
+		this.ensureInitialized();
+		utilityWasmApi.setSdkPlatform(platform);
+	}
+	setDeviceInfo(deviceInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		utilityWasmApi.setDeviceInfo(deviceInfo, overrideExisting);
+	}
+	setBrowserInfo(browserInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		utilityWasmApi.setBrowserInfo(browserInfo, overrideExisting);
+	}
+	setCameraInfo(cameraInfo, overrideExisting = true) {
+		this.ensureInitialized();
+		utilityWasmApi.setCameraInfo(cameraInfo, overrideExisting);
+	}
+	setMotionStatus(status) {
+		this.ensureInitialized();
+		utilityWasmApi.setMotionStatus(status);
+	}
+	setBackgroundMode(backgroundMode) {
+		this.ensureInitialized();
+		utilityWasmApi.setBackgroundMode(backgroundMode);
+	}
+	setOnDeviceMode(enabled) {
+		this.ensureInitialized();
+		wasmRuntime.setOnDeviceMode(enabled);
+	}
+	setZc(zc) {
+		this.ensureInitialized();
+		utilityWasmApi.setZc(zc);
+	}
+	setInspectorOpened(opened) {
+		this.ensureInitialized();
+		utilityWasmApi.setInspectorOpened(opened);
+	}
+	getInspectorOpened() {
+		return utilityWasmApi.getInspectorOpened();
+	}
+	/**
+	* Toggles the WASM module's production mode. When `true`, the native module
+	* suppresses its verbose debug logging/console output; when `false`, those
+	* logs are emitted. The SDK forces this to `true` by default and only flips
+	* it off when the caller opts in via `setup({ wasm: { showLogs: true } })`.
+	*
+	* @param productionMode - `true` to silence WASM logs, `false` to emit them.
+	*/
+	async setProductionMode(productionMode) {
+		this.ensureInitialized();
+		await utilityWasmApi.setProductionMode(productionMode);
+	}
+	getMetadata() {
+		this.ensureInitialized();
+		return utilityWasmApi.getMetadata();
+	}
+	async analyzeFrame(image) {
+		this.ensureInitialized();
+		await utilityWasmApi.analyzeFrame(image);
+	}
+	getCheck() {
+		this.ensureInitialized();
+		return utilityWasmApi.getCheck();
+	}
+	getPipelineState() {
+		this.ensureInitialized();
+		return wasmRuntime.getPipelineState();
+	}
+	estimatePerformance() {
+		this.ensureInitialized();
+		return utilityWasmApi.estimatePerformance();
+	}
+	isVirtualCamera(label) {
+		this.ensureInitialized();
+		return utilityWasmApi.isVirtualCamera(label);
+	}
+	async prc() {
+		this.ensureInitialized();
+		await utilityWasmApi.prc();
+	}
+	async poc(output) {
+		this.ensureInitialized();
+		await utilityWasmApi.poc(output);
+	}
+	async rsp() {
+		this.ensureInitialized();
+		await utilityWasmApi.rsp();
+	}
+	ssl() {
+		this.ensureInitialized();
+		utilityWasmApi.ssl();
+	}
+	stl() {
+		this.ensureInitialized();
+		utilityWasmApi.stl();
+	}
+	osv() {
+		this.ensureInitialized();
+		utilityWasmApi.osv();
+	}
+	oev() {
+		this.ensureInitialized();
+		utilityWasmApi.oev();
+	}
+	ckvcks(data) {
+		this.ensureInitialized();
+		utilityWasmApi.ckvcks(data);
+	}
+};
+//#endregion
+//#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
+export { utilityWasmApi as a, BaseWasmProvider as i, resolveSessionStorage as n, WasmUtilProvider as r, resolveLocalStorage as t };