@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/wasmWebClient-DM8lkb0z.esm.js

@@ -0,0 +1,407 @@
+//#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;
+}
+//#endregion
+export { setWebApiHttpTransport as a, loadWasmModule as c, initializeWasmWebClient as i, SemaphoreProvider as l, createWebApiHostAdapter as n, setupWasmConnection as o, executeWasmRequest as r, wasmCallWrapper as s, WasmWebClientError as t, deriveSiblingJsPath as u };

package/dist/watchlist-for-business.d.ts

@@ -1,6 +1,4 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-
+import { t as Manager } from "./Manager-CQQ99QOI.js";
 //#region src/modules/watchlist-for-business/watchlistForBusinessManager.d.ts
 /** Waiting for `load()` to be called. */
 type WatchlistForBusinessIdleState = {

package/dist/watchlist-for-business.esm.js

@@ -1,14 +1,11 @@
-import "./api-DsbUi7TO.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 watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-R1Yp1g5A.esm.js";
-
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.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 watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-BcBMkMvV.esm.js";
 //#region src/modules/watchlist-for-business/watchlistForBusinessActor.ts
 function createWatchlistForBusinessActor() {
 	return createActor(watchlistForBusinessMachine).start();
 }
-
 //#endregion
 //#region src/modules/watchlist-for-business/watchlistForBusinessManager.ts
 /**
@@ -48,21 +45,25 @@ function mapState(snapshot) {
 }
 function createApi({ actor, trackElementClicked }) {
 	return {
+		/** Transitions from `idle` to the form. Must be called before any other method. */
 		load() {
 			actor.send({ type: "LOAD" });
 		},
+		/** Updates the selected country code (ISO 3166-1 alpha-2). */
 		setCountry(country) {
 			actor.send({
 				type: "SET_COUNTRY",
 				country
 			});
 		},
+		/** Updates the business name field and recomputes validity. */
 		setBusinessName(value) {
 			actor.send({
 				type: "SET_BUSINESS_NAME",
 				value
 			});
 		},
+		/** Submits the form. Only transitions when `isValid` is true. */
 		submit() {
 			trackElementClicked?.("submit");
 			actor.send({ type: "SUBMIT" });
@@ -97,6 +98,5 @@ function createWatchlistForBusinessManager() {
 		instrumentation: createManagerInstrumentation(eventModuleNames.watchlistForBusiness, { getEventScreenName: getWatchlistForBusinessScreenName })
 	});
 }
-
 //#endregion
-export { createWatchlistForBusinessManager, watchlistForBusinessMachine };
+export { createWatchlistForBusinessManager, watchlistForBusinessMachine };

package/dist/watchlist.d.ts

