@incodetech/core 0.0.0-dev-20260729-9461bce1 → 0.0.0-dev-20260729-e2dda0b0

package/dist/BrowserDiagnosticsCryptoProvider-BZqV7sJR.esm.js

@@ -0,0 +1,96 @@
+//#region ../infra/src/crypto/truesightKey.ts
+/** Interim P1 key id — the BE looks up the AES key by this label. */
+const TRUESIGHT_KID = "truesight-v1";
+const KEY_LENGTH_BYTES = 32;
+/** Recovers the key from its two obfuscated halves. Throws on malformed input. */
+function decodeTruesightKey(s0Base64, s1Base64) {
+	const s0 = fromBase64(s0Base64);
+	const s1 = fromBase64(s1Base64);
+	if (s0.length !== s1.length || s0.length === 0) throw new Error("truesight key halves are malformed");
+	const key = new Uint8Array(s0.length);
+	for (let i = 0; i < key.length; i += 1) key[i] = s1[(i + 7) % s1.length] ^ s0[i];
+	return key;
+}
+/**
+* The bundle's key, decoded lazily — `null` when this build carries no key
+* (defines absent → collect-only mode, uploads disabled). Returns a fresh
+* copy per call so callers may zero their copy after use.
+*/
+function getTruesightKey() {
+	if (typeof __TRUESIGHT_S0__ === "undefined" || typeof __TRUESIGHT_S1__ === "undefined") return null;
+	try {
+		const key = decodeTruesightKey(__TRUESIGHT_S0__, __TRUESIGHT_S1__);
+		return key.length === KEY_LENGTH_BYTES ? key : null;
+	} catch {
+		return null;
+	}
+}
+function fromBase64(value) {
+	return Uint8Array.from(atob(value), (char) => char.charCodeAt(0));
+}
+//#endregion
+//#region ../infra/src/providers/browser/BrowserDiagnosticsCryptoProvider.ts
+/**
+* Browser sealer for TrueSight diagnostics (ENG-48677 plan §1.5): JSON string →
+* gzip via native CompressionStream → AES-256-GCM via WebCrypto → contract
+* envelope. Designed to be loaded as a LAZY chunk — zero bytes on the host
+* page's critical path.
+*
+* The CryptoKey is imported once (non-extractable) and the raw bytes are zeroed
+* immediately after import; `getKeyBytes` must therefore return a fresh copy.
+*/
+var BrowserDiagnosticsCryptoProvider = class {
+	constructor(getKeyBytes = getTruesightKey, kid = TRUESIGHT_KID) {
+		this.getKeyBytes = getKeyBytes;
+		this.kid = kid;
+		this.keyPromise = null;
+	}
+	isSupported() {
+		return typeof crypto !== "undefined" && typeof crypto.subtle !== "undefined" && typeof crypto.getRandomValues === "function" && typeof CompressionStream !== "undefined";
+	}
+	async seal(plaintext) {
+		const [gz, key] = await Promise.all([gzipUtf8(plaintext), this.importKeyOnce()]);
+		const iv = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(12));
+		const additionalData = new TextEncoder().encode(`v1|A256GCM|gzip|${this.kid}`);
+		const sealed = new Uint8Array(await crypto.subtle.encrypt({
+			name: "AES-GCM",
+			iv,
+			additionalData
+		}, key, gz));
+		const tagStart = sealed.length - 16;
+		return {
+			version: 1,
+			alg: "A256GCM",
+			compression: "gzip",
+			kid: this.kid,
+			iv: toBase64Url(iv),
+			ciphertext: toBase64Url(sealed.subarray(0, tagStart)),
+			tag: toBase64Url(sealed.subarray(tagStart))
+		};
+	}
+	importKeyOnce() {
+		this.keyPromise ??= (async () => {
+			const bytes = this.getKeyBytes();
+			if (!bytes || bytes.length !== 32) throw new Error("TrueSight diagnostics key unavailable in this build");
+			const copy = new Uint8Array(bytes);
+			try {
+				return await crypto.subtle.importKey("raw", copy, { name: "AES-GCM" }, false, ["encrypt"]);
+			} finally {
+				copy.fill(0);
+				bytes.fill(0);
+			}
+		})();
+		return this.keyPromise;
+	}
+};
+async function gzipUtf8(text) {
+	const stream = new Blob([text]).stream().pipeThrough(new CompressionStream("gzip"));
+	return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+function toBase64Url(bytes) {
+	let binary = "";
+	for (let i = 0; i < bytes.length; i += 1) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/u, "");
+}
+//#endregion
+export { BrowserDiagnosticsCryptoProvider };

