@incodetech/core 2.4.0 → 2.4.1-agentic.1

package/dist/{videoSelfieCameraWarmer-D1xA0u8y.esm.js → videoSelfieCameraWarmer-e3irGfcO.esm.js}

@@ -1,14 +1,14 @@
-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 { t as BrowserTimerProvider } from "./BrowserTimerProvider-BXhgNxLt.esm.js";
-import { d as facingModeForStep, f as resolveVideoSelfieSteps } from "./flowServices-roD0oIQL.esm.js";
-import { a as requestCameraWithFallback, i as requestCameraAccess } from "./camera-sIa9ceW2.esm.js";
-import { t as checkPermission } from "./permissionServices-Ca-tSNhT.esm.js";
-import { c as processFace, d as FACE_ERROR_CODES, l as uploadSelfie, n as encryptSelfieImage, o as startDetection, t as FaceDetectionProvider } from "./FaceDetectionProvider-DcPOC2gS.esm.js";
-import { o as StreamCanvasProcessingSession } from "./multipartRecordingService-CLwrF5wD.esm.js";
-import { n as getBackCameraStream } from "./backCameraStream-CMvXj4X4.esm.js";
+import { f as facingModeForStep, p as resolveVideoSelfieSteps } from "./flowServices-Dmnc8Rye.esm.js";
+import { i as requestCameraWithFallback, r as requestCameraAccess } from "./camera-E_Kcre4O.esm.js";
+import { t as checkPermission } from "./permissionServices-D190ATGD.esm.js";
+import { c as uploadSelfie, n as encryptSelfieImage, o as startDetection, s as processFace, t as FaceDetectionProvider, u as FACE_ERROR_CODES } from "./FaceDetectionProvider-CAY43vSI.esm.js";
+import { t as StreamCanvasProcessingSession } from "./StreamCanvasProcessingSession-CBnbTnOr.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-DS1oDiUq.esm.js";
 import { n as getWindowDimensions } from "./getDeviceClass-CeBiEayS.esm.js";
