@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/{phoneManager-FsJ0W2Ei.esm.js → phoneManager-IjhSv5XS.esm.js}

@@ -1,6 +1,6 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-Ba0wKHyX.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-CXdXufKg.esm.js";
 //#region src/modules/phone/phoneActor.ts
 function createPhoneActor(options) {
 	return createActor(phoneMachine, { input: { config: options.config } }).start();

package/dist/{phoneStateMachine-Ba0wKHyX.esm.js → phoneStateMachine-CXdXufKg.esm.js}

@@ -1,6 +1,6 @@
 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 { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { i as assign, 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 isOtpComplete, t as computeOtpValidationErrors } from "./otp-D2k3PeSL.esm.js";

package/dist/{platform-BJrm5nzZ.esm.js → platform-DkcRc9JV.esm.js}

@@ -43,6 +43,18 @@ function isAndroidWebView(userAgent) {
 	if (/SamsungBrowser|Firefox|EdgA|OPR|OPT|YaBrowser|HuaweiBrowser/i.test(ua)) return false;
 	return /\bVersion\/[\d.]+/.test(ua) && /\bChrome\/[\d.]+/.test(ua);
 }
+/**
+* True when an iOS/iPadOS host exposes the standard WebKit WebView user agent.
+* Native WebViews omit the product token used by Safari and branded browsers.
+*
+* In-app browsers are WebViews and report as such; whether one is *supported*
+* belongs to `isSupportedBrowser` in core.
+*/
+function isIOSWebView(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	if (!isIOS(ua) || !/AppleWebKit/i.test(ua) || !/Mobile\//i.test(ua)) return false;
+	return !/\b(?:Safari|CriOS|FxiOS|EdgiOS|OPiOS|OPT|YaBrowser)\//i.test(ua);
+}
 function isIPad(userAgent) {
 	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
 	const hasTouchPoints = typeof navigator !== "undefined" ? navigator.maxTouchPoints > 0 : false;
@@ -56,6 +68,22 @@ function isSafari(userAgent) {
 	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
 	return /Safari/i.test(ua) && !/Chrome|Chromium|Edge/i.test(ua);
 }
+/**
+* Desktop Safari on macOS (not iOS/iPadOS — `isIOS` also matches modern
+* iPads that report as "Mac OS" with touch points). The Apple-Wallet-web
+* handshake is the only wallet flow available on desktop Apple platforms,
+* so this is the signal that routes macOS Safari to the Apple provider.
+*/
+function isMacOsSafari(userAgent) {
+	const ua = userAgent || (typeof navigator !== "undefined" ? navigator.userAgent : "");
+	return /Mac OS/.test(ua) && !isIOS(ua) && isSafari(ua);
+}
+function isBraveBrowser() {
+	return typeof navigator !== "undefined" && "brave" in navigator;
+}
+function isIslandBrowser() {
+	return typeof navigator !== "undefined" && "island" in navigator;
+}
 const IPHONE_14_PLUS_DIMENSIONS = [
 	{
 		outerHeight: 852,
@@ -100,4 +128,4 @@ function isIPhone14OrHigher() {
 	return IPHONE_14_PLUS_DIMENSIONS.some((dims) => dims.outerHeight === outerHeight && dims.outerWidth === outerWidth || dims.innerHeight === innerHeight && dims.innerWidth === innerWidth);
 }
 //#endregion
-export { isIPad as a, isTabletWithoutAndroid as c, isIOS as i, isAndroidWebView as n, isIPhone14OrHigher as o, isDesktop as r, isSafari as s, isAndroid as t };
+export { isIOS as a, isIPhone14OrHigher as c, isSafari as d, isTabletWithoutAndroid as f, isDesktop as i, isIslandBrowser as l, isAndroidWebView as n, isIOSWebView as o, isBraveBrowser as r, isIPad as s, isAndroid as t, isMacOsSafari as u };

package/dist/qe-signature.d.ts

@@ -1,6 +1,6 @@
 import { t as Manager } from "./Manager-CQQ99QOI.js";
-import { _ as getDefaultConsentChecks, a as ElectronicSignatureConfig, d as QE_CONSENT_KEYS, h as areAllConsented, i as ConsentKey, r as ConsentChecks, s as ElectronicSignatureDocument } from "./types-DVmXIdzW.js";
-import { n as ElectronicSignatureState, o as electronicSignatureMachine } from "./electronicSignatureManager-CcUXQZS7.js";
+import { S as getDefaultConsentChecks, a as ElectronicSignatureConfig, b as areAllConsented, f as NAMIRIAL_QES_CONSENT_KEYS, h as QE_CONSENT_KEYS, i as ConsentKey, m as NamirialQesConsentKey, p as NAMIRIAL_QES_PROVIDER_CODE, r as ConsentChecks, s as ElectronicSignatureDocument, u as ElectronicSignatureProviderTerms } from "./types-D0gekt4U.js";
+import { n as ElectronicSignatureState, o as electronicSignatureMachine } from "./electronicSignatureManager-Ds-KEVTq.js";
 import "./electronic-signature.js";
 //#region src/modules/qe-signature/index.d.ts
 type QeSignatureConfig = Omit<ElectronicSignatureConfig, 'variant'>;
@@ -14,6 +14,8 @@ declare function createQeSignatureManager(options: {
   confirmFile(): void;
   viewDocument(url: string): void;
   closeDocumentView(): void;
+  viewApplicationForm(): void;
+  closeApplicationForm(): void;
   sign(): void;
   finish(): void;
   retry(): void;
@@ -21,4 +23,4 @@ declare function createQeSignatureManager(options: {
 };
 type QeSignatureManager = ReturnType<typeof createQeSignatureManager>;
 //#endregion
-export { type ConsentChecks, QE_CONSENT_KEYS, QeSignatureConfig, type ElectronicSignatureDocument as QeSignatureDocument, QeSignatureManager, type ElectronicSignatureState as QeSignatureState, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };
+export { type ConsentChecks, NAMIRIAL_QES_CONSENT_KEYS, NAMIRIAL_QES_PROVIDER_CODE, type NamirialQesConsentKey, QE_CONSENT_KEYS, QeSignatureConfig, type ElectronicSignatureDocument as QeSignatureDocument, QeSignatureManager, type ElectronicSignatureProviderTerms as QeSignatureProviderTerms, type ElectronicSignatureState as QeSignatureState, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };

package/dist/qe-signature.esm.js

@@ -1,4 +1,4 @@
-import { a as QE_CONSENT_KEYS, c as getDefaultConsentChecks, o as areAllConsented, r as electronicSignatureMachine, t as createElectronicSignatureManager } from "./electronicSignatureManager-DGbAJ00W.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-BJJH0Tvi.esm.js";
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {
@@ -7,4 +7,4 @@ function createQeSignatureManager(options) {
 	} });
 }
 //#endregion
-export { QE_CONSENT_KEYS, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };
+export { NAMIRIAL_QES_CONSENT_KEYS, NAMIRIAL_QES_PROVIDER_CODE, QE_CONSENT_KEYS, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };

package/dist/redirect-to-mobile.esm.js

@@ -1,3 +1,3 @@
-import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices } from "./redirectToMobileStateMachine-Cyv2x0PP.esm.js";
-import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-y4VQB11M.esm.js";
+import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices } from "./redirectToMobileStateMachine-CSWWgUTO.esm.js";
+import { n as createRedirectToMobileManagerFromActor, t as createRedirectToMobileManager } from "./redirectToMobileManager-FLEWJtv8.esm.js";
 export { createRedirectToMobileManager, createRedirectToMobileManagerFromActor, defaultRedirectToMobileServices, redirectToMobileMachine };

package/dist/{redirectToMobileManager-y4VQB11M.esm.js → redirectToMobileManager-FLEWJtv8.esm.js}

@@ -1,8 +1,8 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { s as createActor, 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 { n as redirectToMobileMachine, r as defaultRedirectToMobileServices, t as canResendSmsFromContext } from "./redirectToMobileStateMachine-Cyv2x0PP.esm.js";
+import { n as redirectToMobileMachine, r as defaultRedirectToMobileServices, t as canResendSmsFromContext } from "./redirectToMobileStateMachine-CSWWgUTO.esm.js";
 //#region src/modules/redirect-to-mobile/redirectToMobileActor.ts
 const POLL_INTERVAL_MS = 5e3;
 const QR_REFRESH_INTERVAL_MS = 5e3;

package/dist/{redirectToMobileStateMachine-Cyv2x0PP.esm.js → redirectToMobileStateMachine-CSWWgUTO.esm.js}

@@ -1,6 +1,6 @@
 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 { t as endpoints } from "./endpoints-B-3Q-LUw.esm.js";
 import { i as assign, 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";

package/dist/{rolldown-runtime-FZ4Itg2g.esm.js → rolldown-runtime-FDOR9p9I.esm.js}

@@ -5,24 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esmMin = (fn, res, err) => () => {
-	if (err) throw err[0];
-	try {
-		return fn && (res = fn(fn = 0)), res;
-	} catch (e) {
-		throw err = [e], e;
-	}
-};
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -37,6 +20,5 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	value: mod,
 	enumerable: true
 }) : target, mod));
-var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 //#endregion
-export { __toESM as a, __toCommonJS as i, __esmMin as n, __exportAll as r, __commonJSMin as t };
+export { __toESM as n, __commonJSMin as t };

package/dist/{runChildModule-Dukuw23X.esm.js → runChildModule-CI1gGWN1.esm.js}

@@ -1,9 +1,8 @@
 import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService---iW2KKJ.esm.js";
-import { C as createEventBus } from "./events-DYiyoSlx.esm.js";
+import { a as notifyTrueSightManagerStopped, i as notifyTrueSightFlowEvent } from "./trueSightService-BN-Hzw82.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";
-import { t as FACE_ERROR_CODES } from "./types-BN5RPPIZ.esm.js";
 //#region src/internal/flow-events/flowEvents.ts
 function createFlowEventBus() {
 	const eventBus = createEventBus();
@@ -196,23 +195,6 @@ function attachFlowEventEmitter(manager, options = {}) {
 	return manager;
 }
 //#endregion
-//#region src/internal/orchestration/advanceableErrors.ts
-/**
-* Module terminal-error codes an orchestrator should treat as "advance to the
-* next step" rather than "fail the flow". Decided here, at the orchestration
-* layer, so every consumer behaves identically. "Advanceable" is independent of
-* "retryable" (the module's own concern): it only decides what the flow does
-* *after* a terminal error. Note `NO_MORE_ATTEMPTS` subsumes the former
-* `USER_IS_NOT_RECOGNIZED` entry — see the contract test for the full matrix.
-*/
-const ADVANCEABLE_ERROR_CODES = [
-	FACE_ERROR_CODES.NONEXISTENT_CUSTOMER,
-	FACE_ERROR_CODES.HINT_NOT_PROVIDED,
-	FACE_ERROR_CODES.NO_MORE_ATTEMPTS
-];
-/** True when the given code is a module terminal error the flow should advance past rather than fail on. */
-const isAdvanceableError = (moduleErrorCode) => moduleErrorCode !== void 0 && ADVANCEABLE_ERROR_CODES.includes(moduleErrorCode);
-//#endregion
 //#region src/internal/orchestration/runChildModule.ts
 const runChildModule = fromCallback(({ sendBack, input }) => {
 	const { machine, config } = input;
@@ -239,4 +221,4 @@ const runChildModule = fromCallback(({ sendBack, input }) => {
 	};
 });
 //#endregion
-export { isAdvanceableError as n, attachFlowEventEmitter as r, runChildModule as t };
+export { attachFlowEventEmitter as n, runChildModule as t };

package/dist/safeStorage-B-trhxg6.esm.js

@@ -0,0 +1,423 @@
+import { c as wasmCallWrapper, s as ML_CALL_MAX_POLLS } from "./wasmWebClient-B7baE-Wf.esm.js";
+import { a as waitForWasm, n as getWasmStatus, o as warmupWasm, r as isWasmReady, s as wasmRuntime } from "./warmup-CUUnwYxe.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);
+	}
+	/**
+	* @deprecated Native label inspection has been unavailable since
+	* v2.14.49-post1; scheduled for removal in 3.0.0. Protected PRC/POC owns
+	* the authoritative decision: use `prc()` followed by `poc()` instead.
+	*/
+	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(pipelineType, image);
+	}
+	/**
+	* 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) {
+		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) {
+		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 };

package/dist/{sdkVersion-D1Bm59g6.esm.js → sdkVersion-BZh6dj53.esm.js}

@@ -1,4 +1,4 @@
 //#region src/internal/version/sdkVersion.ts
-const SDK_VERSION = "2.2.0";
+const SDK_VERSION = "2.3.0-rc.1+c6c04ca";
 //#endregion
 export { SDK_VERSION as t };

package/dist/selfie.d.ts

@@ -1,10 +1,10 @@
 import { t as IVisibilityObserverCapability } from "./IVisibilityObserverCapability-D4tvIB5v.js";
-import { a as SelfieCaptureOnlyMachine, c as SelfieActor, g as SelfieConfig, h as SelfieCaptureOnlyConfig, i as SelfieCaptureOnlyActor, l as SelfieMachine, n as FaceCaptureManagerState, o as selfieCaptureOnlyMachine, r as CreateSelfieCaptureOnlyActorOptions, t as FaceCaptureManager, u as selfieMachine } from "./faceCaptureManagerFactory-BxWPpxyd.js";
-import { t as CameraStream } from "./camera-9wWD-pwg.js";
-import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode } from "./types-Hmd7U0JA.js";
+import { _ as SelfieCaptureOnlyConfig, a as SelfieCaptureOnlyMachine, c as SelfieActor, g as processFace, h as ProcessFaceResponse, i as SelfieCaptureOnlyActor, l as SelfieMachine, n as FaceCaptureManagerState, o as selfieCaptureOnlyMachine, r as CreateSelfieCaptureOnlyActorOptions, t as FaceCaptureManager, u as selfieMachine, v as SelfieConfig } from "./faceCaptureManagerFactory-BeUl8fl1.js";
 import { n as PermissionStatus, t as PermissionResult } from "./types-BEwVKkLJ.js";
-import { t as DeepsightService } from "./deepsightService-DLVQS_RH.js";
-import { a as ProcessFaceResponse, i as createSelfieManagerFromActor, n as SelfieState, o as processFace, r as createSelfieManager, t as SelfieManager } from "./selfieManager-DwlCppg0.js";
+import { a as FaceCapturedImageData, i as FaceCaptureOnlyResponse, n as DetectionStatus, o as FaceErrorCode } from "./types-Bnl58jUQ.js";
+import { n as DeepsightService } from "./StreamCanvasCapture-_8gdW5Lk.js";
+import { t as CameraStream } from "./camera-9wWD-pwg.js";
+import { i as createSelfieManagerFromActor, n as SelfieState, r as createSelfieManager, t as SelfieManager } from "./selfieManager-4RRLi21P.js";
 //#region src/modules/selfie/selfieCaptureOnlyManager.d.ts
 type SelfieCaptureOnlyState = FaceCaptureManagerState;
 type SelfieCaptureOnlyManager = FaceCaptureManager;