package/dist/IBrowserEnvironmentCapability-DEaRRk-R.esm.js

@@ -0,0 +1,9 @@
+//#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
+function getTimestamp() {
+	return Date.now();
+}
+function revokeObjectURL(url) {
+	URL.revokeObjectURL(url);
+}
+//#endregion
+export { revokeObjectURL as n, getTimestamp as t };

package/dist/{WasmUtilProvider-BrWOTaVG.esm.js → WasmUtilProvider-D13sxEmA.esm.js}

@@ -1,408 +1,4 @@
-//#region ../infra/src/wasm/wasmPathUtils.ts
-function deriveSiblingJsPath(wasmPath) {
-	const index = wasmPath.lastIndexOf(".wasm");
-	if (index === -1) return wasmPath;
-	const rest = wasmPath.slice(index + 5);
-	if (rest !== "" && !rest.startsWith("?")) return wasmPath;
-	return `${wasmPath.slice(0, index)}.js${rest}`;
-}
-//#endregion
-//#region ../infra/src/providers/browser/SemaphoreProvider.ts
-const DEFAULT_ACQUIRE_TIMEOUT_MS = 3e4;
-/**
-* Counting-semaphore implementation of {@link IConcurrencyCapability}.
-*
-* Default `maxConcurrent=1` makes it behave as a mutex; set higher for
-* parallel-bounded access. Each acquire returns a numeric `threadId` for
-* tracing — the slot index, in `[0, maxConcurrent)` — that must be passed back
-* to `release`.
-*
-* If all slots stay occupied longer than `acquireTimeoutMs` (default 30s), the
-* pending wait still resolves when a slot frees, but `console.error` is logged
-* as a deadlock-watchdog signal. Misuse — out-of-range or double-released
-* `threadId`s — is also logged and treated as a no-op rather than thrown.
-*/
-var SemaphoreProvider = class {
-	constructor(maxConcurrent = 1, acquireTimeoutMs = DEFAULT_ACQUIRE_TIMEOUT_MS) {
-		this.pending = [];
-		this.available = [];
-		this.processing = /* @__PURE__ */ new Set();
-		this.maxId = maxConcurrent - 1;
-		this.acquireTimeoutMs = acquireTimeoutMs;
-		for (let i = 0; i < maxConcurrent; i++) this.available.push(i);
-	}
-	/**
-	* Acquire a slot. Resolves immediately with the slot's `threadId` if one is
-	* free, otherwise queues FIFO and resolves when a holder releases.
-	*/
-	async acquire() {
-		if (this.available.length > 0) {
-			const threadId = this.available.shift();
-			this.processing.add(threadId);
-			return threadId;
-		}
-		return new Promise((resolve, reject) => {
-			const entry = {
-				resolve: (threadId) => {
-					clearTimeout(entry.timer);
-					this.processing.add(threadId);
-					resolve(threadId);
-				},
-				reject: (error) => {
-					clearTimeout(entry.timer);
-					reject(error);
-				},
-				timer: setTimeout(() => {
-					console.error(`SemaphoreProvider: all slots occupied for ${this.acquireTimeoutMs}ms, ${this.pending.length} request(s) waiting`);
-				}, this.acquireTimeoutMs)
-			};
-			this.pending.push(entry);
-		});
-	}
-	/**
-	* Return a slot to the pool. The next pending waiter (if any) is resolved
-	* with this `threadId`; otherwise the slot is added back to `available`.
-	* Releasing an out-of-range or already-released `threadId` logs an error and
-	* is otherwise a no-op.
-	*/
-	release(threadId) {
-		if (threadId < 0 || threadId > this.maxId) {
-			console.error(`SemaphoreProvider: invalid threadId ${threadId}`);
-			return;
-		}
-		if (!this.processing.has(threadId)) {
-			console.error(`SemaphoreProvider: double-release of threadId ${threadId}`);
-			return;
-		}
-		this.processing.delete(threadId);
-		if (this.pending.length > 0) this.pending.shift().resolve(threadId);
-		else this.available.unshift(threadId);
-	}
-	/**
-	* Cancel all pending acquires with a reset error and replenish all slots.
-	* Existing holders are not contacted — a `release` after reset will log a
-	* double-release warning rather than disrupt the new pool.
-	*/
-	reset() {
-		const waiters = this.pending;
-		this.pending = [];
-		this.available = [];
-		this.processing = /* @__PURE__ */ new Set();
-		for (let i = 0; i <= this.maxId; i++) this.available.push(i);
-		for (const waiter of waiters) waiter.reject(/* @__PURE__ */ new Error("SemaphoreProvider reset: pending acquire cancelled"));
-	}
-	/**
-	* Acquire a slot, invoke `fn(threadId, ...args)`, then release the slot in a
-	* `finally` block. Errors thrown by `fn` propagate to the caller after the
-	* slot is released.
-	*/
-	async withLock(fn, ...args) {
-		const threadId = await this.acquire();
-		try {
-			return await fn(threadId, ...args);
-		} finally {
-			this.release(threadId);
-		}
-	}
-};
-//#endregion
-//#region ../infra/src/wasm/apiUtilities.ts
-/**
-* Shared WASM module loader.
-*
-* The pinned `webLib.wasm` (see `wasmDefaults.ts`) bundles BOTH the ML pipeline
-* APIs (used by `mlWasmJSApi.ts`) AND a C++ `WebClient` HTTP client (used by
-* `wasmWebClient.ts`). Both consumers must share a single instantiated
-* `wasmModule` — calling the glue `Module()` factory twice would re-instantiate
-* the WASM heap and produce divergent state.
-*
-* This module memoizes the load: the first caller (whichever arrives first —
-* ML init or HTTP init) triggers the fetch + glue load, and subsequent callers
-* await the same promise. Idempotent on success; on failure, the singleton is
-* cleared so the next caller retries.
-*
-* SIMD fallback mirrors the legacy behavior: try the SIMD binary + SIMD glue
-* (`webLibSimd.js` + `webLibSimd.wasm`) first, fall back to the non-SIMD pair
-* (`webLib.js` + `webLib.wasm`) on instantiation failure. Each binary MUST be
-* paired with its matching glue — the CDN ships them as paired artifacts and
-* mixing them produces an unusable module.
-*/
-if (typeof window !== "undefined" && window.wasmArrayBuffer === void 0) window.wasmArrayBuffer = null;
-let loadPromise = null;
-let loadedResult = null;
-async function importGlue(glueCodePath) {
-	const mod = await import(
-		/* @vite-ignore */
-		/* webpackIgnore: true */
-		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 instantiate(factory, libPath) {
-	window.wasmArrayBuffer = await fetchWasmBinary(libPath);
-	return await factory();
-}
-/**
-* Load the WASM module, memoized. Subsequent calls return the same instance.
-*
-* SIMD-first with fallback: if `useSimd !== false` and a `wasmSimdPath` is
-* provided, the SIMD binary + SIMD glue are tried first; on instantiation
-* failure the non-SIMD binary + non-SIMD glue are used. Each `.wasm` is
-* paired with its matching `.js` glue — they cannot be mixed.
-*/
-async function loadWasmModule(config) {
-	if (loadedResult) return loadedResult;
-	if (loadPromise) return loadPromise;
-	loadPromise = (async () => {
-		try {
-			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));
-				window.Module = simdFactory;
-				const result = {
-					wasmModule: await instantiate(simdFactory, simdBinary),
-					simdUsed: true
-				};
-				loadedResult = result;
-				return result;
-			} catch (simdError) {
-				console.warn("[Incode SDK] SIMD WASM load failed, falling back to non-SIMD", simdError);
-			}
-			const nonSimdFactory = await importGlue(config.glueCodePath);
-			window.Module = nonSimdFactory;
-			const result = {
-				wasmModule: await instantiate(nonSimdFactory, config.wasmPath),
-				simdUsed: false
-			};
-			loadedResult = result;
-			return result;
-		} catch (error) {
-			loadPromise = null;
-			throw error;
-		}
-	})();
-	return loadPromise;
-}
-//#endregion
-//#region ../infra/src/wasm/wasmCallUtils.ts
-async function wasmCallWrapper(concurrency, wasmMethod, useSemaphore = true, ...args) {
-	const innerCall = async () => {
-		while (true) {
-			if (wasmMethod(...args)) return;
-			await new Promise((resolve) => setTimeout(resolve, 0));
-		}
-	};
-	if (useSemaphore) {
-		await concurrency.withLock(innerCall);
-		return;
-	}
-	await innerCall();
-}
-//#endregion
-//#region ../infra/src/wasm/wasmWebClient.ts
-/**
-* JavaScript bridge for the C++ `WebClient` exposed by `webLib.wasm`.
-*
-* The pinned WASM bundle ships a `WebClient` class alongside the ML pipeline
-* APIs. This module instantiates it once (sharing the singleton `wasmModule`
-* with `mlWasmJSApi`) and exposes a small TypeScript-friendly surface that
-* `createWasmApi` can drive.
-*
-* Concurrency model mirrors the legacy implementation:
-* - 4-slot semaphore keyed by per-request `threadId` so multiple HTTP calls
-*   can run in parallel without trampling shared C++ state.
-* - Each WASM-side method that performs in-binary HTTP (request methods AND
-*   `createApi`'s in-binary `/e2ee/key` handshake) returns `false` while in
-*   flight and `true` once the C++ side has finished; the JS bridge awaits
-*   completion via {@link wasmCallWrapper}.
-* - Result extraction (`getRequestResult`) is per-thread for HTTP requests
-*   and uses `threadId = -1` for the session-level `createApi` handshake.
-*
-* Encryption support: `setupConnection` accepts an `encryptionEnabled` flag
-* that triggers the in-binary RSA/AES handshake. The OAEP MGF1 hash is
-* controlled by the `useSha256` flag forwarded to the C++ `createApi`:
-* `true` = SHA-256 MGF1, `false` = SHA-1 MGF1 (Java-compat default).
-* State lives in the C++ binary and (for SDK config) in
-* `@incodetech/core`'s `setup.ts` — this module caches nothing.
-*/
-const HTTP_CONCURRENCY = 4;
-/**
-* Sentinel `threadId` used by the session-level `createApi` handshake when we
-* read its result via `getRequestResult`. Per-request HTTP traffic uses real
-* thread ids handed out by the semaphore; the handshake has no slot of its
-* own, so the C++ side stores its result under `-1`. Mirrors legacy
-* `checkError(threadId = -1)`.
-*/
-const SETUP_THREAD_ID = -1;
-var WasmWebClientError = class extends Error {
-	constructor(message, statusCode, data) {
-		super(message);
-		this.name = "WasmWebClientError";
-		this.status = statusCode;
-		this.statusCode = statusCode;
-		if (statusCode > 0 || data !== void 0) this.response = {
-			status: statusCode,
-			data
-		};
-	}
-};
-let webClientApi = null;
-let initPromise = null;
-let semaphore = new SemaphoreProvider(HTTP_CONCURRENCY);
-const isWebClientWasm = (mod) => {
-	return typeof mod.WebClient === "function";
-};
-const toStringRecord = (obj) => {
-	if (!obj) return void 0;
-	const result = {};
-	for (const key of Object.keys(obj)) {
-		const value = obj[key];
-		if (value === void 0 || value === null) continue;
-		result[key] = String(value);
-	}
-	return result;
-};
-/**
-* 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) {
-	if (webClientApi) return;
-	if (initPromise) return initPromise;
-	initPromise = (async () => {
-		try {
-			const { wasmModule } = await loadWasmModule({
-				wasmPath,
-				wasmSimdPath,
-				glueCodePath,
-				glueCodeSimdPath: glueCodeSimdPath || void 0,
-				useSimd
-			});
-			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) {
-			initPromise = null;
-			throw error;
-		}
-	})();
-	return initPromise;
-}
-/**
-* Configures the C++ WebClient connection. Safe to call multiple times — each
-* call resets the underlying session and re-applies default headers.
-*
-* `defaultHeaders` are applied **before** `createApi`, so the in-binary RSA
-* handshake (`GET /e2ee/key/v2` + `POST /e2ee/key`) sees the same headers as
-* data requests. Without this ordering, environments that require auth/version
-* headers on the handshake (e.g. `x-api-key`, `api-version`) would 401/4xx
-* before any encrypted traffic ever flowed.
-*
-* The C++ `createApi` returns `false` while the in-binary handshake is still
-* in flight and `true` once both the `/e2ee/key/v2` GET and the `/e2ee/key`
-* POST have completed (encryption on) or once the WebClient is configured
-* (encryption off — same boolean convention, just no network traffic). The
-* JS bridge waits on that boolean via {@link wasmCallWrapper}, then surfaces
-* any handshake error captured on the session-level (`threadId = -1`)
-* request slot. Mirrors legacy
-* `ms-incodesmile-web/packages/incode-welcome/src/wasmUtils/webClientApi.ts`
-* `setupConnection`.
-*
-* `useSha256` selects the OAEP MGF1 hash for the in-binary RSA wrap:
-* - `true` → MGF1 = SHA-256. Caller is responsible for attaching the
-*   `X-RSA-Encryption-Scheme: RSA/NONE/OAEPWITHSHA-256ANDMGF1PADDING`
-*   header on subsequent encrypted requests so the server matches.
-* - `false` → MGF1 = SHA-1 (Java-compat default). No scheme header needed;
-*   the server falls back to the legacy Java default.
-*/
-async function setupWasmConnection(apiURL, token, encryptionEnabled, defaultHeaders, useSha256) {
-	const api = ensureReady();
-	api.resetSessionState?.();
-	api.setDefaultHeaders?.(defaultHeaders);
-	await wasmCallWrapper(semaphore, () => api.createApi(apiURL, token, useSha256, encryptionEnabled), false);
-	const result = api.getRequestResult(SETUP_THREAD_ID);
-	if (result.hasError) throw new WasmWebClientError(result.errorMessage || "WebClient handshake failed", result.statusCode, result.result);
-}
-/**
-* Executes a single HTTP request through the WASM WebClient.
-*
-* Acquires a semaphore slot for `threadId`, registers progress callbacks, runs
-* the request via {@link wasmCallWrapper} (busy-polls until the WASM method
-* returns `true`), then extracts the per-thread result. Throws
-* {@link WasmWebClientError} on non-2xx or transport errors.
-*
-* The `ie` (inline-encryption) flag is forwarded to the C++ WebClient for
-* mutating methods. Default `false` — the SDK HTTP path leaves payloads
-* unencrypted at the WebClient layer. The C++ `WebApi.postFaceResults`
-* pre-encrypts its JSON via `SessionEncryptor` and calls back into this
-* function with `ie=true`; see {@link createWebApiHostAdapter}.
-*/
-async function executeWasmRequest(method, url, body, headers, params, timeout, onUploadProgress, ie = false) {
-	const api = ensureReady();
-	const stringParams = toStringRecord(params);
-	return semaphore.withLock(async (threadId) => {
-		if (onUploadProgress && api.setOnUploadProgress) api.setOnUploadProgress((event) => {
-			try {
-				onUploadProgress(event);
-			} catch (error) {
-				console.error("WasmWebClient: error in onUploadProgress callback", error);
-			}
-		});
-		try {
-			await wasmCallWrapper(semaphore, () => callWasmMethod(api, method, threadId, url, body, headers, stringParams, timeout, ie), false);
-			return readResult(api, threadId);
-		} finally {
-			api.clearOnUploadProgress?.(threadId);
-			api.clearOnDownloadProgress?.(threadId);
-		}
-	});
-}
-function callWasmMethod(api, method, threadId, url, body, headers, params, timeout, ie) {
-	switch (method) {
-		case "GET": return api.get(threadId, url, params, headers, timeout);
-		case "POST": return api.post(threadId, url, body ?? {}, headers, params, timeout, ie);
-		case "PUT": return api.put(threadId, url, body ?? {}, headers, params, timeout, ie);
-		case "PATCH": return api.patch(threadId, url, body ?? {}, headers, params, timeout, ie);
-		case "DELETE": return api.del(threadId, url, body ?? {}, headers, params, timeout, ie);
-		default: throw new Error(`Unsupported WASM HTTP method: ${method}`);
-	}
-}
-const DEFAULT_WEBAPI_TIMEOUT_MS = 3e4;
-let webApiHttpTransport = null;
-function setWebApiHttpTransport(transport) {
-	webApiHttpTransport = transport;
-}
-function createWebApiHostAdapter() {
-	return { post(url, body, config) {
-		const effectiveConfig = config ?? {};
-		const transport = webApiHttpTransport;
-		if (transport) return transport(url, body, effectiveConfig);
-		return executeWasmRequest("POST", url, body, effectiveConfig.headers ?? {}, effectiveConfig.params, effectiveConfig.timeout ?? DEFAULT_WEBAPI_TIMEOUT_MS, void 0, effectiveConfig.ie === true);
-	} };
-}
-function readResult(api, threadId) {
-	const response = api.getRequestResult(threadId);
-	if (response.hasError) throw new WasmWebClientError(response.errorMessage || "WasmWebClient request failed", response.statusCode, response.result);
-	return {
-		data: response.result,
-		status: response.statusCode
-	};
-}
-function ensureReady() {
-	if (!webClientApi) throw new Error("WasmWebClient not initialized. Call initializeWasmWebClient() first.");
-	return webClientApi;
-}
+import { c as loadWasmModule, l as SemaphoreProvider, n as createWebApiHostAdapter, s as wasmCallWrapper } from "./wasmWebClient-DM8lkb0z.esm.js";
 var mlWasmJSApi_default = class MlWasmJSApi {
 	constructor() {
 		this.versionsFile = null;
@@ -1345,4 +941,4 @@ var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
 	}
 };
 //#endregion
