@incodetech/core 2.2.0 → 2.3.0-rc.0

package/dist/{wasmWebClient-DM8lkb0z.esm.js → wasmWebClient-B7baE-Wf.esm.js}

@@ -1,3 +1,105 @@
+//#region ../infra/src/wasm/wasmAssets.ts
+const WASM_MODEL_FILES = {
+	idCapture: "id_capture_2_01_fp16.ortmodelv2",
+	idFiqa: "id_fiqa_19a81a0b9bf6492eb03b4667f6db4c85_fp16.ortmodelv2",
+	idFaceDetector: "id_facedetector_v2_1_fp16.ortmodelv2",
+	barcode: "barcode_enhance_896x224_fp16.ortmodelv2",
+	selfie: "selfie_bf_angles_192x192_opset9_fp16.ortmodelv2",
+	faceAttributes: "face_attributes_v1_3_fp16.ortmodelv2",
+	faceOcclusion: "face_occlusion_v0_2_fp16.ortmodelv2",
+	mlsRegressor: "mls_regressor_4773007c657b4f05a460321456740d0f_fp16.ortmodelv2",
+	liveness: "ondevice_physical_liveness_v2_1_fp16.ortmodelv2",
+	ageEstimation: "age_estimation_v2_2_2_fp16.ortmodelv2"
+};
+const WASM_PIPELINE_MODEL_NAMES = {
+	selfie: [
+		"selfie",
+		"faceAttributes",
+		"mlsRegressor",
+		"faceOcclusion"
+	],
+	onDeviceSelfie: [
+		"selfie",
+		"faceAttributes",
+		"mlsRegressor",
+		"faceOcclusion",
+		"liveness",
+		"ageEstimation"
+	],
+	idCapture: ["idCapture", "idFiqa"],
+	videoSelfie: [
+		"selfie",
+		"faceAttributes",
+		"mlsRegressor",
+		"faceOcclusion"
+	],
+	videoSelfieId: ["idCapture"]
+};
+const WASM_PIPELINE_LAZY_MODEL_NAMES = {
+	selfie: [],
+	onDeviceSelfie: [],
+	idCapture: ["barcode"],
+	videoSelfie: [],
+	videoSelfieId: []
+};
+/**
+* Models a pipeline's Core workflow profiles can use but that a pre-existing
+* self-hosted configuration is NOT required to supply. Deliberately not part of
+* `defineWasm`'s required set: adding a model to a released pipeline's required
+* list is a breaking change for every self-hoster following the published
+* WASM-Configuration walkthrough. When an optional model is absent, warmup skips
+* the Core profile that needs it instead of failing.
+*/
+const WASM_PIPELINE_OPTIONAL_MODEL_NAMES = {
+	selfie: [],
+	onDeviceSelfie: [],
+	idCapture: ["idFaceDetector"],
+	videoSelfie: [],
+	videoSelfieId: []
+};
+const MODEL_VARIANT_DIRECTORIES = ["current", "legacy"];
+/**
+* ml-wasm-kit publishes every model twice under a release's `models/`
+* directory: `models/current/` pairs with the SIMD binary, `models/legacy/`
+* with the non-SIMD fallback. Both URLs are built up front so the loader can
+* pick one after the SIMD probe without rewriting strings — a base path is not
+* required to contain a `models` segment, and the CDN answers a variant-less
+* model path with a 200 HTML placeholder rather than a 404.
+*/
+function buildModelVariantSources(modelsBasePath, fileName) {
+	let base = modelsBasePath;
+	while (base.endsWith("/")) base = base.slice(0, -1);
+	const lastSegment = base.slice(base.lastIndexOf("/") + 1);
+	if (MODEL_VARIANT_DIRECTORIES.includes(lastSegment)) return `${base}/${fileName}`;
+	return {
+		current: `${base}/current/${fileName}`,
+		legacy: `${base}/legacy/${fileName}`
+	};
+}
+const WASM_PIPELINE_MODELS = {
+	selfie: WASM_PIPELINE_MODEL_NAMES.selfie.map((model) => WASM_MODEL_FILES[model]),
+	onDeviceSelfie: WASM_PIPELINE_MODEL_NAMES.onDeviceSelfie.map((model) => WASM_MODEL_FILES[model]),
+	idCapture: WASM_PIPELINE_MODEL_NAMES.idCapture.map((model) => WASM_MODEL_FILES[model]),
+	videoSelfie: WASM_PIPELINE_MODEL_NAMES.videoSelfie.map((model) => WASM_MODEL_FILES[model]),
+	videoSelfieId: WASM_PIPELINE_MODEL_NAMES.videoSelfieId.map((model) => WASM_MODEL_FILES[model])
+};
+async function resolveWasmSource(source, kind) {
+	if (source instanceof Uint8Array) return source;
+	if (source instanceof ArrayBuffer) return new Uint8Array(source);
+	let response;
+	try {
+		response = await fetch(source);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message : String(error);
+		throw new Error(`[Incode SDK] Could not load the WASM ${kind} at ${source}: ${detail}`);
+	}
+	if (!response.ok) throw new Error(`[Incode SDK] Could not load the WASM ${kind} at ${source}: ${response.status} ${response.statusText}`);
+	return new Uint8Array(await response.arrayBuffer());
+}
+function missingWasmModelError(fileName, pipeline) {
+	return /* @__PURE__ */ new Error(`[Incode SDK] The "${pipeline}" pipeline needs ${fileName}, but the self-hosted WASM configuration does not provide it.`);
+}
+//#endregion
 //#region ../infra/src/wasm/wasmPathUtils.ts
 function deriveSiblingJsPath(wasmPath) {
 	const index = wasmPath.lastIndexOf(".wasm");
@@ -106,12 +208,191 @@ var SemaphoreProvider = class {
 	}
 };
 //#endregion