-import { t as getFaceErrorCodeFromUnknown } from "./selfieErrorUtils-BY0-YbPW.esm.js";
-import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-BGsG2OAs.esm.js";
+import { t as getFaceErrorCodeFromUnknown } from "./selfieErrorUtils-f4MgAG2A.esm.js";
+import { n as DEFAULT_ID_CAPTURE_THRESHOLDS, r as IdCaptureProvider, t as DEFAULT_ID_CAPTURE_GEOMETRY } from "./idCaptureDefaults-Dszuq9ng.esm.js";
 import { t as StreamCanvasCapture } from "./StreamCanvasCapture-C9jtgBdT.esm.js";
 //#region src/modules/video-selfie/videoSelfieCompareService.ts
 async function postVideoSelfieCompare(endpoint, base64Image) {
@@ -23,6 +23,14 @@ const compareVideoSelfieBackId = (base64Image) => postVideoSelfieCompare(endpoin
 /** Compare OCR from a back-ID frame against the captured ID's OCR. */
 const compareVideoSelfieBackOcr = (base64Image) => postVideoSelfieCompare(endpoints.videoSelfieCompareBackOcr, base64Image);
 //#endregion
+//#region src/modules/video-selfie/videoSelfieErrors.ts
+/** HTTP transport failures, rather than backend validation verdicts. */
+function isConnectionError(error) {
+	if (typeof error !== "object" || error === null || !("status" in error)) return false;
+	const status = error.status;
+	return typeof status === "number" && (status === 0 || status === 408 || status === 429 || status >= 500);
+}
+//#endregion
 //#region src/modules/video-selfie/videoSelfieStepDetector.ts
 /** Default autocapture window for the selfie step when the config omits one. */
 const SELFIE_AUTOCAPTURE_MS = 1e4;
@@ -95,17 +103,6 @@ function isSelfieValidationError(error) {
 const SELFIE_SUBMIT_ATTEMPTS = 3;
 const SELFIE_SUBMIT_BACKOFF_MS = 2e3;
 /**
-* True for HTTP-transport-shaped failures — network error / client-side
-* timeout (status 0), 408, 429, 5xx — as opposed to a backend verdict.
-* Plain Errors (aborts, programming faults) are not connection errors.
-*/
-function isConnectionError(error) {
-	if (typeof error !== "object" || error === null || !("status" in error)) return false;
-	const status = error.status;
-	if (typeof status !== "number") return false;
-	return status === 0 || status === 408 || status === 429 || status >= 500;
-}
-/**
 * True for errors where the selfie submission never got a meaningful backend
 * verdict, as opposed to a validation outcome. Re-sending the same payload
 * can succeed, so these are retried in place instead of failing the whole
@@ -508,4 +505,4 @@ function createVideoSelfieCameraWarmer(config, steps = resolveVideoSelfieSteps(c
 	};
 }
 //#endregion
-export { isConnectionError as a, delay as i, defaultAcquireCamera as n, isSelfieValidationError as o, createDefaultStepDetector as r, isWrongVideoSelfieIdSide as s, createVideoSelfieCameraWarmer as t };
+export { isSelfieValidationError as a, delay as i, defaultAcquireCamera as n, isWrongVideoSelfieIdSide as o, createDefaultStepDetector as r, isConnectionError as s, createVideoSelfieCameraWarmer as t };

package/dist/{videoSelfieStepDetector-CGsTltqB.d.ts → videoSelfieStepDetector-Dv3Mgws-.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-CRaFu6wS.js";
+import "./IWasmUtilCapability-Cqiaxydi.js";
+import { n as DetectionStatus } from "./types-BEVHQbbC.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/virtualCameraCheck-eFOm2C9q.esm.js

@@ -0,0 +1,27 @@
+//#region src/internal/virtualCameraCheck.ts
+const frameSources = {
+	front: "FRONT_ID",
+	back: "BACK_ID",
+	selfie: "SELFIE"
+};
+/**
+* Runs the native post-capture check (`poc`).
+*
+* Since ml-wasm-kit v2.14.53 (ADR 0008, single-run IAD) the binding keeps its
+* output argument for arity but never writes into it: the post-capture
+* verdicts travel only inside the signed capture metadata that the protected
+* upload carries. The JavaScript verdict this function used to derive from
+* that output — the `/omni/log/frame/v2` frame upload, the
+* `virtualCameraDetected` device stat and `setZc` — is gone with it (the same
+* removal ms-incodesmile-web made in ENG-58409). The name is kept so the
+* protected attempts' POC step reads the same.
+*/
+async function runVirtualCameraCheck({ wasmUtil }) {
+	await wasmUtil.poc({
+		canvas: null,
+		itr: null,
+		skipped: null
+	});
+}
+//#endregion
+export { runVirtualCameraCheck as n, frameSources as t };

package/dist/{warmup-BElYWRh7.esm.js → warmup-DtB0DJpl.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-BDrax6Eu.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;
@@ -577,25 +637,32 @@ var WasmRuntime = class WasmRuntime {
 		let cleanupFailure = null;
 		try {
 			if (pipelines === null) throw new Error(message);
-			for (const [type, modelsPaths] of pipelines) {
+			const downloads = /* @__PURE__ */ new Map();
+			const loadModel = (path) => {
+				const resolvedSource = this.resolveModelSource(isWasmModelEntry(path) ? path.source : path);
+				const loaded = this.loadedModels.get(resolvedSource);
+				if (loaded) return Promise.resolve(loaded);
+				let download = downloads.get(resolvedSource);
+				if (!download) {
+					download = resolveWasmSource(resolvedSource, {
+						kind: "model",
+						file: isWasmModelEntry(path) ? path.file : void 0
+					}).then((model) => {
+						this.loadedModels.set(resolvedSource, model);
+						return model;
+					});
+					downloads.set(resolvedSource, download);
+				}
+				return download;
+			};
+			const pipelineModels = await Promise.all(Array.from(pipelines, async ([type, modelsPaths]) => {
+				return [type, await Promise.all(modelsPaths.map(loadModel))];
+			}));
+			for (const [type, pipelineBuffers] of pipelineModels) {
 				const wasmType = this.pipelineTypeToWasmEnum(type);
-				const pipelineBuffers = [];
 				const sizes = new (this.requireWasmModule(message)).VectorInt();
 				sizeVectors.push(sizes);
-				for (const path of modelsPaths) {
-					const file = isWasmModelEntry(path) ? path.file : void 0;
-					const resolvedSource = this.resolveModelSource(isWasmModelEntry(path) ? path.source : path);
-					let model = this.loadedModels.get(resolvedSource);
-					if (!model) {
-						model = await resolveWasmSource(resolvedSource, {
-							kind: "model",
-							file
-						});
-						this.loadedModels.set(resolvedSource, model);
-					}
-					sizes.push_back(model.byteLength);
-					pipelineBuffers.push(model);
-				}
+				for (const model of pipelineBuffers) sizes.push_back(model.byteLength);
 				buffSizes.set(wasmType, sizes);
 				modelData.set(wasmType, pipelineBuffers);
 			}
@@ -641,8 +708,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 +790,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 +895,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 +925,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 +1127,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 +1207,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 +1224,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-BDrax6Eu.esm.js";
+import { s as warmupWasm } from "./warmup-DtB0DJpl.esm.js";
+import { a as resolveWasmConfigForPipelines, c as upgradeToWasmHttpClient, n as initializeWasmUtil, o as setWasmConfig, t as ensureWasmPipelines } from "./setup-DDahygZs.esm.js";
 //#region src/defineWasm.ts
 function requiredModels(pipelines) {
 	const models = /* @__PURE__ */ new Set();

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

@@ -1,4 +1,4 @@
-import { i as utilityWasmApi } from "./WasmUtilProvider-DtJuBdt-.esm.js";
+import { i as utilityWasmApi } from "./WasmUtilProvider-Dp2V-Uct.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 };