@incodetech/core 2.1.0-rc.3 → 2.1.0-rc.5

package/dist/sessionInitializer-IghS6XM8.esm.js

@@ -0,0 +1,547 @@
+import { r as getToken, s as setToken, t as api } from "./api-DsbUi7TO.esm.js";
+import { _ as getAnalyticsBatcher, g as addEvent } from "./events-1wxZ97yf.esm.js";
+import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
+import { n as flushDeviceStatsQueue, r as resetDeviceStatsQueue } from "./stats-BVy52wLy.esm.js";
+import { i as UAParser, n as getThumbmarkId, r as getParsedUserAgent, t as isBrowserSimulation } from "./browserSimulation-CWJhFPZ2.esm.js";
+import { i as linkSessionWithTRI, r as isTRIStarted } from "./tri-CFBjqf5E.esm.js";
+
+//#region ../infra/src/providers/browser/BrowserEnvironmentProvider.ts
+var BrowserEnvironmentProvider = class {
+	getScreenDimensions() {
+		if (typeof screen === "undefined") return {
+			width: 0,
+			height: 0
+		};
+		return {
+			width: screen.width,
+			height: screen.height
+		};
+	}
+	generateCanvasFingerprint() {
+		try {
+			if (typeof document === "undefined") return "";
+			const canvas = document.createElement("canvas");
+			const ctx = canvas.getContext("2d");
+			if (!ctx) return "";
+			ctx.textBaseline = "top";
+			ctx.font = "14px Arial";
+			ctx.fillText("fingerprint", 2, 2);
+			return canvas.toDataURL().slice(-50);
+		} catch {
+			return "";
+		}
+	}
+	getWebGLRenderer() {
+		try {
+			if (typeof document === "undefined") return "";
+			const canvas = document.createElement("canvas");
+			const gl = canvas.getContext("webgl") || canvas.getContext("experimental-webgl");
+			if (!gl) return "";
+			const debugInfo = gl.getExtension("WEBGL_debug_renderer_info");
+			if (!debugInfo) return "";
+			return gl.getParameter(debugInfo.UNMASKED_RENDERER_WEBGL) || "";
+		} catch {
+			return "";
+		}
+	}
+	getWindowProperty(prop) {
+		if (typeof window === "undefined") return;
+		return window[prop];
+	}
+	getNavigatorProperty(prop) {
+		if (typeof navigator === "undefined") return;
+		return navigator[prop];
+	}
+	getNavigatorPrefixes() {
+		if (typeof navigator === "undefined") return {
+			webkit: false,
+			moz: false,
+			o: false,
+			ms: false
+		};
+		const nav = navigator;
+		return {
+			webkit: nav.webkitGetUserMedia !== void 0,
+			moz: nav.mozGetUserMedia !== void 0,
+			o: nav.oGetUserMedia !== void 0,
+			ms: nav.msGetUserMedia !== void 0
+		};
+	}
+	getMaxTouchPoints() {
+		if (typeof navigator === "undefined") return 0;
+		return navigator.maxTouchPoints;
+	}
+	hasOnTouchStart() {
+		if (typeof window !== "undefined" && "ontouchstart" in window) return true;
+		if (typeof document !== "undefined") return "ontouchstart" in document.documentElement;
+		return false;
+	}
+	getNavigatorProductSub() {
+		if (typeof navigator === "undefined") return;
+		return navigator.productSub;
+	}
+	getEvalToStringLength() {
+		return eval.toString().length;
+	}
+	tryFirefoxToSource() {
+		try {
+			throw "a";
+		} catch (err) {
+			try {
+				err.toSource();
+				return true;
+			} catch {
+				return false;
+			}
+		}
+	}
+	async fetchJson(url, timeoutMs = 3e3) {
+		try {
+			if (typeof fetch === "undefined") return null;
+			const controller = new AbortController();
+			const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+			const response = await fetch(url, { signal: controller.signal });
+			clearTimeout(timeoutId);
+			return await response.json();
+		} catch {
+			return null;
+		}
+	}
+	async enumerateVideoDeviceLabels() {
+		try {
+			if (typeof navigator === "undefined" || !navigator.mediaDevices?.enumerateDevices) return [];
+			return (await navigator.mediaDevices.enumerateDevices()).filter((device) => device.kind === "videoinput").map((device) => device.label);
+		} catch {
+			return [];
+		}
+	}
+	getTimestamp() {
+		return Date.now();
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/BrowserInfoProvider.ts
+var BrowserInfoProvider = class {
+	checkWebRtcSupport() {
+		if (typeof window === "undefined") return false;
+		const hasRTCPeerConnection = "RTCPeerConnection" in window || "webkitRTCPeerConnection" in window || "mozRTCPeerConnection" in window;
+		const hasGetUserMedia = typeof navigator !== "undefined" && navigator.mediaDevices?.getUserMedia !== void 0;
+		return hasRTCPeerConnection && hasGetUserMedia;
+	}
+	getBrowserInfo() {
+		const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+		const result = new UAParser(userAgent).getResult();
+		return {
+			userAgent,
+			isWebRtcSupported: this.checkWebRtcSupport(),
+			browser: {
+				name: result.browser.name,
+				version: result.browser.version
+			},
+			os: {
+				name: result.os.name,
+				version: result.os.version
+			},
+			device: {
+				model: result.device.model,
+				type: result.device.type,
+				vendor: result.device.vendor
+			},
+			engine: {
+				name: result.engine.name,
+				version: result.engine.version
+			},
+			cpu: { architecture: result.cpu.architecture }
+		};
+	}
+};
+
+//#endregion
+//#region ../infra/src/device/getDeviceData.ts
+const HIGH_ENTROPY_HINTS = new Set([
+	"model",
+	"platformVersion",
+	"fullVersionList",
+	"brands",
+	"platform"
+]);
+function getFallbackDeviceInfo() {
+	const parsed = getParsedUserAgent();
+	return {
+		device: { model: parsed.device.model },
+		os: {
+			name: parsed.os.name,
+			version: parsed.os.version
+		},
+		browser: {
+			name: parsed.browser.name,
+			version: parsed.browser.version
+		}
+	};
+}
+function sanitizeString(value) {
+	return value?.trim() || void 0;
+}
+function extractPrimaryBrandInfo(fullVersionList, brands) {
+	const primaryBrand = fullVersionList?.[0] || brands?.[0];
+	return {
+		name: sanitizeString(primaryBrand?.brand),
+		version: sanitizeString(primaryBrand?.version)
+	};
+}
+async function getHighEntropyDeviceInfo(userAgentData) {
+	const highEntropyValues = await userAgentData.getHighEntropyValues(Array.from(HIGH_ENTROPY_HINTS));
+	const { name: browserName, version: browserVersion } = extractPrimaryBrandInfo(highEntropyValues.fullVersionList, userAgentData.brands);
+	return {
+		device: { model: sanitizeString(highEntropyValues.model) },
+		os: {
+			name: sanitizeString(highEntropyValues.platform),
+			version: sanitizeString(highEntropyValues.platformVersion)
+		},
+		browser: {
+			name: browserName,
+			version: browserVersion
+		}
+	};
+}
+const checkForUnbrandedBrowser = (browser) => {
+	const userAgent = typeof navigator !== "undefined" ? navigator.userAgent : "";
+	const fallback = getFallbackDeviceInfo();
+	if (!userAgent) return browser;
+	try {
+		return {
+			...browser,
+			name: fallback.browser.name,
+			version: fallback.browser.version
+		};
+	} catch {
+		return {
+			...browser,
+			name: "Unknown",
+			version: "Unknown"
+		};
+	}
+};
+function mergeDeviceInfo(fallback, enhanced) {
+	return {
+		device: { model: enhanced.device?.model || fallback.device.model },
+		os: {
+			name: enhanced.os?.name || fallback.os.name,
+			version: enhanced.os?.version || fallback.os.version
+		},
+		browser: checkForUnbrandedBrowser({
+			name: enhanced.browser?.name || fallback.browser.name,
+			version: enhanced.browser?.version || fallback.browser.version
+		})
+	};
+}
+function isUserAgentClientHintsSupported(navigator$1) {
+	return Boolean(navigator$1.userAgentData?.getHighEntropyValues && typeof navigator$1.userAgentData.getHighEntropyValues === "function");
+}
+async function getDeviceFingerprintInfo() {
+	if (typeof navigator === "undefined") return {
+		device: {},
+		os: {},
+		browser: {}
+	};
+	const customNavigator = navigator;
+	const fallbackInfo = getFallbackDeviceInfo();
+	if (!isUserAgentClientHintsSupported(customNavigator)) return fallbackInfo;
+	try {
+		return mergeDeviceInfo(fallbackInfo, await getHighEntropyDeviceInfo(customNavigator.userAgentData));
+	} catch {
+		return fallbackInfo;
+	}
+}
+
+//#endregion
+//#region ../infra/src/providers/browser/FingerprintProvider.ts
+var FingerprintProvider = class {
+	constructor(ipLookup) {
+		this.ipLookup = ipLookup;
+	}
+	async getFingerprint(disableIpify = false) {
+		const visitorId = await getThumbmarkId();
+		const [deviceInfo, ip] = await Promise.all([getDeviceFingerprintInfo(), disableIpify ? Promise.resolve("") : this.ipLookup.getIp()]);
+		return {
+			visitorId,
+			ip,
+			deviceInfo
+		};
+	}
+};
+
+//#endregion
+//#region ../infra/src/providers/browser/IpifyProvider.ts
+let cachedIp;
+let inFlightLookup;
+/**
+* Resets the module-level IP cache. Intended for tests and full session resets.
+*/
+function resetIpifyCache() {
+	cachedIp = void 0;
+	inFlightLookup = void 0;
+}
+async function fetchIpFromIpify() {
+	if (typeof fetch === "undefined") return "";
+	let timeoutId = 0;
+	const controller = new AbortController();
+	if (AbortSignal.timeout) {
+		const signal = AbortSignal.timeout(3e3);
+		return (await (await fetch("https://api.ipify.org?format=json", { signal })).json()).ip;
+	}
+	const timeoutPromise = new Promise((_, reject) => {
+		timeoutId = setTimeout(() => {
+			controller.abort();
+			reject(/* @__PURE__ */ new Error("Request timeout"));
+		}, 3e3);
+	});
+	const fetchPromise = fetch("https://api.ipify.org?format=json", { signal: controller.signal }).then((res) => res.json()).then((data) => data.ip);
+	const result = await Promise.race([fetchPromise, timeoutPromise]);
+	clearTimeout(timeoutId);
+	return result;
+}
+var IpifyProvider = class {
+	async getIp() {
+		if (cachedIp !== void 0) return cachedIp;
+		if (inFlightLookup) return inFlightLookup;
+		inFlightLookup = (async () => {
+			try {
+				const ip = await fetchIpFromIpify();
+				cachedIp = ip;
+				return ip;
+			} catch {
+				cachedIp = "";
+				return "";
+			} finally {
+				inFlightLookup = void 0;
+			}
+		})();
+		return inFlightLookup;
+	}
+};
+
+//#endregion
+//#region src/internal/featureConfig/featureConfigService.ts
+let cachedFeatures$1 = null;
+/**
+* Checks if a feature is enabled in the feature config.
+*/
+function isFeatureEnabled(feature, features) {
+	return features?.find((f) => f.feature === feature)?.enabled ?? false;
+}
+/**
+* Fetches feature configuration from the backend.
+* Results are cached for the session lifetime.
+*/
+async function fetchFeatureConfig(signal) {
+	if (cachedFeatures$1) return cachedFeatures$1;
+	const response = await api.get(endpoints.featureConfig, { signal });
+	if (!response.ok) throw new Error(`Failed to fetch feature config: ${response.status} ${response.statusText}`);
+	cachedFeatures$1 = response.data;
+	return cachedFeatures$1;
+}
+/**
+* Resets the cached feature config (useful for testing).
+*/
+function resetFeatureConfigCache() {
+	cachedFeatures$1 = null;
+}
+
+//#endregion
+//#region src/internal/version/sdkVersion.ts
+const SDK_VERSION = "2.1.0-rc.5";
+
+//#endregion
+//#region src/internal/fingerprint/fingerprintService.ts
+function formatOsVersion(os) {
+	return `${os.name || "Unknown"} ${os.version || ""}`.trim();
+}
+function formatBrowser(browser) {
+	if (!browser.name || !browser.version) return "Unknown";
+	return `${browser.name} ${browser.version}`;
+}
+async function submitDeviceFingerprint(options = {}, dependencies) {
+	const { disableIpify = false, hostingApp, signal } = options;
+	const fingerprint = await dependencies.fingerprintProvider.getFingerprint(disableIpify);
+	const hasLiedBrowser = isBrowserSimulation(dependencies.browserEnv);
+	const payload = {
+		hash: fingerprint.visitorId || "",
+		ip: fingerprint.ip || "",
+		deviceType: "WEBAPP",
+		data: JSON.stringify(fingerprint),
+		osVersion: formatOsVersion(fingerprint.deviceInfo.os),
+		deviceModel: fingerprint.deviceInfo.device.model || "",
+		browser: formatBrowser(fingerprint.deviceInfo.browser),
+		hasLiedBrowser,
+		sdkVersion: SDK_VERSION,
+		hostingApp: hostingApp ?? "Web SDK"
+	};
+	const response = await api.post(endpoints.deviceFingerprint, payload, { signal });
+	if (!response.ok) throw new Error(`Failed to submit fingerprint: ${response.status} ${response.statusText}`);
+	return response.data;
+}
+
+//#endregion
+//#region src/internal/session/sessionInitializer.ts
+let sessionInitialized = false;
+let cachedFeatures = null;
+let cachedDisableIpify = false;
+let clientIpLookupEnabled = true;
+let clientFingerprintEnabled = true;
+function setClientIpLookupEnabled(enabled) {
+	clientIpLookupEnabled = enabled;
+}
+function setClientFingerprintEnabled(enabled) {
+	clientFingerprintEnabled = enabled;
+}
+function resolveDisableIpify(serverDisableIpify) {
+	return !clientIpLookupEnabled || serverDisableIpify;
+}
+let cachedFingerprintSuccess = false;
+let cachedFingerprintResult;
+let sessionInitPromise = null;
+/**
+* Activates a session by setting the auth token on the HTTP client and
+* preloading session-scoped state.
+*
+* Performs:
+* 1. Sets the token (and clears stale session-init cache if the token changed)
+* 2. Links the session with the TRI activity if TRI is enabled
+* 3. Fetches feature configuration from backend
+* 4. Submits device fingerprint
+* 5. Starts the analytics batcher so buffered events are flushed
+*
+* Results are cached per token. Calling again with the same token returns the
+* cached result; calling with a different token re-initializes from scratch.
+*
+* @param options - Session activation options (`token` required)
+* @returns Session initialization result with feature config
+*
+* @example
+* ```ts
+* await setup({ apiURL: 'https://api.incode.com' });
+* const session = await createSession('api-key', options);
+* const { features } = await initializeSession({ token: session.token });
+*
+* // Check feature flags
+* if (isFeatureEnabled('DISABLE_IPIFY', features.features)) {
+*   // Handle disabled ipify
+* }
+* ```
+*/
+async function initializeSession(options = {}) {
+	const { token, hostingApp, signal } = options;
+	if (token !== void 0 && token !== getToken()) {
+		setToken(token);
+		resetSessionInit();
+		if (isTRIStarted()) await linkSessionWithTRI(token);
+	}
+	if (sessionInitialized && cachedFeatures) return {
+		features: cachedFeatures,
+		disableIpify: cachedDisableIpify,
+		fingerprintSuccess: cachedFingerprintSuccess,
+		fingerprintResult: cachedFingerprintResult
+	};
+	if (sessionInitPromise) return sessionInitPromise;
+	sessionInitPromise = (async () => {
+		let features;
+		let serverDisableIpify = false;
+		try {
+			features = await fetchFeatureConfig(signal);
+			serverDisableIpify = isFeatureEnabled("DISABLE_IPIFY", features.features);
+		} catch {
+			features = { sessionIdentifier: "" };
+		}
+		const disableIpify = resolveDisableIpify(serverDisableIpify);
+		let fingerprintSuccess = false;
+		let fingerprintResult;
+		if (clientFingerprintEnabled) try {
+			const fingerprintProvider = new FingerprintProvider(new IpifyProvider());
+			const browserEnv = new BrowserEnvironmentProvider();
+			fingerprintResult = await submitDeviceFingerprint({
+				disableIpify,
+				hostingApp,
+				signal
+			}, {
+				fingerprintProvider,
+				browserEnv
+			});
+			fingerprintSuccess = true;
+			flushDeviceStatsQueue();
+		} catch (error) {
+			console.warn("Failed to submit device fingerprint:", error);
+		}
+		else flushDeviceStatsQueue();
+		try {
+			const browserInfo = new BrowserInfoProvider().getBrowserInfo();
+			addEvent({
+				code: "browser",
+				payload: {
+					userAgent: browserInfo.userAgent,
+					isWebRtcSupported: browserInfo.isWebRtcSupported,
+					browser: browserInfo.browser,
+					os: browserInfo.os,
+					device: browserInfo.device,
+					engine: browserInfo.engine,
+					cpu: browserInfo.cpu
+				}
+			});
+		} catch (error) {
+			console.warn("Failed to send browser info event:", error);
+		}
+		sessionInitialized = true;
+		cachedFeatures = features;
+		cachedDisableIpify = disableIpify;
+		cachedFingerprintSuccess = fingerprintSuccess;
+		cachedFingerprintResult = fingerprintResult;
+		return {
+			features,
+			disableIpify,
+			fingerprintSuccess,
+			fingerprintResult
+		};
+	})().finally(() => {
+		sessionInitPromise = null;
+		getAnalyticsBatcher()?.start();
+	});
+	return sessionInitPromise;
+}
+/**
+* Gets the cached disableIpify flag.
+* Returns false if session hasn't been initialized.
+*/
+function getDisableIpify() {
+	if (!clientIpLookupEnabled) return true;
+	return cachedDisableIpify;
+}
+function getSessionFingerprintResult() {
+	return cachedFingerprintResult;
+}
+/**
+* Gets whether client-side device-fingerprint submission is enabled.
+* Consumed by `loadDeepsightSession` to resolve `disableFingerprint`
+* (mirrors how `getDisableIpify` is used).
+*/
+function getFingerprintEnabled() {
+	return clientFingerprintEnabled;
+}
+/**
+* Resets session initialization state.
+* Useful for testing or when starting a new session.
+*/
+function resetSessionInit() {
+	sessionInitialized = false;
+	cachedFeatures = null;
+	cachedDisableIpify = false;
+	cachedFingerprintSuccess = false;
+	cachedFingerprintResult = void 0;
+	sessionInitPromise = null;
+	resetFeatureConfigCache();
+	resetIpifyCache();
+	resetDeviceStatsQueue();
+}
+
+//#endregion
+export { resetSessionInit as a, IpifyProvider as c, BrowserEnvironmentProvider as d, initializeSession as i, FingerprintProvider as l, getFingerprintEnabled as n, setClientFingerprintEnabled as o, getSessionFingerprintResult as r, setClientIpLookupEnabled as s, getDisableIpify as t, getDeviceFingerprintInfo as u };

package/dist/{setup-CpRnXxn8.d.ts → setup-BbAMk9Rg.d.ts}

@@ -1,5 +1,5 @@
-import { n as WasmPipeline } from "./warmup-BJZPQIiX.js";
-import { s as TransactionalRiskIntelligenceSetupConfig } from "./index-XTtxaahe.js";
+import { n as WasmPipeline } from "./warmup-DzJ0I4Kv.js";
+import { s as TransactionalRiskIntelligenceSetupConfig } from "./index-CCG6MnCO.js";
 
 //#region src/setup.d.ts
 
@@ -163,6 +163,21 @@ type SetupOptions = {
    * (lookup enabled).
    */
   ipLookup?: boolean;
+  /**
+   * Disables client-side device-fingerprint submission
+   * (`POST /omni/add/device-fingerprint`). When `false`, the SDK skips that
+   * request entirely — `initializeSession` still runs, but
+   * `getSessionFingerprintResult()` resolves to `undefined`, so
+   * `showMandatoryConsent`/`regulationType` are not available and mandatory
+   * consent will not be auto-injected into `flow`/`workflow`.
+   *
+   * Also blanks the `fingerprintHash` field of the Deepsight metadata bundle
+   * collected during face capture (selfie/authentication/id/personhood) — the
+   * descriptive device fields and `webglFingerprint` are unaffected.
+   *
+   * Default: `true` (fingerprint submission enabled).
+   */
+  fingerprint?: boolean;
   /**
    * Disables the browser devtools detector for local development. When `true`,
    * the detector is **not** started, so devtools no longer gets repeatedly

package/dist/{setup-DHc6OaHm.esm.js → setup-BvUZozWd.esm.js}

@@ -2,11 +2,11 @@ import { f as deriveSiblingJsPath, r as warmupWasm, t as WasmUtilProvider } from
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
 import { a as resetApi, i as isApiConfigured, n as getApi, r as getToken, t as api } from "./api-DsbUi7TO.esm.js";
 import { i as upgradeToWasmHttpClient, n as installFreshHttpClient, r as resetHttpClientState, t as getStoredHttpConfig } from "./clientLifecycle-Ct7h9uxx.esm.js";
-import { f as getAnalyticsBatcher, m as setAnalyticsBatcher, p as resetAnalyticsBatcher, u as createAnalyticsBatchingService } from "./events-CqGY1yMq.esm.js";
-import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
-import { r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-CYcScXcO.esm.js";
-import { a as setClientIpLookupEnabled, i as resetSessionInit, r as initializeSession } from "./sessionInitializer-C_TYIgyk.esm.js";
-import { a as resetTRI, n as initializeTRI, o as resetTRIProviderInstance } from "./tri-BG1iJsr4.esm.js";
+import { _ as getAnalyticsBatcher, h as createAnalyticsBatchingService, v as resetAnalyticsBatcher, y as setAnalyticsBatcher } from "./events-1wxZ97yf.esm.js";
+import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
+import { r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-BVy52wLy.esm.js";
+import { a as resetSessionInit, i as initializeSession, o as setClientFingerprintEnabled, s as setClientIpLookupEnabled } from "./sessionInitializer-IghS6XM8.esm.js";
+import { a as resetTRI, n as initializeTRI, o as resetTRIProviderInstance } from "./tri-CFBjqf5E.esm.js";
 
 //#region ../infra/src/wasm/wasmDefaults.ts
 const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
@@ -424,6 +424,7 @@ let configured = false;
 */
 async function setup(options) {
 	if (options.ipLookup !== void 0) setClientIpLookupEnabled(options.ipLookup);
+	if (options.fingerprint !== void 0) setClientFingerprintEnabled(options.fingerprint);
 	if (!getAnalyticsBatcher()) setAnalyticsBatcher(createAnalyticsBatchingService({
 		endpoint: endpoints.events,
 		authToken: () => getToken(),
@@ -549,6 +550,7 @@ function reset() {
 	resetApi();
 	resetSessionInit();
 	setClientIpLookupEnabled(true);
+	setClientFingerprintEnabled(true);
 	resetAnalyticsBatcher();
 	resetHttpClientState();
 	resetTRI();

package/dist/signature.d.ts

@@ -1,6 +1,6 @@
-import "./StateMachine-C_AY4cs7.js";
-import { t as Manager } from "./Manager-CJ3G2zqi.js";
-import "./Actor-CGEelYtQ.js";
+import "./StateMachine-20ahmASR.js";
+import { t as Manager } from "./Manager-BfBOhrjh.js";
+import "./Actor-DYjXVMQm.js";
 
 //#region src/modules/signature/types.d.ts
 /**

package/dist/signature.esm.js

@@ -1,9 +1,8 @@
 import "./api-DsbUi7TO.esm.js";
-import { n as createManagerInstrumentation, t as topLevelStateName } from "./events-CqGY1yMq.esm.js";
-import { n as eventModuleNames } from "./types-ElOJAGaM.esm.js";
-import "./endpoints-BzMJFAPV.esm.js";
-import { l as createManager, s as createActor } from "./xstate.esm-Bomq1a0z.esm.js";
-import { t as signatureMachine } from "./signatureStateMachine-DtoiPzys.esm.js";
+import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
+import "./endpoints-CwrFQfW7.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
+import { t as signatureMachine } from "./signatureStateMachine-iT9BhNUf.esm.js";
 
 //#region src/modules/signature/signatureActor.ts
 function createSignatureActor(options) {

package/dist/{signatureStateMachine-DtoiPzys.esm.js → signatureStateMachine-iT9BhNUf.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Bomq1a0z.esm.js";
+import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
 
 //#region src/modules/signature/signatureServices.ts
 /**

package/dist/{stats-CYcScXcO.esm.js → stats-BVy52wLy.esm.js}

@@ -1,5 +1,5 @@
 import { r as getToken, t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-BzMJFAPV.esm.js";
+import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
 
 //#region src/modules/stats/statsServices.ts
 const deviceStatsQueue = [];

package/dist/stats.esm.js

@@ -1,5 +1,5 @@
 import "./api-DsbUi7TO.esm.js";
-import "./endpoints-BzMJFAPV.esm.js";
-import { n as flushDeviceStatsQueue, r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-CYcScXcO.esm.js";
+import "./endpoints-CwrFQfW7.esm.js";
+import { n as flushDeviceStatsQueue, r as resetDeviceStatsQueue, t as addDeviceStats } from "./stats-BVy52wLy.esm.js";
 
 export { addDeviceStats, flushDeviceStatsQueue, resetDeviceStatsQueue };

package/dist/{tri-BG1iJsr4.esm.js → tri-CFBjqf5E.esm.js}

@@ -120,7 +120,7 @@ const LAZY_IMPORT_OPTIONS = {
 	timeoutMs: 1e4,
 	disabledMessage: "TRI will be disabled for this session."
 };
-const importSdk = () => import("./tri.esm-DUC01NgO.esm.js");
+const importSdk = () => import("./tri.esm-BzYyqlPa.esm.js");
 /**
 * Concrete implementation of {@link ITransactionalRiskIntelligenceCapability}.
 *

package/dist/tri.d.ts

@@ -1,2 +1,2 @@
-import { a as startTRI, i as setupTRI, n as isTRIStarted, o as stopTRI, r as resetTRI, s as TransactionalRiskIntelligenceSetupConfig, t as createTRISession } from "./index-XTtxaahe.js";
+import { a as startTRI, i as setupTRI, n as isTRIStarted, o as stopTRI, r as resetTRI, s as TransactionalRiskIntelligenceSetupConfig, t as createTRISession } from "./index-CCG6MnCO.js";
 export { TransactionalRiskIntelligenceSetupConfig, createTRISession, isTRIStarted, resetTRI, setupTRI, startTRI, stopTRI };

package/dist/{tri.esm-DUC01NgO.esm.js → tri.esm-BzYyqlPa.esm.js}

@@ -1702,7 +1702,7 @@ async function Ht(t$1) {
 						return Promise.race([r$1, o$2]).finally(() => {
 							d(i$2);
 						});
-					}(() => import("./browser-DlFgHpoC-qLKs75Qp.esm.js"), 1e4);
+					}(() => import("./browser-DlFgHpoC-CR6x7ypG.esm.js"), 1e4);
 					jt = t$3, t$3.then((n$1) => {
 						null === n$1 && u(() => {
 							jt === t$3 && (jt = null);