+//#region ../infra/src/wasm/wasmStorageFallback.ts
+/**
+* SDK-local compatibility fallback for ml-wasm-kit releases whose embind
+* storage lookups let browser `SecurityError`s escape into JavaScript.
+*
+* The fallback shadows only a denied `window.localStorage` or
+* `window.sessionStorage` property. Available storage and absent/deleted
+* globals are left untouched. A coordinator stored under `Symbol.for(...)`
+* shares the memory stores and leases across multiple bundled SDK copies.
+*/
+const STORAGE_NAMES = ["localStorage", "sessionStorage"];
+const COORDINATOR_KEY = Symbol.for("@incodetech/infra/wasm-storage-fallback/v1");
+const COORDINATOR_VERSION = 1;
+const INSTALL_ERROR = "[Incode SDK] Unable to install the WASM in-memory storage fallback.";
+let probeSequence = 0;
+function createMemoryStorage() {
+	const values = /* @__PURE__ */ new Map();
+	return {
+		get length() {
+			return values.size;
+		},
+		clear() {
+			values.clear();
+		},
+		getItem(key) {
+			return values.get(String(key)) ?? null;
+		},
+		key(index) {
+			return Array.from(values.keys())[Number(index)] ?? null;
+		},
+		removeItem(key) {
+			values.delete(String(key));
+		},
+		setItem(key, value) {
+			values.set(String(key), String(value));
+		}
+	};
+}
+function isDeniedStorageError(error) {
+	if (typeof error !== "object" || error === null || !("name" in error)) return false;
+	const name = Reflect.get(error, "name");
+	return name === "SecurityError" || name === "QuotaExceededError";
+}
+function probeStorage(name) {
+	const descriptor = Object.getOwnPropertyDescriptor(window, name);
+	let storage;
+	try {
+		storage = window[name];
+	} catch (error) {
+		if (isDeniedStorageError(error)) return {
+			status: "denied",
+			descriptor
+		};
+		throw error;
+	}
+	if (storage == null) return { status: "absent" };
+	probeSequence += 1;
+	const key = `__incode_wasm_storage_probe_${Date.now()}_${probeSequence}`;
+	try {
+		storage.setItem(key, key);
+		if (storage.getItem(key) !== key) throw new DOMException("Storage probe did not retain its value.", "SecurityError");
+		storage.removeItem(key);
+		return { status: "available" };
+	} catch (error) {
+		try {
+			storage.removeItem(key);
+		} catch {}
+		if (isDeniedStorageError(error)) return {
+			status: "denied",
+			descriptor
+		};
+		throw error;
+	}
+}
+function isCoordinator(value) {
+	return typeof value === "object" && value !== null && Reflect.get(value, "version") === COORDINATOR_VERSION && Reflect.get(value, "leases") instanceof Set && Reflect.get(value, "shadows") instanceof Map;
+}
+function readCoordinator() {
+	const value = Reflect.get(window, COORDINATOR_KEY);
+	if (value === void 0) return null;
+	if (!isCoordinator(value)) throw new Error(INSTALL_ERROR);
+	return value;
+}
+function restoreShadow(name, shadow) {
+	if (Object.getOwnPropertyDescriptor(window, name)?.get !== shadow.installedGetter) return;
+	if (shadow.originalDescriptor) Object.defineProperty(window, name, shadow.originalDescriptor);
+	else Reflect.deleteProperty(window, name);
+}
+function installDeniedShadows(coordinator) {
+	const installed = [];
+	try {
+		for (const name of STORAGE_NAMES) {
+			if (coordinator.shadows.has(name)) continue;
+			const probe = probeStorage(name);
+			if (probe.status !== "denied") continue;
+			if (probe.descriptor && !probe.descriptor.configurable) throw new Error(INSTALL_ERROR);
+			const memory = createMemoryStorage();
+			const installedGetter = () => memory;
+			const shadow = {
+				originalDescriptor: probe.descriptor,
+				installedGetter,
+				memory
+			};
+			Object.defineProperty(window, name, {
+				configurable: true,
+				enumerable: probe.descriptor?.enumerable ?? true,
+				get: installedGetter
+			});
+			coordinator.shadows.set(name, shadow);
+			installed.push(name);
+		}
+		return installed;
+	} catch (error) {
+		for (const name of installed.reverse()) {
+			const shadow = coordinator.shadows.get(name);
+			coordinator.shadows.delete(name);
+			if (shadow) {
+				restoreShadow(name, shadow);
+				shadow.memory.clear();
+			}
+		}
+		throw error;
+	}
+}
+function restoreCoordinator(coordinator) {
+	let firstError;
+	for (const [name, shadow] of coordinator.shadows) {
+		try {
+			restoreShadow(name, shadow);
+		} catch (error) {
+			firstError ??= error;
+		}
+		shadow.memory.clear();
+	}
+	coordinator.shadows.clear();
+	if (Reflect.get(window, COORDINATOR_KEY) === coordinator) Reflect.deleteProperty(window, COORDINATOR_KEY);
+	if (firstError !== void 0) throw firstError;
+}
+/**
+* Acquires a shared fallback lease when storage access is denied.
+*
+* The caller must retain the lease for the complete native-handle lifetime;
+* ml-wasm-kit performs storage lookups during constructors and later calls.
+*/
+function acquireWasmStorageFallback() {
+	if (typeof window === "undefined") return null;
+	let coordinator = readCoordinator();
+	const created = coordinator === null;
+	coordinator ??= {
+		version: COORDINATOR_VERSION,
+		leases: /* @__PURE__ */ new Set(),
+		shadows: /* @__PURE__ */ new Map()
+	};
+	if (created) Object.defineProperty(window, COORDINATOR_KEY, {
+		configurable: true,
+		enumerable: false,
+		value: coordinator
+	});
+	try {
+		installDeniedShadows(coordinator);
+	} catch (error) {
+		if (created) Reflect.deleteProperty(window, COORDINATOR_KEY);
+		throw error;
+	}
+	if (coordinator.shadows.size === 0) {
+		if (created) Reflect.deleteProperty(window, COORDINATOR_KEY);
+		return null;
+	}
+	const token = Symbol("wasm-storage-fallback-lease");
+	coordinator.leases.add(token);
+	let released = false;
+	return { release() {
+		if (released) return;
+		released = true;
+		coordinator.leases.delete(token);
+		if (coordinator.leases.size === 0) restoreCoordinator(coordinator);
+	} };
+}
+//#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
+* APIs (loaded by `WasmRuntime.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.
@@ -130,7 +411,7 @@ var SemaphoreProvider = class {
 if (typeof window !== "undefined" && window.wasmArrayBuffer === void 0) window.wasmArrayBuffer = null;
 let loadPromise = null;
 let loadedResult = null;
-async function importGlue(glueCodePath) {
+async function importGlueAt(glueCodePath) {
 	const mod = await import(
 		/* @vite-ignore */
 		/* webpackIgnore: true */
@@ -139,15 +420,18 @@ async function importGlue(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 resolveGlue(loader, glueCodePath) {
+	if (loader) {
+		const module = await loader();
+		if (typeof module.Module !== "function") throw new Error("[Incode SDK] WASM glue module did not export a Module factory.");
+		return module.Module;
+	}
+	if (!glueCodePath) throw new Error("WASM glue code is required");
+	return await importGlueAt(glueCodePath);
 }
 async function instantiate(factory, libPath) {
-	window.wasmArrayBuffer = await fetchWasmBinary(libPath);
-	return await factory();
+	window.wasmArrayBuffer = await resolveWasmSource(libPath, "binary");
+	return await factory({ wasmBinary: window.wasmArrayBuffer });
 }
 /**
 * Load the WASM module, memoized. Subsequent calls return the same instance.
@@ -161,11 +445,13 @@ async function loadWasmModule(config) {
 	if (loadedResult) return loadedResult;
 	if (loadPromise) return loadPromise;
 	loadPromise = (async () => {
+		let storageFallbackLease = null;
 		try {
+			storageFallbackLease = acquireWasmStorageFallback();
 			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));
+				const simdFactory = await resolveGlue(config.loadGlueSimd, typeof simdBinary === "string" ? config.glueCodeSimdPath || deriveSiblingJsPath(simdBinary) : config.glueCodeSimdPath);
 				window.Module = simdFactory;
 				const result = {
 					wasmModule: await instantiate(simdFactory, simdBinary),
@@ -176,7 +462,7 @@ async function loadWasmModule(config) {
 			} catch (simdError) {
 				console.warn("[Incode SDK] SIMD WASM load failed, falling back to non-SIMD", simdError);
 			}
-			const nonSimdFactory = await importGlue(config.glueCodePath);
+			const nonSimdFactory = await resolveGlue(config.loadGlue, config.glueCodePath);
 			window.Module = nonSimdFactory;
 			const result = {
 				wasmModule: await instantiate(nonSimdFactory, config.wasmPath),
@@ -187,16 +473,66 @@ async function loadWasmModule(config) {
 		} catch (error) {
 			loadPromise = null;
 			throw error;
+		} finally {
+			storageFallbackLease?.release();
 		}
 	})();
 	return loadPromise;
 }
 //#endregion
 //#region ../infra/src/wasm/wasmCallUtils.ts
-async function wasmCallWrapper(concurrency, wasmMethod, useSemaphore = true, ...args) {
+/**
+* Poll bound applied to the ML long-poll call sites (`prc` / `poc` / `rsp` in
+* `utilityWasmApi.ts`).
+*
+* Count-based, not deadline-based: the poll loop yields with `setTimeout(0)`,
+* which background tabs throttle to >= 1s per tick, so a wall-clock deadline
+* would false-trip whenever the user backgrounds the page. A count bounds the
+* number of C++ invocations regardless of how slowly the event loop turns.
+*
+* 3000 is deliberately generous. `prc` alone burns ~750 idle polls waiting on
+* the ~3s of camera frames the C++ side needs before it reports done, so the
+* bound sits well above the legitimate worst case. It exists to break a
+* permanently stuck poll that would otherwise hold the ML semaphore forever and
+* freeze detection — not to enforce a latency budget.
+*/
+const ML_CALL_MAX_POLLS = 3e3;
+/**
+* Thrown when a bounded {@link wasmCallWrapper} poll exhausts `maxPolls` without
+* the C++ method reporting completion.
+*
+* The semaphore is always released before this surfaces — the lock is held in a
+* `withLock` `finally` — so a timeout frees the ML slot for the next caller
+* instead of deadlocking it.
+*/
+var WasmPollTimeoutError = class extends Error {
+	constructor(polls, label) {
+		super(`[Incode SDK] WASM call ${label ?? "poll"} did not complete after ${polls} polls`);
+		this.name = "WasmPollTimeoutError";
+		this.polls = polls;
+		this.label = label;
+	}
+};
+/**
+* Busy-polls an iterative WASM method until it returns `true`, optionally under
+* a concurrency lock.
+*
+* @param concurrency - semaphore used when `useSemaphore` is true.
+* @param wasmMethod - zero-arg closure over the C++ call; `false` means "call me
+*   again", `true` means done. Bind any arguments in the closure.
+* @param useSemaphore - `false` bypasses the lock (caller already holds one, or
+*   is provably the only caller).
+* @param options - see {@link WasmPollOptions}. `maxPolls` omitted = unbounded.
+* @throws {WasmPollTimeoutError} when `maxPolls` is exhausted.
+*/
+async function wasmCallWrapper(concurrency, wasmMethod, useSemaphore = true, options = {}) {
+	const { maxPolls, label } = options;
 	const innerCall = async () => {
+		let polls = 0;
 		while (true) {
-			if (wasmMethod(...args)) return;
+			polls++;
+			if (wasmMethod()) return;
+			if (maxPolls !== void 0 && polls >= maxPolls) throw new WasmPollTimeoutError(polls, label);
 			await new Promise((resolve) => setTimeout(resolve, 0));
 		}
 	};
@@ -212,8 +548,9 @@ async function wasmCallWrapper(concurrency, wasmMethod, useSemaphore = true, ...
 * 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
+* APIs. This module instantiates it once — sharing the one memoized
+* `wasmModule` from `apiUtilities.ts` that `WasmRuntime` also holds as its
+* `wasmModule` field — and exposes a small TypeScript-friendly surface that
 * `createWasmApi` can drive.
 *
 * Concurrency model mirrors the legacy implementation:
@@ -273,27 +610,20 @@ const toStringRecord = (obj) => {
 /**
 * 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) {
+async function initializeWasmWebClient(config) {
 	if (webClientApi) return;
 	if (initPromise) return initPromise;
 	initPromise = (async () => {
+		let acquiredStorageFallbackLease = null;
 		try {
-			const { wasmModule } = await loadWasmModule({
-				wasmPath,
-				wasmSimdPath,
-				glueCodePath,
-				glueCodeSimdPath: glueCodeSimdPath || void 0,
-				useSimd
-			});
+			acquiredStorageFallbackLease = acquireWasmStorageFallback();
+			const { wasmModule } = await loadWasmModule(config);
 			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;
+			acquiredStorageFallbackLease?.release();
 			throw error;
 		}
 	})();
@@ -404,4 +734,4 @@ function ensureReady() {
 	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 };
+export { WASM_PIPELINE_OPTIONAL_MODEL_NAMES as _, setWebApiHttpTransport as a, resolveWasmSource as b, wasmCallWrapper as c, SemaphoreProvider as d, deriveSiblingJsPath as f, WASM_PIPELINE_MODEL_NAMES as g, WASM_PIPELINE_MODELS as h, initializeWasmWebClient as i, loadWasmModule as l, WASM_PIPELINE_LAZY_MODEL_NAMES as m, createWebApiHostAdapter as n, setupWasmConnection as o, WASM_MODEL_FILES as p, executeWasmRequest as r, ML_CALL_MAX_POLLS as s, WasmWebClientError as t, acquireWasmStorageFallback as u, buildModelVariantSources as v, missingWasmModelError as y };

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

@@ -1,78 +1,2 @@
-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 = {
-  status: 'idle';
-};
-/** Form is ready — use `setCountry()`, `setBusinessName()`, and `submit()`. */
-type WatchlistForBusinessFormState = {
-  status: 'form';
-  country: string;
-  businessName: string;
-  isValid: boolean;
-};
-/** API request in flight. */
-type WatchlistForBusinessSubmittingState = {
-  status: 'submitting';
-};
-/**
- * API succeeded — success screen visible for ~3 s before transitioning
- * to `finished`.
- */
-type WatchlistForBusinessSuccessState = {
-  status: 'success';
-};
-/** Module complete. Fires regardless of API outcome (fire-and-forget). */
-type WatchlistForBusinessFinishedState = {
-  status: 'finished';
-};
-/**
- * Discriminated union of all possible watchlist-for-business manager states.
- */
-type WatchlistForBusinessState = WatchlistForBusinessIdleState | WatchlistForBusinessFormState | WatchlistForBusinessSubmittingState | WatchlistForBusinessSuccessState | WatchlistForBusinessFinishedState;
-/**
- * Creates a watchlist-for-business manager for headless or UI-driven usage.
- *
- * On API error the module completes silently (fire-and-forget).
- *
- * @example Headless usage
- * ```typescript
- * import { createWatchlistForBusinessManager } from '@incodetech/core/watchlist-for-business';
- *
- * const manager = createWatchlistForBusinessManager();
- * manager.subscribe((state) => {
- *   if (state.status === 'finished') console.log('Done');
- * });
- * manager.load();
- * manager.setCountry('MX');
- * manager.setBusinessName('Acme Corp');
- * manager.submit();
- * manager.stop();
- * ```
- */
-declare function createWatchlistForBusinessManager(): Manager<WatchlistForBusinessState> & {
-  /** Transitions from `idle` to the form. Must be called before any other method. */
-  load(): void;
-  /** Updates the selected country code (ISO 3166-1 alpha-2). */
-  setCountry(country: string): void;
-  /** Updates the business name field and recomputes validity. */
-  setBusinessName(value: string): void;
-  /** Submits the form. Only transitions when `isValid` is true. */
-  submit(): void;
-};
-type WatchlistForBusinessManager = ReturnType<typeof createWatchlistForBusinessManager>;
-//#endregion
-//#region src/modules/watchlist-for-business/watchlistForBusinessStateMachine.d.ts
-declare const watchlistForBusinessMachine: any;
-//#endregion
-//#region src/modules/watchlist-for-business/types.d.ts
-/**
- * Configuration for the watchlist-for-business module.
- *
- * No server-side configuration is required — the module collects
- * country and business name from the user and submits them to the
- * business watchlist endpoint.
- */
-type WatchlistForBusinessConfig = Record<string, never>;
-//#endregion
-export { type WatchlistForBusinessConfig, type WatchlistForBusinessFinishedState, type WatchlistForBusinessFormState, type WatchlistForBusinessManager, type WatchlistForBusinessState, createWatchlistForBusinessManager, watchlistForBusinessMachine };
+import { a as createWatchlistForBusinessManager, c as WatchlistForBusinessValidationErrors, i as WatchlistForBusinessState, l as WatchlistForBusinessActor, n as WatchlistForBusinessFormState, o as createWatchlistForBusinessManagerFromActor, r as WatchlistForBusinessManager, s as WatchlistForBusinessConfig, t as WatchlistForBusinessFinishedState, u as watchlistForBusinessMachine } from "./watchlistForBusinessManager-CsnJnG-C.js";
+export { type WatchlistForBusinessActor, type WatchlistForBusinessConfig, type WatchlistForBusinessFinishedState, type WatchlistForBusinessFormState, type WatchlistForBusinessManager, type WatchlistForBusinessState, type WatchlistForBusinessValidationErrors, createWatchlistForBusinessManager, createWatchlistForBusinessManagerFromActor, watchlistForBusinessMachine };

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

@@ -1,102 +1,3 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
-import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
-import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-CxFnlshm.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
-/**
-* Maps a Watchlist-for-Business state-machine snapshot to the exact Figma
-* "Tracked Events" screen name. Source: Watchlist for Business Figma
-* file (`https://www.figma.com/design/BfHifNPAvPTpBlnMEDfg4J/Watchlist-for-Business---Latest-Design?node-id=3031-82920`).
-* Family is `watchlist.*`, shared with global watchlist and custom
-* watchlist — each manager keeps its own module token per the
-* AdSign/QSign precedent.
-*
-* `idle` and `finished` are intentionally unmapped — the Figma canvas does
-* not define screens for them; `finished` collapses into `moduleClosed`.
-*/
-function getWatchlistForBusinessScreenName(snapshot) {
-	const stateName = topLevelStateName(snapshot.value);
-	if (stateName === void 0) return void 0;
-	switch (stateName) {
-		case "form": return snapshot.context.isValid ? "watchlist.filled" : "watchlist.default";
-		case "submitting": return "watchlist.processing";
-		case "success": return "watchlist.success";
-		default: return;
-	}
-}
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	if (typedSnapshot.matches("form")) return {
-		status: "form",
-		country: context.country,
-		businessName: context.businessName,
-		isValid: context.isValid
-	};
-	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
-	if (typedSnapshot.matches("success")) return { status: "success" };
-	if (typedSnapshot.matches("finished")) return { status: "finished" };
-	return { status: "idle" };
-}
-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" });
-		}
-	};
-}
-/**
-* Creates a watchlist-for-business manager for headless or UI-driven usage.
-*
-* On API error the module completes silently (fire-and-forget).
-*
-* @example Headless usage
-* ```typescript
-* import { createWatchlistForBusinessManager } from '@incodetech/core/watchlist-for-business';
-*
-* const manager = createWatchlistForBusinessManager();
-* manager.subscribe((state) => {
-*   if (state.status === 'finished') console.log('Done');
-* });
-* manager.load();
-* manager.setCountry('MX');
-* manager.setBusinessName('Acme Corp');
-* manager.submit();
-* manager.stop();
-* ```
-*/
-function createWatchlistForBusinessManager() {
-	return createManager({
-		actor: createWatchlistForBusinessActor(),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.watchlistForBusiness, { getEventScreenName: getWatchlistForBusinessScreenName })
-	});
-}
-//#endregion
-export { createWatchlistForBusinessManager, watchlistForBusinessMachine };
+import { t as watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-DEzgjz7C.esm.js";
+import { n as createWatchlistForBusinessManagerFromActor, t as createWatchlistForBusinessManager } from "./watchlistForBusinessManager-CpuuB1J2.esm.js";
+export { createWatchlistForBusinessManager, createWatchlistForBusinessManagerFromActor, watchlistForBusinessMachine };

package/dist/watchlist.esm.js

@@ -1,3 +1,3 @@
-import { t as watchlistMachine } from "./watchlistStateMachine-DIKQDoUT.esm.js";
-import { t as createWatchlistManager } from "./watchlistManager-LoNZH9qm.esm.js";
+import { t as watchlistMachine } from "./watchlistStateMachine-DvOby3a-.esm.js";
+import { t as createWatchlistManager } from "./watchlistManager-CI8BHFob.esm.js";
 export { createWatchlistManager, watchlistMachine };