-export { warmupWasm as a, executeWasmRequest as c, setupWasmConnection as d, deriveSiblingJsPath as f, setWasmOnDeviceMode as i, initializeWasmWebClient as l, BaseWasmProvider as n, mlWasmJSApi_default as o, getResolvedModelsBasePath as r, WasmWebClientError as s, WasmUtilProvider as t, setWebApiHttpTransport as u };
+export { warmupWasm as a, setWasmOnDeviceMode as i, BaseWasmProvider as n, mlWasmJSApi_default as o, getResolvedModelsBasePath as r, WasmUtilProvider as t };

package/dist/{addressSearch-oyJf4OZO.esm.js → addressSearch-D_0t2Wdn.esm.js}

@@ -1,6 +1,6 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { t as api } from "./api-BDTZNnca.esm.js";
-import { t as endpoints } from "./endpoints-BwKx4Gne.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-DOfmJylF.esm.js";
 import { t as fromCallback } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 const usStateOptions = Object.values({
 	AL: {

package/dist/ae-signature.esm.js

@@ -1,4 +1,4 @@
-import { a as areAllConsented, n as electronicSignatureMachine, r as AE_CONSENT_KEYS, s as getDefaultConsentChecks, t as createElectronicSignatureManager } from "./electronicSignatureManager-hJ9YaAvD.esm.js";
+import { a as areAllConsented, n as electronicSignatureMachine, r as AE_CONSENT_KEYS, s as getDefaultConsentChecks, t as createElectronicSignatureManager } from "./electronicSignatureManager-D0X7P-de.esm.js";
 //#region src/modules/ae-signature/index.ts
 function createAeSignatureManager(options) {
 	return createElectronicSignatureManager({ config: {

package/dist/antifraud.esm.js

@@ -1,3 +1,3 @@
-import { t as antifraudMachine } from "./antifraudStateMachine-MfVOsgZf.esm.js";
-import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-CQ0zC0jZ.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-NuzlVVte.esm.js";
+import { n as createAntifraudManagerFromActor, t as createAntifraudManager } from "./antifraudManager-COYh4O_y.esm.js";
 export { antifraudMachine, createAntifraudManager, createAntifraudManagerFromActor };

package/dist/{antifraudManager-CQ0zC0jZ.esm.js → antifraudManager-COYh4O_y.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dy8PyVO5.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CMFCCu1H.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
-import { t as antifraudMachine } from "./antifraudStateMachine-MfVOsgZf.esm.js";
+import { t as antifraudMachine } from "./antifraudStateMachine-NuzlVVte.esm.js";
 //#region src/modules/antifraud/antifraudActor.ts
 function createAntifraudActor() {
 	return createActor(antifraudMachine).start();

package/dist/{antifraudStateMachine-MfVOsgZf.esm.js → antifraudStateMachine-NuzlVVte.esm.js}

@@ -1,5 +1,5 @@
-import { t as api } from "./api-BDTZNnca.esm.js";
-import { t as endpoints } from "./endpoints-BwKx4Gne.esm.js";
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-DOfmJylF.esm.js";
 import { t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/antifraud/antifraudServices.ts