@incodetech/core 2.4.0 → 2.4.1-agentic

package/dist/{videoSelfieStepDetector-CGsTltqB.d.ts → videoSelfieStepDetector-RfSmlFFW.d.ts}

@@ -1,6 +1,6 @@
-import { i as FlowModuleConfig } from "./types-B6HsSzpk.js";
-import "./IWasmUtilCapability-GF2n7sfm.js";
-import { n as DetectionStatus } from "./types-yPH8lAH-.js";
+import { i as FlowModuleConfig } from "./types-DuD8TRJU.js";
+import "./IWasmUtilCapability-Cqiaxydi.js";
+import { n as DetectionStatus } from "./types--3HDl2SF.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
 import { t as DetectionOrientation } from "./IIdCaptureCapability-CGcEt2Cw.js";
 //#region src/modules/video-selfie/types.d.ts
@@ -10,6 +10,11 @@ import { t as DetectionOrientation } from "./IIdCaptureCapability-CGcEt2Cw.js";
  * `frontId`/`backId`, `checkVoiceConsent` enables `speech`).
  */
 type VideoSelfieStep = 'selfie' | 'frontId' | 'backId' | 'poa' | 'questions' | 'speech';
+/** Speech validation verdict, or a failure to obtain a verdict. */
+type VideoSelfieSpeechResult = {
+  success: boolean;
+  errorKind?: 'connection' | 'technical';
+};
 /**
  * Public Video Selfie configuration. Mirrors the backend `VIDEO_ONBOARDING`
  * workflow module.
@@ -215,4 +220,4 @@ type StepDetector = (params: {
   registerManualCapture?: (trigger: () => void) => void;
 }) => Promise<StepDetectionResult>;
 //#endregion
-export { FacingMode as a, CameraCompositor as i, VideoSelfieDetectionStatus as n, VideoSelfieConfig as o, VideoSelfieValidationFailure as r, VideoSelfieStep as s, StepDetector as t };
+export { FacingMode as a, VideoSelfieStep as c, CameraCompositor as i, VideoSelfieDetectionStatus as n, VideoSelfieConfig as o, VideoSelfieValidationFailure as r, VideoSelfieSpeechResult as s, StepDetector as t };

package/dist/{warmup-BElYWRh7.esm.js → warmup-BkfxQZsC.esm.js}

@@ -1,5 +1,7 @@
-import { A as buildModelVariantSources, C as isDefaultCdnWasmConfig, D as WASM_PIPELINE_MODELS, M as resolveWasmSource, N as reportWasmIntegritySummary, T as WASM_MODEL_FILES, f as rearmWasmCallDiagnostics, g as emitWasmDiagnostic, h as acquireWasmStorageFallback, j as missingWasmModelError, k as WASM_PIPELINE_OPTIONAL_MODEL_NAMES, l as notePipelineStatePulled, m as loadWasmModule, n as createWebApiHostAdapter, p as resetWasmCallDiagnostics, v as SemaphoreProvider, y as DEFAULT_WASM_VERSION } from "./wasmWebClient-BjZw_7OB.esm.js";
-import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
+import { n as __exportAll } from "./rolldown-runtime-B-1-B7_t.esm.js";
+import { A as WASM_PIPELINE_OPTIONAL_MODEL_NAMES, E as WASM_MODEL_FILES, M as missingWasmModelError, N as resolveWasmSource, O as WASM_PIPELINE_MODELS, P as reportWasmIntegritySummary, _ as emitWasmDiagnostic, b as DEFAULT_WASM_VERSION, c as wasmCallWrapper, f as rearmWasmCallDiagnostics, h as acquireWasmStorageFallback, j as buildModelVariantSources, l as notePipelineStatePulled, m as loadWasmModule, n as createWebApiHostAdapter, p as resetWasmCallDiagnostics, w as isDefaultCdnWasmConfig, y as SemaphoreProvider } from "./wasmWebClient-DTj9auyA.esm.js";
+import { n as getTimestamp } from "./IBrowserEnvironmentCapability-D7JG7ML3.esm.js";
+import { t as bindWasmMetadataV2Applier } from "./wasmMetadataVersionSync-U8EFUr1T.esm.js";
 //#region ../infra/src/wasm/wasmEnumMaps.ts
 function pipelineTypeToWasmEnum(wasmModule, type) {
 	switch (type) {
@@ -63,11 +65,11 @@ function idCaptureModelTypeFromWasmEnum(wasmModule, type) {
 * The mode is a property of the binary, detected at install:
 * - `sink` — `setDiagnosticsSink` exists (v2.14.52+): batches are pushed,
 *   and finalize drains the unsent tail via `drainDiagnostics`.
-* - `fallback` — only `getAppLogs` exists (the pinned v2.14.50-post1): the
+* - `fallback` — only `getAppLogs` exists (binaries before v2.14.52): the
 *   plain-text `ClientLogger::render()` grammar (optional leading
 *   `... <k> dropped`, then `+<elapsedMs> <E|W|I> <tag>: <msg>[ (xN)]`) is
-*   parsed at finalize. Nothing in v2.14.50-post1 writes that logger, so in
-*   practice it is empty until the bump.
+*   parsed at finalize. Nothing before v2.14.52 writes that logger, so in
+*   practice it is empty on those binaries.
 * - `none` — neither binding.
 * No TrueSight change is needed when `DEFAULT_WASM_VERSION` moves past the
 * sensor release: the next install simply detects `sink`.
@@ -395,6 +397,45 @@ function deleteWasmHandle(firstFailure, handle) {
 function releaseCameraCycleResources(stream, cameraCycleApi) {
 	return attemptCleanup(stopStreamTracks(stream), () => cameraCycleApi?.rcc());
 }
+/**
+* Wraps one host callback of the camera step. The kit calls the outcome
+* callbacks from inside the `cst` binding and the frame callbacks from its own
+* 16 ms frame timer. A JavaScript throw out of either cannot be caught in C++,
+* so the host's error becomes a diagnostic instead. Only the first throw per
+* callback per step is reported, so a failing frame callback cannot flood
+* TrueSight. An absent optional callback becomes a no-op, because the binding
+* expects four functions and logs `cc: bad callback` otherwise.
+*/
+function guardCameraCycleCallback(name, callback) {
+	let reported = false;
+	return (...args) => {
+		if (callback === void 0) return;
+		try {
+			callback(...args);
+		} catch (error) {
+			if (reported) return;
+			reported = true;
+			emitWasmDiagnostic({
+				level: "warning",
+				subsystem: "camera",
+				category: "other",
+				message: `camera cycle ${name} host callback threw: ${error instanceof Error ? error.message : String(error)}`
+			});
+		}
+	};
+}
+/**
+* The native release runs behind the ML lock, after the caller returned, so its
+* failure can only be reported, never thrown.
+*/
+function reportCameraCycleReleaseFailure(error) {
+	emitWasmDiagnostic({
+		level: "warning",
+		subsystem: "camera",
+		category: "other",
+		message: `camera cycle release failed: ${error instanceof Error ? error.message : String(error)}`
+	});
+}
 function isWasmModelEntry(source) {
 	return typeof source === "object" && !(source instanceof ArrayBuffer) && !(source instanceof Uint8Array) && "file" in source;
 }