@@ -1,55 +1,4 @@
-import "./StateMachine-D5WO6lHS.js";
-import { t as Manager } from "./Manager-goNPc_h_.js";
-
-//#region src/modules/watchlist/watchlistStateMachine.d.ts
-type WatchlistResult = 'success' | 'skipped';
-declare const watchlistMachine: any;
-//#endregion
-//#region src/modules/watchlist/watchlistManager.d.ts
-type WatchlistIdleState = {
-  status: 'idle';
-};
-type WatchlistProcessingState = {
-  status: 'processing';
-};
-type WatchlistSuccessState = {
-  status: 'success';
-};
-type WatchlistFinishedState = {
-  status: 'finished';
-  result: WatchlistResult;
-};
-/**
- * Union of all possible global watchlist manager states.
- *
- * @example
- * ```typescript
- * const state = watchlistManager.getState();
- * if (state.status === 'finished') {
- *   console.log('Global watchlist check complete');
- * }
- * ```
- */
-type WatchlistState = WatchlistIdleState | WatchlistProcessingState | WatchlistSuccessState | WatchlistFinishedState;
-/**
- * Creates a global watchlist manager for headless or UI-driven usage.
- *
- * @example Headless usage
- * ```typescript
- * const manager = createWatchlistManager();
- * manager.subscribe((state) => console.log(state.status));
- * manager.load();
- * ```
- */
-declare function createWatchlistManager(): Manager<WatchlistState> & {
-  /**
-   * Kicks off the global watchlist check.
-   * Transitions from 'idle' to 'processing'.
-   */
-  load(): void;
-};
-type WatchlistManager = ReturnType<typeof createWatchlistManager>;
-//#endregion
+import { n as WatchlistState, o as watchlistMachine, r as createWatchlistManager, t as WatchlistManager } from "./watchlistManager-DLXef90v.js";
 //#region src/modules/watchlist/types.d.ts
 /**
  * Configuration options for the global watchlist module.

package/dist/watchlist.esm.js

@@ -1,70 +1,3 @@
-import "./api-DsbUi7TO.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 watchlistMachine } from "./watchlistStateMachine-D07UVq1m.esm.js";
-
-//#region src/modules/watchlist/watchlistActor.ts
-function createWatchlistActor() {
-	return createActor(watchlistMachine).start();
-}
-
-//#endregion
-//#region src/modules/watchlist/watchlistManager.ts
-/**
-* Maps a Watchlist state-machine snapshot to the exact Figma "Tracked
-* Events" screen name. Source: Watchlist | Custom Watchlist Figma file
-* (`https://www.figma.com/design/Xm4BgXotNwdi5iRdHTIX0N/Watchlist-%7C-Custom-Watchlist----Latest-Design?node-id=3031-82920`).
-* Family is `watchlist.*` — shared across global watchlist, custom
-* watchlist, and watchlist-for-business (distinct module tokens per
-* AdSign/QSign precedent).
-*
-* `idle` and `finished` are intentionally unmapped — the Figma canvas does
-* not define screens for the entry / terminal moments. `finished` collapses
-* into `moduleClosed`.
-*/
-function getWatchlistScreenName(snapshot) {
-	const stateName = topLevelStateName(snapshot.value);
-	if (stateName === void 0) return void 0;
-	switch (stateName) {
-		case "processing": return "watchlist.processing";
-		case "success": return "watchlist.success";
-		default: return;
-	}
-}
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	if (typedSnapshot.matches("processing")) return { status: "processing" };
-	if (typedSnapshot.matches("success")) return { status: "success" };
-	if (typedSnapshot.matches("finished")) return {
-		status: "finished",
-		result: typedSnapshot.context.result ?? "skipped"
-	};
-	return { status: "idle" };
-}
-function createApi({ actor }) {
-	return { load() {
-		actor.send({ type: "LOAD" });
-	} };
-}
-/**
-* Creates a global watchlist manager for headless or UI-driven usage.
-*
-* @example Headless usage
-* ```typescript
-* const manager = createWatchlistManager();
-* manager.subscribe((state) => console.log(state.status));
-* manager.load();
-* ```
-*/
-function createWatchlistManager() {
-	return createManager({
-		actor: createWatchlistActor(),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.watchlist, { getEventScreenName: getWatchlistScreenName })
-	});
-}
-
-//#endregion
-export { createWatchlistManager, watchlistMachine };
+import { t as watchlistMachine } from "./watchlistStateMachine-Bl7Wy9Cm.esm.js";
+import { t as createWatchlistManager } from "./watchlistManager-CjSMmbyq.esm.js";
+export { createWatchlistManager, watchlistMachine };

package/dist/{watchlistForBusinessStateMachine-R1Yp1g5A.esm.js → watchlistForBusinessStateMachine-BcBMkMvV.esm.js}

@@ -1,14 +1,13 @@
-import { t as api } from "./api-DsbUi7TO.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";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/watchlist-for-business/watchlistForBusinessServices.ts
 async function submitWatchlistForBusiness(data, signal) {
 	const res = await api.post(endpoints.watchlistForBusinessSubmit, data, { signal });
 	if (!res.ok) throw new Error(`POST ${endpoints.watchlistForBusinessSubmit} failed: ${res.status} ${res.statusText}`);
 	return res.data;
 }
-
 //#endregion
 //#region src/modules/watchlist-for-business/watchlistForBusinessStateMachine.ts
 const DEFAULT_COUNTRY = "US";
@@ -69,6 +68,5 @@ const watchlistForBusinessMachine = setup({
 		finished: { type: "final" }
 	}
 });
-
 //#endregion
-export { watchlistForBusinessMachine as t };
+export { watchlistForBusinessMachine as t };