@incodetech/core 2.4.0 → 2.4.1-agentic.1

package/dist/{wasmWebClient-BjZw_7OB.esm.js → wasmWebClient-BDrax6Eu.esm.js}

@@ -1,8 +1,8 @@
-import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
+import { n as getTimestamp } from "./IBrowserEnvironmentCapability-D7JG7ML3.esm.js";
 //#region ../infra/src/wasm/wasmIntegrityManifest.ts
 /** SHA-256 digests of the official WASM release files this SDK loads. */
 const WASM_INTEGRITY_MANIFEST = {
-	wasmVersion: "v2.14.50-post1",
+	wasmVersion: "v2.14.54-pre6",
 	files: {
 		"models/current/age_estimation_v2_2_2_fp16.ortmodelv2": "70bd372b5e140ea8e9773a25d371cb65e5a9090651fdfe73ab6fc7ce25d59c83",
 		"models/current/barcode_enhance_896x224_fp16.ortmodelv2": "bccecd74abf48181efb95bf020784b7e50d37ae255bf89c14c2c5186976279e0",
@@ -24,14 +24,14 @@ const WASM_INTEGRITY_MANIFEST = {
 		"models/legacy/mls_regressor_4773007c657b4f05a460321456740d0f_fp16.ortmodelv2": "e41887f75b284ba1f973f2a26209bf365da8a587d266492b642e5b7c36716069",
 		"models/legacy/ondevice_physical_liveness_v2_1_fp16.ortmodelv2": "405eee9fd961c48fff608246ef579dc8ce9f0b5ce51361e05dac7d9afcf9162d",
 		"models/legacy/selfie_bf_angles_192x192_opset9_fp16.ortmodelv2": "1c8dda528d5111fa7b4272ffabca7cf0a59099f57258aaece7262974aebafc4a",
-		"webLib.js": "2953d4da3b8eddf1ff48e113ac4ff11d69eb379e1ab091fec1dad34a17d23844",
-		"webLib.wasm": "7616ea70cab3171ef376f9d0fa646548efc90beab49fdefa25d1b241ca704673",
-		"webLibSimd.js": "51407ce3032dd330ae806d9aea1b43eb5c245e2b64780b4b62c9c62310a0bee1",
-		"webLibSimd.wasm": "0575425989803e58ccb82fcd30d64508a7c7b52019564d8644b59d5cf11135ab"
+		"webLib.js": "0db12df86a8b0d5c205486e508d391f0df3e69d652ab4dc30e06f9237ef89caf",
+		"webLib.wasm": "72a0a5b611af6ec1dfd2d77a61de72477f385d76569259d9c74c2ea116ffab42",
+		"webLibSimd.js": "7bc83d69c4d0b6c6e2a5e620ffa49405570936f5d01c3ad9a0c82548f72ca2f8",
+		"webLibSimd.wasm": "371af5334158b4f6b437c74f31fb55181a8d1ced7ad5e718e141f348c90a3029"
 	},
 	dist: {
-		"webLib.js": "6d7177b6e2e86a0d975b595ea546bf87fc11a194ad4cbdc0613fb3b2a2810e90",
-		"webLibSimd.js": "4ac981fa15dd748ec1a312bd25408fb4af3449d8c1bb6ebb8fe436476049d446"
+		"webLib.js": "87a490cc43662337ad3e8540f34b3a81eeb07c98e1bb0817a0e165bf9d9a0117",
+		"webLibSimd.js": "ea683348b881de418dbb6c1447ba89bd592d16540ce899259c6d404f52568722"
 	}
 };
 //#endregion
@@ -314,7 +314,7 @@ function deriveSiblingJsPath(wasmPath) {
 //#region ../infra/src/wasm/wasmDefaults.ts
 const WASM_CDN_BASE_URL = "https://cdn.incodesmile.com/ml-wasm-kit-release";
 /** The WASM version bundled and tested with this SDK release. */
-const DEFAULT_WASM_VERSION = "v2.14.50-post1";
+const DEFAULT_WASM_VERSION = "v2.14.54-pre6";
 const PATH_KEYS = [
 	"wasmPath",
 	"wasmSimdPath",
@@ -425,7 +425,7 @@ const BARCODE_ENHANCE_MODEL_FILE = WASM_MODEL_FILES.barcode;
 * NOT part of any warmup model bundle.
 */
 function getBarcodeEnhanceModelUrl(modelsBasePath, variant = "current") {
-	const source = buildModelVariantSources(modelsBasePath ?? `${WASM_CDN_BASE_URL}/v2.14.50-post1/models`, BARCODE_ENHANCE_MODEL_FILE);
+	const source = buildModelVariantSources(modelsBasePath ?? `${WASM_CDN_BASE_URL}/v2.14.54-pre6/models`, BARCODE_ENHANCE_MODEL_FILE);
 	return typeof source === "string" ? source : source[variant];
 }
 /**
@@ -597,6 +597,27 @@ async function importVerifiedGlue(bytes) {
 	}
 }
 //#endregion
+//#region ../infra/src/wasm/wasmStartGate.ts
+/**
+* SDK 2's own addition, not mirrored from ml-wasm-kit.
+*
+* Holds back the WASM module load while another fingerprint module on the
+* page initializes, such as TRI's fpSignals build. ML-Wasm's integration
+* guide: on the legacy build the two modules must be initialized one after
+* the other, since both use `window.wasmArrayBuffer`.
+*/
+let startGate = null;
+/** Sets what the next module load waits for; `null` removes the wait. */
+function setWasmStartGate(gate) {
+	startGate = gate;
+}
+/** Settles with the gate. A gate that rejects or throws never blocks the load. */
+async function waitForWasmStartGate() {
+	try {
+		await startGate?.();
+	} catch {}
+}
+//#endregion
 //#region ../infra/src/wasm/wasmStorageFallback.ts
 /**
 * SDK-local compatibility fallback for ml-wasm-kit releases whose embind
@@ -825,11 +846,8 @@ async function resolveGlue(loader, glueCodePath, slot) {
 	if (!glueCodePath) throw new Error("WASM glue code is required");
 	return await importGlueAt(glueCodePath, slot);
 }
-async function instantiate(factory, libPath, slot, showLogs = false) {
-	window.wasmArrayBuffer = await resolveWasmSource(libPath, {
-		kind: "binary",
-		slot
-	});
+async function instantiate(factory, wasmBinary, showLogs = false) {
+	window.wasmArrayBuffer = wasmBinary;
 	return await factory({
 		wasmBinary: window.wasmArrayBuffer,
 		print: (text) => {
@@ -866,16 +884,20 @@ async function loadWasmModule(config) {
 	if (loadPromise) return loadPromise;
 	const startedAtMs = getTimestamp();
 	loadPromise = (async () => {
+		await waitForWasmStartGate();
 		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 resolveGlue(config.loadGlueSimd, typeof simdBinary === "string" ? config.glueCodeSimdPath || deriveSiblingJsPath(simdBinary) : config.glueCodeSimdPath, "webLibSimd.js");
+				const [simdFactory, simdBytes] = await Promise.all([resolveGlue(config.loadGlueSimd, typeof simdBinary === "string" ? config.glueCodeSimdPath || deriveSiblingJsPath(simdBinary) : config.glueCodeSimdPath, "webLibSimd.js"), resolveWasmSource(simdBinary, {
+					kind: "binary",
+					slot: "webLibSimd.wasm"
+				})]);
 				window.Module = simdFactory;
 				const result = {
-					wasmModule: await instantiate(simdFactory, simdBinary, "webLibSimd.wasm", config.showLogs),
+					wasmModule: await instantiate(simdFactory, simdBytes, config.showLogs),
 					simdUsed: true
 				};
 				loadedResult = result;
@@ -896,10 +918,13 @@ async function loadWasmModule(config) {
 					message: `simd load failed falling back ${describeLoadError(simdError)}`
 				});
 			}
-			const nonSimdFactory = await resolveGlue(config.loadGlue, config.glueCodePath, "webLib.js");
+			const [nonSimdFactory, nonSimdBytes] = await Promise.all([resolveGlue(config.loadGlue, config.glueCodePath, "webLib.js"), resolveWasmSource(config.wasmPath, {
+				kind: "binary",
+				slot: "webLib.wasm"
+			})]);
 			window.Module = nonSimdFactory;
 			const result = {
-				wasmModule: await instantiate(nonSimdFactory, config.wasmPath, "webLib.wasm", config.showLogs),
+				wasmModule: await instantiate(nonSimdFactory, nonSimdBytes, config.showLogs),
 				simdUsed: false
 			};
 			loadedResult = result;
@@ -1020,7 +1045,7 @@ function resetWasmCallDiagnostics() {
 //#endregion
 //#region ../infra/src/wasm/wasmCallUtils.ts
 /**
-* Poll bound applied to the ML long-poll call sites (`prc` / `poc` / `rsp` in
+* Poll bound applied to the ML long-poll call sites (`poc` / `rsp` in
 * `utilityWasmApi.ts`).
 *
 * Count-based, not deadline-based: the poll loop yields with `setTimeout(0)`,
@@ -1028,11 +1053,15 @@ function resetWasmCallDiagnostics() {
 * 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.
+* 3000 is deliberately generous. The pre-capture check (`prc`, until
+* ml-wasm-kit v2.14.52 moved it into the camera step) alone burned ~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.
+* The camera step itself (`cst`) is deliberately unbounded: an open permission
+* prompt or a hidden tab parks it, and `rcc` is the only cancel — see
+* `WasmRuntime.startCameraCycle`.
 */
 const ML_CALL_MAX_POLLS = 3e3;
 /**
@@ -1271,4 +1300,4 @@ function ensureReady() {
 	return webClientApi;
 }
 //#endregion
-export { buildModelVariantSources as A, isDefaultCdnWasmConfig as C, WASM_PIPELINE_MODELS as D, WASM_PIPELINE_LAZY_MODEL_NAMES as E, resolveWasmSource as M, reportWasmIntegritySummary as N, WASM_PIPELINE_MODEL_NAMES as O, setWasmIntegrityObserver as P, getBarcodeEnhanceModelUrl as S, WASM_MODEL_FILES as T, setWasmDiagnosticsHandler as _, setWebApiHttpTransport as a, buildDefaultWasmConfig as b, wasmCallWrapper as c, noteUnlockedCallStart as d, rearmWasmCallDiagnostics as f, emitWasmDiagnostic as g, acquireWasmStorageFallback as h, initializeWasmWebClient as i, missingWasmModelError as j, WASM_PIPELINE_OPTIONAL_MODEL_NAMES as k, notePipelineStatePulled as l, loadWasmModule as m, createWebApiHostAdapter as n, setupWasmConnection as o, resetWasmCallDiagnostics as p, executeWasmRequest as r, ML_CALL_MAX_POLLS as s, WasmWebClientError as t, noteUnlockedCallEnd as u, SemaphoreProvider as v, resolveWasmConfig as w, buildWasmConfigFromBasePath as x, DEFAULT_WASM_VERSION as y };
+export { WASM_PIPELINE_OPTIONAL_MODEL_NAMES as A, getBarcodeEnhanceModelUrl as C, WASM_PIPELINE_LAZY_MODEL_NAMES as D, WASM_MODEL_FILES as E, setWasmIntegrityObserver as F, missingWasmModelError as M, resolveWasmSource as N, WASM_PIPELINE_MODELS as O, reportWasmIntegritySummary as P, buildWasmConfigFromBasePath as S, resolveWasmConfig as T, emitWasmDiagnostic as _, setWebApiHttpTransport as a, DEFAULT_WASM_VERSION as b, wasmCallWrapper as c, noteUnlockedCallStart as d, rearmWasmCallDiagnostics as f, setWasmStartGate as g, acquireWasmStorageFallback as h, initializeWasmWebClient as i, buildModelVariantSources as j, WASM_PIPELINE_MODEL_NAMES as k, notePipelineStatePulled as l, loadWasmModule as m, createWebApiHostAdapter as n, setupWasmConnection as o, resetWasmCallDiagnostics as p, executeWasmRequest as r, ML_CALL_MAX_POLLS as s, WasmWebClientError as t, noteUnlockedCallEnd as u, setWasmDiagnosticsHandler as v, isDefaultCdnWasmConfig as w, buildDefaultWasmConfig as x, SemaphoreProvider as y };

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

@@ -1,2 +1,3 @@
-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-B3GDPZrr.js";
+import { n as WatchlistForBusinessValidationErrors, t as WatchlistForBusinessConfig } from "./types-B9C8W01q.js";
+import { a as createWatchlistForBusinessManager, c as watchlistForBusinessMachine, i as WatchlistForBusinessState, n as WatchlistForBusinessFormState, o as createWatchlistForBusinessManagerFromActor, r as WatchlistForBusinessManager, s as WatchlistForBusinessActor, t as WatchlistForBusinessFinishedState } from "./watchlistForBusinessManager-DX2AyM4Y.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,3 +1,3 @@
-import { t as watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-B66E7jud.esm.js";
-import { n as createWatchlistForBusinessManagerFromActor, t as createWatchlistForBusinessManager } from "./watchlistForBusinessManager-CZZOFkGl.esm.js";
+import { n as watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-DdaPl2PS.esm.js";
+import { n as createWatchlistForBusinessManagerFromActor, t as createWatchlistForBusinessManager } from "./watchlistForBusinessManager-DqUpAEj_.esm.js";
 export { createWatchlistForBusinessManager, createWatchlistForBusinessManagerFromActor, watchlistForBusinessMachine };

package/dist/watchlist.esm.js

@@ -1,3 +1,3 @@
-import { t as watchlistMachine } from "./watchlistStateMachine-McALifag.esm.js";
-import { t as createWatchlistManager } from "./watchlistManager-DXtX94SN.esm.js";
+import { t as watchlistMachine } from "./watchlistStateMachine-ofHW_lPk.esm.js";
+import { t as createWatchlistManager } from "./watchlistManager-CdpXzT4B.esm.js";
 export { createWatchlistManager, watchlistMachine };

package/dist/{watchlistForBusinessManager-B3GDPZrr.d.ts → watchlistForBusinessManager-DX2AyM4Y.d.ts}

@@ -1,36 +1,47 @@
 import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
 import { t as Manager } from "./Manager-C9T5amUN.js";
 import "./Actor-DpTj5PFb.js";
+import { n as WatchlistForBusinessValidationErrors, t as WatchlistForBusinessConfig } from "./types-B9C8W01q.js";
 //#region src/modules/watchlist-for-business/watchlistForBusinessStateMachine.d.ts
 declare const watchlistForBusinessMachine: any;
 type WatchlistForBusinessMachine = typeof watchlistForBusinessMachine;
 //#endregion
 //#region src/modules/watchlist-for-business/watchlistForBusinessActor.d.ts
-type WatchlistForBusinessActor = ActorRefFrom<WatchlistForBusinessMachine>;
-//#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>;
-type WatchlistForBusinessValidationErrors = {
-  businessName?: string;
+type CreateWatchlistForBusinessActorOptions = {
+  config?: WatchlistForBusinessConfig;
 };
+type WatchlistForBusinessActor = ActorRefFrom<WatchlistForBusinessMachine>;
 //#endregion
 //#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()`. */
+/**
+ * Form is ready — use `setCountry()`, `setBusinessName()`, `setTaxId()`,
+ * `setDateOfIncorporation()`, and `submit()`.
+ */
 type WatchlistForBusinessFormState = {
   status: 'form';
   country: string;
   businessName: string;
+  /** Optional. Sent only when `showTaxId` is true and the value is not blank. */
+  taxId: string;
+  /**
+   * Optional, `YYYY-MM-DD`. Sent only when `showDateOfIncorporation` is true
+   * and the value is not blank.
+   */
+  dateOfIncorporation: string;
+  /** Whether the module config enables the optional Tax ID input. */
+  showTaxId: boolean;
+  /** Whether the module config enables the optional date-of-incorporation input. */
+  showDateOfIncorporation: boolean;
+  /**
+   * Latest allowed date of incorporation (`YYYY-MM-DD`): today in the user's
+   * local time. Use it as the date input's `max`; a later date fails submit.
+   */
+  maxDateOfIncorporation: string;
+  /** Whether the required business name is filled. Optional fields never affect it. */
   isValid: boolean;
   validationErrors?: WatchlistForBusinessValidationErrors;
   canSubmit: boolean;
@@ -59,6 +70,11 @@ type WatchlistForBusinessState = WatchlistForBusinessIdleState | WatchlistForBus
  *
  * On API error the module completes silently (fire-and-forget).
  *
+ * @param options.config - Optional module config. `taxIdEnabled` and
+ * `dateOfIncorporationEnabled` turn on the optional Tax ID and date-of-
+ * incorporation inputs. Without config only country and business name are
+ * collected.
+ *
  * @example Headless usage
  * ```typescript
  * import { createWatchlistForBusinessManager } from '@incodetech/core/watchlist-for-business';
@@ -74,14 +90,24 @@ type WatchlistForBusinessState = WatchlistForBusinessIdleState | WatchlistForBus
  * manager.stop();
  * ```
  */
-declare function createWatchlistForBusinessManager(): Manager<WatchlistForBusinessState> & {
+declare function createWatchlistForBusinessManager(options?: CreateWatchlistForBusinessActorOptions): 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. */
+  /** Updates the optional Tax ID field. A blank value is not sent. */
+  setTaxId(value: string): void;
+  /**
+   * Updates the optional date of incorporation (`YYYY-MM-DD`). A blank value
+   * is not sent; a future date blocks submit.
+   */
+  setDateOfIncorporation(value: string): void;
+  /**
+   * Submits the form. Transitions only when the business name is filled and
+   * every filled optional field is valid; otherwise sets `validationErrors`.
+   */
   submit(): void;
 };
 declare function createWatchlistForBusinessManagerFromActor(actor: WatchlistForBusinessActor): Manager<WatchlistForBusinessState> & {
@@ -91,9 +117,19 @@ declare function createWatchlistForBusinessManagerFromActor(actor: WatchlistForB
   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. */
+  /** Updates the optional Tax ID field. A blank value is not sent. */
+  setTaxId(value: string): void;
+  /**
+   * Updates the optional date of incorporation (`YYYY-MM-DD`). A blank value
+   * is not sent; a future date blocks submit.
+   */
+  setDateOfIncorporation(value: string): void;
+  /**
+   * Submits the form. Transitions only when the business name is filled and
+   * every filled optional field is valid; otherwise sets `validationErrors`.
+   */
   submit(): void;
 };
 type WatchlistForBusinessManager = ReturnType<typeof createWatchlistForBusinessManager>;
 //#endregion
-export { createWatchlistForBusinessManager as a, WatchlistForBusinessValidationErrors as c, WatchlistForBusinessState as i, WatchlistForBusinessActor as l, WatchlistForBusinessFormState as n, createWatchlistForBusinessManagerFromActor as o, WatchlistForBusinessManager as r, WatchlistForBusinessConfig as s, WatchlistForBusinessFinishedState as t, watchlistForBusinessMachine as u };
+export { createWatchlistForBusinessManager as a, watchlistForBusinessMachine as c, WatchlistForBusinessState as i, WatchlistForBusinessFormState as n, createWatchlistForBusinessManagerFromActor as o, WatchlistForBusinessManager as r, WatchlistForBusinessActor as s, WatchlistForBusinessFinishedState as t };

package/dist/{watchlistForBusinessManager-CZZOFkGl.esm.js → watchlistForBusinessManager-DqUpAEj_.esm.js}

@@ -1,10 +1,10 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Du2A4-Qr.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ggpBBaZ8.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
-import { t as watchlistForBusinessMachine } from "./watchlistForBusinessStateMachine-B66E7jud.esm.js";
+import { n as watchlistForBusinessMachine, t as getMaxDateOfIncorporation } from "./watchlistForBusinessStateMachine-DdaPl2PS.esm.js";
 //#region src/modules/watchlist-for-business/watchlistForBusinessActor.ts
-function createWatchlistForBusinessActor() {
-	return createActor(watchlistForBusinessMachine).start();
+function createWatchlistForBusinessActor(options = {}) {
+	return createActor(watchlistForBusinessMachine, { input: { config: options.config ?? {} } }).start();
 }
 //#endregion
 //#region src/modules/watchlist-for-business/watchlistForBusinessManager.ts
@@ -38,6 +38,11 @@ function mapState(snapshot) {
 		status: "form",
 		country: context.country,
 		businessName: context.businessName,
+		taxId: context.taxId,
+		dateOfIncorporation: context.dateOfIncorporation,
+		showTaxId: context.config?.taxIdEnabled === true,
+		showDateOfIncorporation: context.config?.dateOfIncorporationEnabled === true,
+		maxDateOfIncorporation: getMaxDateOfIncorporation(),
 		isValid: context.isValid,
 		validationErrors: context.validationErrors,
 		canSubmit: Object.keys(context.validationErrors ?? {}).length === 0
@@ -67,7 +72,27 @@ function createApi({ actor, trackElementClicked }) {
 				value
 			});
 		},
-		/** Submits the form. Only transitions when `isValid` is true. */
+		/** Updates the optional Tax ID field. A blank value is not sent. */
+		setTaxId(value) {
+			actor.send({
+				type: "SET_TAX_ID",
+				value
+			});
+		},
+		/**
+		* Updates the optional date of incorporation (`YYYY-MM-DD`). A blank value
+		* is not sent; a future date blocks submit.
+		*/
+		setDateOfIncorporation(value) {
+			actor.send({
+				type: "SET_DATE_OF_INCORPORATION",
+				value
+			});
+		},
+		/**
+		* Submits the form. Transitions only when the business name is filled and
+		* every filled optional field is valid; otherwise sets `validationErrors`.
+		*/
 		submit() {
 			trackElementClicked?.("submit");
 			actor.send({ type: "SUBMIT" });
@@ -79,6 +104,11 @@ function createApi({ actor, trackElementClicked }) {
 *
 * On API error the module completes silently (fire-and-forget).
 *
+* @param options.config - Optional module config. `taxIdEnabled` and
+* `dateOfIncorporationEnabled` turn on the optional Tax ID and date-of-
+* incorporation inputs. Without config only country and business name are
+* collected.
+*
 * @example Headless usage
 * ```typescript
 * import { createWatchlistForBusinessManager } from '@incodetech/core/watchlist-for-business';
@@ -94,8 +124,8 @@ function createApi({ actor, trackElementClicked }) {
 * manager.stop();
 * ```
 */
-function createWatchlistForBusinessManager() {
-	return createWatchlistForBusinessManagerFromActor(createWatchlistForBusinessActor());
+function createWatchlistForBusinessManager(options = {}) {
+	return createWatchlistForBusinessManagerFromActor(createWatchlistForBusinessActor(options));
 }
 function createWatchlistForBusinessManagerFromActor(actor) {
 	return createManager({

package/dist/watchlistForBusinessStateMachine-DdaPl2PS.esm.js

@@ -0,0 +1,166 @@
+import { n as getTimestamp } from "./IBrowserEnvironmentCapability-D7JG7ML3.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
+import { r as validateCNPJ, t as COUNTRIES_WITH_CNPJ_VALIDATION } from "./cnpj-Co1ottYN.esm.js";
+//#region ../infra/src/time/epochMsToLocalIsoDate.ts
+/**
+* Converts an epoch-milliseconds timestamp to the user's local calendar date
+* as `YYYY-MM-DD` — the format of an `<input type="date">` value.
+*
+* Use it to compare a user-entered date with "today" as the user sees it.
+* `DateFormattingProvider.utcToIsoDateString` returns the UTC date, which is a
+* day off near midnight outside UTC. Lives in Infra (L0) because Core cannot
+* touch the `Date` global (`no-browser-api-in-core`); see `epochMsToIsoString`.
+*/
+function epochMsToLocalIsoDate(epochMs) {
+	const date = new Date(epochMs);
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${date.getFullYear()}-${month}-${day}`;
+}
+//#endregion
+//#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";
+const BUSINESS_NAME_REQUIRED_ERROR = "dynamicForms.fieldRequired";
+const INVALID_TAX_ID_ERROR = "ekyb.error.invalidTaxId";
+const FUTURE_DATE_OF_INCORPORATION_ERROR = "watchlistForBusiness.dateOfIncorporationFuture";
+/**
+* Country-specific Tax ID format checks, applied only to a filled Tax ID.
+* Countries without an entry accept any value. The CNPJ countries come from
+* the shared list eKYB also uses, so the two modules cannot drift.
+*/
+const TAX_ID_VALIDATORS = Object.fromEntries(COUNTRIES_WITH_CNPJ_VALIDATION.map((country) => [country, validateCNPJ]));
+/**
+* Latest allowed date of incorporation: today in the user's local time, as
+* `YYYY-MM-DD`. The single source for both the future-date check and the
+* date picker's `max` (exposed through the manager's `form` state).
+*/
+function getMaxDateOfIncorporation() {
+	return epochMsToLocalIsoDate(getTimestamp());
+}
+function computeIsValid(businessName) {
+	return businessName.trim().length > 0;
+}
+/**
+* Returns the trimmed value of an optional field, or `undefined` when the
+* field is disabled or blank — a blank optional field is never sent.
+*/
+function optionalValue(enabled, value) {
+	if (!enabled) return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function getTaxId(context) {
+	return optionalValue(context.config?.taxIdEnabled, context.taxId);
+}
+function getDateOfIncorporation(context) {
+	return optionalValue(context.config?.dateOfIncorporationEnabled, context.dateOfIncorporation);
+}
+function computeValidationErrors(context) {
+	const errors = {};
+	if (!computeIsValid(context.businessName)) errors.businessName = BUSINESS_NAME_REQUIRED_ERROR;
+	const taxId = getTaxId(context);
+	const validateTaxId = TAX_ID_VALIDATORS[context.country];
+	if (taxId && validateTaxId && !validateTaxId(taxId)) errors.taxId = INVALID_TAX_ID_ERROR;
+	const dateOfIncorporation = getDateOfIncorporation(context);
+	if (dateOfIncorporation && dateOfIncorporation > getMaxDateOfIncorporation()) errors.dateOfIncorporation = FUTURE_DATE_OF_INCORPORATION_ERROR;
+	return Object.keys(errors).length > 0 ? errors : void 0;
+}
+function buildSubmitRequest(context) {
+	const request = {
+		countryCodes: [context.country],
+		businessName: context.businessName.trim()
+	};
+	const taxId = getTaxId(context);
+	if (taxId) request.taxId = taxId;
+	const dateOfIncorporation = getDateOfIncorporation(context);
+	if (dateOfIncorporation) request.dateOfIncorporation = dateOfIncorporation;
+	return request;
+}
+/** Drops one field's error once the user edits what it depends on. */
+function withoutValidationError(context, field) {
+	if (!context.validationErrors?.[field]) return {};
+	const remaining = { ...context.validationErrors };
+	delete remaining[field];
+	return { validationErrors: Object.keys(remaining).length > 0 ? remaining : void 0 };
+}
+const watchlistForBusinessMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { submitWatchlistForBusiness: fromPromise(async ({ input, signal }) => {
+		await submitWatchlistForBusiness(input, signal);
+	}) },
+	actions: {
+		setCountry: assign(({ event }) => {
+			const { country } = event;
+			return { country };
+		}),
+		setBusinessName: assign(({ event }) => {
+			const { value } = event;
+			return {
+				businessName: value,
+				isValid: computeIsValid(value)
+			};
+		}),
+		setTaxId: assign(({ event }) => {
+			const { value } = event;
+			return { taxId: value };
+		}),
+		setDateOfIncorporation: assign(({ event }) => {
+			const { value } = event;
+			return { dateOfIncorporation: value };
+		}),
+		clearBusinessNameValidationError: assign(({ context }) => withoutValidationError(context, "businessName")),
+		clearTaxIdValidationError: assign(({ context }) => withoutValidationError(context, "taxId")),
+		clearDateOfIncorporationValidationError: assign(({ context }) => withoutValidationError(context, "dateOfIncorporation")),
+		setValidationErrors: assign(({ context }) => ({ validationErrors: computeValidationErrors(context) }))
+	},
+	guards: { canSubmit: ({ context }) => computeValidationErrors(context) === void 0 }
+}).createMachine({
+	id: "watchlist-for-business",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input?.config ?? {},
+		country: DEFAULT_COUNTRY,
+		businessName: "",
+		taxId: "",
+		dateOfIncorporation: "",
+		isValid: false,
+		validationErrors: void 0
+	}),
+	states: {
+		idle: { on: { LOAD: { target: "form" } } },
+		form: { on: {
+			SET_COUNTRY: { actions: ["setCountry", "clearTaxIdValidationError"] },
+			SET_BUSINESS_NAME: { actions: ["setBusinessName", "clearBusinessNameValidationError"] },
+			SET_TAX_ID: { actions: ["setTaxId", "clearTaxIdValidationError"] },
+			SET_DATE_OF_INCORPORATION: { actions: ["setDateOfIncorporation", "clearDateOfIncorporationValidationError"] },
+			SUBMIT: [{
+				target: "submitting",
+				guard: "canSubmit"
+			}, { actions: "setValidationErrors" }]
+		} },
+		submitting: { invoke: {
+			id: "submitWatchlistForBusiness",
+			src: "submitWatchlistForBusiness",
+			input: ({ context }) => buildSubmitRequest(context),
+			onDone: { target: "success" },
+			onError: { target: "finished" }
+		} },
+		success: { after: { 3e3: { target: "finished" } } },
+		finished: { type: "final" }
+	}
+});
+//#endregion
+export { watchlistForBusinessMachine as n, getMaxDateOfIncorporation as t };

package/dist/{watchlistManager-DXtX94SN.esm.js → watchlistManager-CdpXzT4B.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Du2A4-Qr.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ggpBBaZ8.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
-import { t as watchlistMachine } from "./watchlistStateMachine-McALifag.esm.js";
+import { t as watchlistMachine } from "./watchlistStateMachine-ofHW_lPk.esm.js";
 //#region src/modules/watchlist/watchlistActor.ts
 function createWatchlistActor() {
 	return createActor(watchlistMachine).start();

package/dist/{watchlistStateMachine-McALifag.esm.js → watchlistStateMachine-ofHW_lPk.esm.js}

@@ -1,4 +1,4 @@
-import { t as api, u as endpoints } from "./api-Cz90EHyu.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-DSajW7CJ.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-8Gzepa_A.esm.js";
 //#region src/modules/watchlist/watchlistServices.ts

package/dist/workflow.d.ts

@@ -2,7 +2,7 @@ import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorR
 import { t as CallbackActorLogic } from "./callback-645_omgz.js";
 import { t as Manager } from "./Manager-C9T5amUN.js";
 import { a as TotalScore, i as GetTotalScoreStatusFn, n as FinishStatus, r as GetFinishStatusFn } from "./flowCompletionService-BlAHsKyv.js";
-import { o as FlowEventSubscribable } from "./index-CKQ9QBZP.js";
+import { o as FlowEventSubscribable } from "./index-DC0P2Vzw.js";
 import { a as WorkflowModuleRegistry, i as RunChildModuleInput, r as RunChildModuleEvent, t as ModuleConfigMappers } from "./types-BQA7lRDV.js";
 //#region src/modules/workflow/types.d.ts
 /** Possible node types returned by the workflow server. */
@@ -215,6 +215,8 @@ type LoadingResult = {
 type ProcessNextNodeInput = {
   isInjectedNode: boolean;
   firstNode: WorkflowNode | undefined;
+  /** The node being left; compared with the server node after a reconnect. */
+  currentNodeId: string | undefined;
   currentNodeModuleKey: string | undefined;
   workflowConfigId: string | undefined;
   workflowRedirectDesktopToMobile: boolean;
@@ -889,7 +891,7 @@ declare const workflowMachine: StateMachine<WorkflowContext, {
           readonly actions: readonly ["setModuleErrorCode", "trackAdvanceableModuleError"];
         }, {
           readonly target: "error";
-          readonly actions: readonly ["setModuleError", "trackTerminalModuleError"];
+          readonly actions: readonly ["setModuleError", "setModuleErrorCode", "trackTerminalModuleError"];
         }];
         readonly COMPLETE_FLOW: "completing";
         readonly FINISH_WORKFLOW: readonly [{
@@ -1033,6 +1035,7 @@ declare const workflowMachine: StateMachine<WorkflowContext, {
         }) => {
           isInjectedNode: boolean;
           firstNode: WorkflowNode | undefined;
+          currentNodeId: string | undefined;
           currentNodeModuleKey: string | undefined;
           workflowConfigId: string | undefined;
           workflowRedirectDesktopToMobile: boolean;