@@ -412,8 +453,10 @@ var WasmRuntime = class WasmRuntime {
 		this.faceProcessingWasmApi = null;
 		this.cameraCycleApi = null;
 		this.webApi = null;
+		this.metadataV2Enabled_ = false;
 		this.storageFallbackLease = null;
 		this.unprotectedStream = null;
+		this.queuedCameraSteps = /* @__PURE__ */ new Set();
 		this.imageWidth_ = null;
 		this.imageHeight_ = null;
 		this.pipelines_ = null;
@@ -432,6 +475,7 @@ var WasmRuntime = class WasmRuntime {
 			this.workflowApiUtilities = new this.wasmModule.WorkflowApiUtilities();
 			this.utilityApi = new this.wasmModule.UtilityApi();
 			this.utilityApi.setProductionMode(module.showLogs !== true);
+			this.utilityApi.smv(this.metadataV2Enabled_);
 			installWasmDiagnosticsSink(this.utilityApi);
 			this.idCaptureWasmApi = new this.wasmModule.IdCaptureApi();
 			this.faceProcessingWasmApi = new this.wasmModule.FaceProcessingApi();
@@ -519,6 +563,7 @@ var WasmRuntime = class WasmRuntime {
 		if (typeof window !== "undefined") window.wasmArrayBuffer = null;
 		resetWasmCallDiagnostics();
 		resetWasmDiagnosticsSink();
+		this.cancelQueuedCameraSteps();
 		let firstFailure = releaseCameraCycleResources(stream, cameraCycleApi);
 		firstFailure = deleteWasmHandle(firstFailure, modelsBuffers);
 		firstFailure = deleteWasmHandle(firstFailure, workflowApiUtilities);
@@ -544,6 +589,21 @@ var WasmRuntime = class WasmRuntime {
 		if (!this.isInitialized() || pipelines === null) throw new Error("Unable to reset pipelines, cpp API hasn't been initialized");
 		for (const [type] of pipelines) this.resetPipeline(type);
 	}
+	/**
+	* Selects the capture-metadata document the kit emits (`smv`, ADR 0009):
+	* `true` = v2, `false` = v1 (the default). Unguarded on purpose: the SDK
+	* resolves the provisioning flag at session initialization, which may run
+	* before WASM is up, so the value is latched here, applied at once when a
+	* module is live and replayed by every `initialize()`. The session sets it
+	* through `wasmMetadataVersionSync.ts`, which the singleton binds to when
+	* this module loads. Never toggle it mid-session — `getMetadata`,
+	* `postFaceResults` and the protected upload each read the selection when
+	* they run, so uploads would mix formats.
+	*/
+	setMetadataV2Enabled(enabled) {
+		this.metadataV2Enabled_ = enabled;
+		this.utilityApi?.smv(enabled);
+	}
 	async process(typeOrImage, imageOrType) {
 		const legacyOrder = typeof typeOrImage !== "number";
 		const type = legacyOrder ? typeof imageOrType === "number" ? imageOrType : void 0 : typeOrImage;
@@ -641,8 +701,55 @@ var WasmRuntime = class WasmRuntime {
 		return this.pipelineTypeFromWasmEnum(workflowApiUtilities.getCurrentWorkflow());
 	}
 	setOnDeviceMode(_enabled) {}
-	adoptCameraStream(stream, constraints, options = {}) {
-		return this.requireCameraCycleApi("Unable to adopt stream, cpp API hasn't been initialized").ads(stream, constraints, options);
+	/**
+	* Runs ml-wasm-kit's camera step: the kit acquires the camera (electing the
+	* lens from `options`), adopts the stream into the protected cycle, runs the
+	* pre-capture checks and reports through `callbacks`. Mirrors upstream
+	* `startCameraCycle` (`wasmApi.ts`): poll `cst` with a release token under
+	* the ML semaphore. The pre-capture IAD inside the step is the work `prc`
+	* used to do, and holding the lock keeps `poc`/`rsp` serialized behind it.
+	*
+	* Two differences from upstream serve the release rule of
+	* {@link releaseCameraCycle}. The token (`grt()`) is read on the first poll,
+	* inside the lock, rather than before queueing: a release queued ahead of
+	* this step has then already rotated it, so the step never polls with a
+	* token its predecessor's `rcc` voided. And a step released while it still
+	* waits for the lock ends without calling `cst`, so a released attempt never
+	* opens the camera.
+	*
+	* Resolves when the step is done: ready or failed through the callbacks, or
+	* skipped because the cycle was released before the step reached the kit,
+	* in which case neither callback fires. Rejects when the handle is freed
+	* mid-step, or when the kit throws outside its own state machine (`cst` is
+	* bound without the exception wrapper on purpose). A re-initialization
+	* between two polls can also end the step without an outcome, because the
+	* new handle refuses the old token.
+	*/
+	async startCameraCycle(options, callbacks) {
+		const message = "Unable to start the camera cycle, cpp API hasn't been initialized";
+		this.requireCameraCycleApi(message);
+		const queued = { cancelled: false };
+		this.queuedCameraSteps.add(queued);
+		const onNewFrame = guardCameraCycleCallback("onNewFrame", callbacks.onNewFrame);
+		const onFirstFrame = guardCameraCycleCallback("onFirstFrame", callbacks.onFirstFrame);
+		const onCameraReady = guardCameraCycleCallback("onCameraReady", callbacks.onCameraReady);
+		const onCameraFailed = guardCameraCycleCallback("onCameraFailed", callbacks.onCameraFailed);
+		let releaseToken;
+		let reachedKit = false;
+		try {
+			await wasmCallWrapper(this.mlCallSemaphore, () => {
+				const api = this.requireCameraCycleApi(message);
+				if (!reachedKit) {
+					this.queuedCameraSteps.delete(queued);
+					if (queued.cancelled) return true;
+					reachedKit = true;
+					releaseToken = api.grt();
+				}
+				return api.cst(options, onNewFrame, onFirstFrame, onCameraReady, onCameraFailed, releaseToken);
+			}, true, { label: "cst" });
+		} finally {
+			this.queuedCameraSteps.delete(queued);
+		}
 	}
 	setWorkflowConsuming(type, consuming) {
 		const accepted = this.requireWorkflowApiUtilities("Unable to set workflow consuming, cpp API hasn't been initialized").setWorkflowConsuming(this.pipelineTypeToWasmEnum(type), consuming);
@@ -676,11 +783,42 @@ var WasmRuntime = class WasmRuntime {
 		const extras = "extras" in request ? request.extras : {};
 		return this.requireWebApi("Unable to post protected request, cpp API hasn't been initialized").pse(request.target, extras, request.config ?? {});
 	}
+	/**
+	* Releases the protected camera cycle. The cached display clone stops at
+	* once. The native release (`rcc`) queues behind the ML lock, so it lands
+	* only after whatever holds the lock settles: a camera step that already
+	* reached the kit, or a `poc`. Cancelling the kit inside its pre-capture
+	* checks leaves the realm unable to run another camera step (ml-wasm-kit
+	* known issue `active-iad-driver-teardown`), and SDK 1 runs `rcc` under the
+	* same lock. Steps still waiting for the lock are skipped and never reach
+	* the kit.
+	*
+	* The cost is that a release cannot cancel a step that is already inside the
+	* kit. A step parked on a permission prompt or a hidden tab keeps the camera
+	* cycle until it settles, and a release queued behind it for 30 s trips the
+	* semaphore's deadlock watchdog log.
+	*
+	* Stopping the display clone can throw synchronously. A failing `rcc` cannot
+	* reach the caller any more, so it is reported as a diagnostic.
+	*/
 	releaseCameraCycle() {
 		const stream = this.unprotectedStream;
 		this.unprotectedStream = null;
-		const firstFailure = releaseCameraCycleResources(stream, this.cameraCycleApi);
-		if (firstFailure) throw firstFailure.error;
+		this.cancelQueuedCameraSteps();
+		wasmCallWrapper(this.mlCallSemaphore, () => {
+			try {
+				this.cameraCycleApi?.rcc();
+			} catch (error) {
+				reportCameraCycleReleaseFailure(error);
+			}
+			return true;
+		}, true, { label: "rcc" }).catch(reportCameraCycleReleaseFailure);
+		const failure = stopStreamTracks(stream);
+		if (failure) throw failure.error;
+	}
+	cancelQueuedCameraSteps() {
+		for (const queued of this.queuedCameraSteps) queued.cancelled = true;
+		this.queuedCameraSteps.clear();
 	}
 	resolveModelSource(source) {
 		if (typeof source === "object" && !(source instanceof ArrayBuffer) && !(source instanceof Uint8Array)) return this.usedSimd_ ? source.current : source.legacy;
@@ -750,8 +888,21 @@ var WasmRuntime = class WasmRuntime {
 WasmRuntime.UNINITIALIZED_ENUM_MAP_MESSAGE = "Unable to map pipeline type, cpp API hasn't been initialized";
 /** Process-wide runtime. One binary, one heap, one owner. */
 const wasmRuntime = new WasmRuntime();
+bindWasmMetadataV2Applier((enabled) => wasmRuntime.setMetadataV2Enabled(enabled));
 //#endregion
 //#region ../infra/src/wasm/warmup.ts
+var warmup_exports = /* @__PURE__ */ __exportAll({
+	WASM_PIPELINES: () => WASM_PIPELINES,
+	getResolvedModelSource: () => getResolvedModelSource,
+	getResolvedModelsBasePath: () => getResolvedModelsBasePath,
+	getWarmupFacts: () => getWarmupFacts,
+	getWasmStatus: () => getWasmStatus,
+	isWasmReady: () => isWasmReady,
+	setWasmOnDeviceMode: () => setWasmOnDeviceMode,
+	waitForWasm: () => waitForWasm,
+	warmupWasm: () => warmupWasm,
+	whenWasmRuntimeReady: () => whenWasmRuntimeReady
+});
 /**
 * Pipelines preloaded when no explicit `pipelines` array is passed to
 * {@link warmupWasm}. The on-device selfie bundle is opt-in (loaded only when
@@ -767,6 +918,7 @@ let lastConfig = null;
 let lastModelVariant = null;
 let warmupFacts = null;
 let pipelinesInFlight = [];
+let runtimeReadyPromise = null;
 function mapPipelineToWasmType(pipeline) {
 	switch (pipeline) {
 		case "selfie": return 4;
@@ -968,10 +1120,13 @@ async function warmupWasm(config) {
 		try {
 			const pipelinesMap = buildPipelinesMap(pipelines, config);
 			if (config.onDeviceMode !== void 0) wasmRuntime.setOnDeviceMode(config.onDeviceMode);
-			const simdUsed = await wasmRuntime.initialize({
+			const runtimeReady = wasmRuntime.initialize({
 				module: config,
 				pipelines: pipelinesMap
 			});
+			runtimeReadyPromise = runtimeReady.then(() => void 0);
+			runtimeReadyPromise.catch(() => void 0);
+			const simdUsed = await runtimeReady;
 			await wasmRuntime.loadModels();
 			await wasmRuntime.initializePipelines();
 			state = "ready";
@@ -1045,6 +1200,15 @@ function waitForWasm() {
 	return Promise.reject(/* @__PURE__ */ new Error("WASM warmup was not started. Call warmupWasm() first."));
 }
 /**
+* Resolves once the WASM runtime is up, before the models of the warmup that
+* started it finish loading: enough for the utility API (fingerprint signals).
+* Rejects when no warmup was started or the runtime failed to start.
+*/
+function whenWasmRuntimeReady() {
+	if (wasmRuntime.isInitialized()) return Promise.resolve();
+	return runtimeReadyPromise ?? Promise.reject(/* @__PURE__ */ new Error("WASM warmup was not started. Call warmupWasm() first."));
+}
+/**
 * Retained compatibility surface for callers that used the removed native
 * on-device-mode setter. Both values are native-free no-ops for the pinned
 * runtime and do not alter initialization, capture, or fingerprint lifecycle.
@@ -1053,4 +1217,4 @@ function setWasmOnDeviceMode(enabled) {
 	wasmRuntime.setOnDeviceMode(enabled);
 }
 //#endregion
-export { setWasmOnDeviceMode as a, wasmRuntime as c, drainWasmDiagnostics as d, getWasmDiagnosticsMode as f, isWasmReady as i, CAMERA_CYCLE_OWNERSHIP_DOMAIN as l, getWarmupFacts as n, waitForWasm as o, rearmWasmDiagnostics as p, getWasmStatus as r, warmupWasm as s, getResolvedModelSource as t, getCameraCycleOwnershipDomain as u };
+export { setWasmOnDeviceMode as a, warmup_exports as c, getCameraCycleOwnershipDomain as d, drainWasmDiagnostics as f, isWasmReady as i, wasmRuntime as l, rearmWasmDiagnostics as m, getWarmupFacts as n, waitForWasm as o, getWasmDiagnosticsMode as p, getWasmStatus as r, warmupWasm as s, getResolvedModelSource as t, CAMERA_CYCLE_OWNERSHIP_DOMAIN as u };

package/dist/wasm.d.ts

@@ -1,8 +1,8 @@
 import { a as WASM_MODEL_FILES, c as WasmPipeline, l as WasmSource, o as WasmGlueLoader, r as warmupWasm, s as WasmModelName, t as WarmupConfig } from "./warmup-BO57syF6.js";
-import { c as setWasmConfig, i as initializeWasmUtil, n as WasmConfig, r as ensureWasmPipelines, s as resolveWasmConfigForPipelines, u as upgradeToWasmHttpClient } from "./setup-YPKTUCY5.js";
+import { c as setWasmConfig, i as initializeWasmUtil, n as WasmConfig, r as ensureWasmPipelines, s as resolveWasmConfigForPipelines, u as upgradeToWasmHttpClient } from "./setup-D9qt8YVU.js";
 //#region ../infra/src/wasm/wasmDefaults.d.ts
 /** The WASM version bundled and tested with this SDK release. */
-declare const DEFAULT_WASM_VERSION = "v2.14.50-post1";
+declare const DEFAULT_WASM_VERSION = "v2.14.54-pre6";
 type UrlWasmConfig = WarmupConfig & {
   wasmPath: string;
   wasmSimdPath: string;

package/dist/wasm.esm.js

@@ -1,6 +1,6 @@
-import { E as WASM_PIPELINE_LAZY_MODEL_NAMES, O as WASM_PIPELINE_MODEL_NAMES, T as WASM_MODEL_FILES, b as buildDefaultWasmConfig, w as resolveWasmConfig, x as buildWasmConfigFromBasePath, y as DEFAULT_WASM_VERSION } from "./wasmWebClient-BjZw_7OB.esm.js";
-import { s as warmupWasm } from "./warmup-BElYWRh7.esm.js";
-import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-BInNAvQw.esm.js";
+import { D as WASM_PIPELINE_LAZY_MODEL_NAMES, E as WASM_MODEL_FILES, S as buildWasmConfigFromBasePath, T as resolveWasmConfig, b as DEFAULT_WASM_VERSION, k as WASM_PIPELINE_MODEL_NAMES, x as buildDefaultWasmConfig } from "./wasmWebClient-DTj9auyA.esm.js";
+import { s as warmupWasm } from "./warmup-BkfxQZsC.esm.js";
+import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-CDAKwTr7.esm.js";
 //#region src/defineWasm.ts
 function requiredModels(pipelines) {
 	const models = /* @__PURE__ */ new Set();

package/dist/{wasmDsFlagSync-CYj5LL9z.esm.js → wasmDsFlagSync-BhU5H2oR.esm.js}

@@ -1,4 +1,4 @@
-import { i as utilityWasmApi } from "./WasmUtilProvider-DtJuBdt-.esm.js";
+import { i as utilityWasmApi } from "./WasmUtilProvider-GTkoJyFY.esm.js";
 //#region ../infra/src/wasm/wasmDsFlagSync.ts
 /**
 * Sets the Deepsight (ds) flag that the WASM utility API receives on every

package/dist/wasmMetadataVersionSync-U8EFUr1T.esm.js

@@ -0,0 +1,27 @@
+//#region ../infra/src/wasm/wasmMetadataVersionSync.ts
+let metadataV2Enabled = false;
+let applyToRuntime;
+/**
+* Selects the capture-metadata document the kit emits (ml-wasm-kit `smv`,
+* ADR 0009): `true` picks the v2 document Deepsight 2.0 scores, `false` (the
+* default) the v1 document. Purely in-memory, like `setWasmDsFlagSync`: the
+* value waits here until the WASM runtime loads, and from then on the runtime
+* latches it, applies it at once when WASM is up and replays it after every
+* `initialize()`, because the kit keeps the selector as realm state that a
+* new module instance resets to v1. Resolve it before the first capture and
+* never toggle it mid-session — the uploads would mix formats.
+*/
+function setWasmMetadataV2Enabled(enabled) {
+	metadataV2Enabled = enabled;
+	applyToRuntime?.(enabled);
+}
+/**
+* For the `WasmRuntime` singleton, once, when its module loads: replays the
+* selection made before the runtime existed and forwards every later one.
+*/
+function bindWasmMetadataV2Applier(apply) {
+	applyToRuntime = apply;
+	apply(metadataV2Enabled);
+}
+//#endregion
+export { setWasmMetadataV2Enabled as n, bindWasmMetadataV2Applier as t };

package/dist/{wasmWebClient-BjZw_7OB.esm.js → wasmWebClient-DTj9auyA.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
@@ -866,6 +887,7 @@ async function loadWasmModule(config) {
 	if (loadPromise) return loadPromise;
 	const startedAtMs = getTimestamp();
 	loadPromise = (async () => {
+		await waitForWasmStartGate();
 		let storageFallbackLease = null;
 		try {
 			storageFallbackLease = acquireWasmStorageFallback();
@@ -1020,7 +1042,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 +1050,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 +1297,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-DA6K5na4.esm.js";
+import { n as createWatchlistForBusinessManagerFromActor, t as createWatchlistForBusinessManager } from "./watchlistForBusinessManager-CVay6-9A.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-CSi_ZhtT.esm.js";
+import { t as createWatchlistManager } from "./watchlistManager-B8gQ_rw3.esm.js";
 export { createWatchlistManager, watchlistMachine };

package/dist/{watchlistForBusinessManager-CZZOFkGl.esm.js → watchlistForBusinessManager-CVay6-9A.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-CQteqXfy.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-DA6K5na4.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({