@incodetech/core 2.4.0 → 2.4.1-agentic.1

package/dist/{FaceDetectionProvider-DcPOC2gS.esm.js → FaceDetectionProvider-CAY43vSI.esm.js}

@@ -1,17 +1,15 @@
-import { c as wasmRuntime } from "./warmup-BElYWRh7.esm.js";
-import { t as ensureWasmPipelines } from "./setup-BInNAvQw.esm.js";
-import { r as BaseWasmProvider } from "./WasmUtilProvider-DtJuBdt-.esm.js";
-import { t as api, u as endpoints } from "./api-Cz90EHyu.esm.js";
-import { l as trueSightHintTransition, r as noteTrueSightCaptureActivity } from "./trueSightService-BMT-TubT.esm.js";
-import "./sessionInitializer-BTjYgE-V.esm.js";
-import { t as addDeviceStats } from "./stats-BEvexnKC.esm.js";
-import { c as isIPhone14OrHigher, i as isDesktop } from "./platform-DkcRc9JV.esm.js";
-import { i as requestCameraAccess, o as stopCameraStream, r as getCameraReacquisitionConstraints } from "./camera-sIa9ceW2.esm.js";
+import { l as wasmRuntime } from "./warmup-DtB0DJpl.esm.js";
+import { t as ensureWasmPipelines } from "./setup-DDahygZs.esm.js";
+import { r as BaseWasmProvider } from "./WasmUtilProvider-Dp2V-Uct.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
+import { l as trueSightHintTransition, r as noteTrueSightCaptureActivity } from "./trueSightService-GuLthUVK.esm.js";
+import "./sessionInitializer-DsL7X2j9.esm.js";
+import { t as addDeviceStats } from "./stats-CatA2dea.esm.js";
 import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
-import { o as StreamCanvasProcessingSession } from "./multipartRecordingService-CLwrF5wD.esm.js";
-import { i as hasBackCamera, n as getBackCameraStream, r as getDesktopCameraStream, t as ensureFrontCameraStream } from "./backCameraStream-CMvXj4X4.esm.js";
-import "./deepsightService-CKTYDIXD.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-bsWdEDxP.esm.js";
+import { t as StreamCanvasProcessingSession } from "./StreamCanvasProcessingSession-CBnbTnOr.esm.js";
+import { r as hasBackCamera } from "./backCameraStream-DS1oDiUq.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-DoIWuKI8.esm.js";
+import { n as saveProcessFaceMatch } from "./processFaceMatch-Bst83HaS.esm.js";
 //#region src/internal/faceCapture/onDeviceFaceResults.ts
 /**
 * On-device still-face capture is owned by the protected camera-cycle actor.
@@ -126,64 +124,30 @@ const getFaceErrorCodeFromHttpError = (error) => {
 	return getFaceUploadErrorCode(err.status, typeof err.data?.status === "number" ? err.data.status : void 0);
 };
 async function processFace(imageType = "selfie", signal) {
-	return (await api.post(endpoints.processFace, {}, {
+	const response = await api.post(endpoints.processFace, {}, {
 		query: { imageType },
 		signal
-	})).data;
+	});
+	if (imageType === "selfie") saveProcessFaceMatch(response.data?.success);
+	return response.data;
 }
 //#endregion
 //#region src/internal/faceCapture/faceCaptureServices.ts
 function sendLabelInspectionEvent() {
 	return addDeviceStats({ cameraLabelInspectionStatus: "FAIL" });
 }
-const MOBILE_SELFIE_CONSTRAINTS = {
-	video: {
-		facingMode: "user",
-		height: { ideal: 480 },
-		width: { ideal: 640 }
-	},
-	audio: false
-};
-const IPHONE14_SELFIE_CONSTRAINTS = {
-	video: { height: { ideal: 1080 } },
-	audio: false
-};
-function buildCameraConstraints(resolution, deviceId) {
-	if (resolution) return {
-		video: {
-			facingMode: "user",
-			deviceId: deviceId ? { exact: deviceId } : void 0,
-			height: resolution.height ? { ideal: resolution.height } : void 0,
-			width: resolution.width ? { ideal: resolution.width } : void 0
-		},
-		audio: false
-	};
-	if (isIPhone14OrHigher()) return IPHONE14_SELFIE_CONSTRAINTS;
-	return MOBILE_SELFIE_CONSTRAINTS;
-}
-function stopStream(stream) {
-	stopCameraStream(stream);
-}
-async function getFrontCameraStream(resolution) {
-	if (isDesktop()) {
-		if (resolution) return ensureFrontCameraStream((deviceId) => requestCameraAccess(buildCameraConstraints(resolution, deviceId)));
-		return ensureFrontCameraStream((deviceId) => getDesktopCameraStream(deviceId ? { deviceId } : {}));
-	}
-	return requestCameraAccess(resolution ? buildCameraConstraints(resolution) : buildCameraConstraints());
-}
-async function initializeCamera(params) {
-	const { config } = params;
+/**
+* Camera-free preparation for one protected face attempt: warms the WASM
+* pipeline the attempt will run and decides which lens to request. Since
+* ml-wasm-kit v2.14.52 the kit acquires the camera itself inside the
+* protected camera step (`ICameraCycleCapability.startCameraCycle`), so no
+* camera opens here. Runs once per
+* attempt — from the tutorial pre-acquire when there is one, otherwise at
+* attempt start.
+*/
+async function probeFaceCamera(config) {
 	await ensureWasmPipelines([isOnDeviceMode(config) ? "onDeviceSelfie" : "selfie"]);
-	const usingBackCamera = config.assistedOnboarding === true && await hasBackCamera();
-	const backCamera = usingBackCamera ? await getBackCameraStream() : void 0;
-	const stream = backCamera?.stream ?? await getFrontCameraStream(config.cameraResolution);
-	const constraints = getCameraReacquisitionConstraints(stream.getVideoTracks()[0], backCamera?.constraints);
-	return {
-		stream,
-		provider: params.provider,
-		usingBackCamera,
-		constraints
-	};
+	return { usingBackCamera: config.assistedOnboarding === true && await hasBackCamera() };
 }
 /**
 * Encrypts the provided selfie image using WASM.
@@ -271,7 +235,7 @@ function startDetection(params) {
 	};
 }
 async function initializeDeepsightSession(options) {
-	const { loadDeepsightSession } = await import("./deepsightLoader-DeNvGU3c.esm.js");
+	const { loadDeepsightSession } = await import("./deepsightLoader-B7DEYoyY.esm.js");
 	return loadDeepsightSession({
 		ds: options.ds,
 		storage: options.storage
@@ -543,4 +507,4 @@ var FaceDetectionProvider = class extends BaseWasmProvider {
 	}
 };
 //#endregion
-export { sendLabelInspectionEvent as a, processFace as c, FACE_ERROR_CODES as d, isOnDeviceMode as f, initializeDeepsightSession as i, uploadSelfie as l, encryptSelfieImage as n, startDetection as o, initializeCamera as r, stopStream as s, FaceDetectionProvider as t, getFaceUploadErrorCode as u };
+export { sendLabelInspectionEvent as a, uploadSelfie as c, isOnDeviceMode as d, probeFaceCamera as i, getFaceUploadErrorCode as l, encryptSelfieImage as n, startDetection as o, initializeDeepsightSession as r, processFace as s, FaceDetectionProvider as t, FACE_ERROR_CODES as u };

package/dist/IBrowserEnvironmentCapability-D7JG7ML3.esm.js

@@ -0,0 +1,16 @@
+//#region ../infra/src/capabilities/IBrowserEnvironmentCapability.ts
+function getTimestamp() {
+	return Date.now();
+}
+/** Today in the user's calendar, as an ISO `YYYY-MM-DD` date. */
+function getLocalIsoDate() {
+	const now = /* @__PURE__ */ new Date();
+	const month = String(now.getMonth() + 1).padStart(2, "0");
+	const day = String(now.getDate()).padStart(2, "0");
+	return `${now.getFullYear()}-${month}-${day}`;
+}
+function revokeObjectURL(url) {
+	URL.revokeObjectURL(url);
+}
+//#endregion
+export { getTimestamp as n, revokeObjectURL as r, getLocalIsoDate as t };

package/dist/IGeolocationCapability-r49Qo7rR.d.ts

@@ -0,0 +1,10 @@
+//#region ../infra/src/capabilities/IGeolocationCapability.d.ts
+type GeolocationCoords = {
+  latitude: number;
+  longitude: number;
+};
+type IGeolocationCapability = {
+  getCurrentPosition(): Promise<GeolocationCoords>;
+};
+//#endregion
+export { IGeolocationCapability as n, GeolocationCoords as t };

package/dist/{IWasmUtilCapability-GF2n7sfm.d.ts → IWasmUtilCapability-Cqiaxydi.d.ts}

@@ -33,6 +33,12 @@ interface IStorageCapability {
 type WasmUtilConfig = MLProviderConfig & {
   pipelines?: WasmPipeline[];
 };
+/**
+ * Output object handed to {@link IWasmUtilCapability.poc}. Since ml-wasm-kit
+ * v2.14.53 the native check writes nothing into it (`itr` and `skipped` stay
+ * as the caller left them): the post-capture verdicts travel only in the
+ * signed capture metadata. Kept for the binding's arity.
+ */
 type VirtualCameraCheckOutput = {
   canvas: HTMLCanvasElement | null;
   itr: boolean | null;
@@ -66,6 +72,11 @@ type IWasmUtilCapability = {
   setBrowserInfo(browserInfo: object, overrideExisting?: boolean): void;
   setCameraInfo(cameraInfo: object, overrideExisting?: boolean): void;
   setMotionStatus(status: string): void;
+  /**
+   * @deprecated Native-free no-op since ml-wasm-kit v2.14.54, which removed
+   * the binding: the kit's own visibility observers record background time.
+   * Scheduled for removal in 3.0.0.
+   */
   setBackgroundMode(backgroundMode: boolean): void;
   /**
    * @deprecated Compatibility-only no-op since ml-wasm-kit v2.14.49-post1.
@@ -77,6 +88,11 @@ type IWasmUtilCapability = {
    * for client-side gating.
    */
   setOnDeviceMode(enabled: boolean): void;
+  /**
+   * @deprecated Native-free no-op since ml-wasm-kit v2.14.54, which removed
+   * the binding: the zoom check is gone and `iad.zc` is the constant `PASS`.
+   * Scheduled for removal in 3.0.0.
+   */
   setZc(zc: string): void;
   setInspectorOpened(opened: boolean): void;
   /**
@@ -112,18 +128,29 @@ type IWasmUtilCapability = {
   getCheck(): string;
   /**
    * Gets the current pipeline state. Must be called before setMotionStatus(),
-   * getCheck(), setBackgroundMode(), and getMetadata() for proper metadata generation.
+   * getCheck(), and getMetadata() for proper metadata generation.
    */
   getPipelineState(): string;
   estimatePerformance(): string;
   /**
    * @deprecated Returns `false` for compatibility; scheduled for removal in
-   * 3.0.0. Protected PRC/POC is the authoritative virtual-camera decision
-   * path: use {@link IWasmUtilCapability.prc} followed by
-   * {@link IWasmUtilCapability.poc} instead of inspecting the track label.
+   * 3.0.0. The protected camera step (`ICameraCycleCapability.startCameraCycle`)
+   * runs the pre-capture checks and the signed capture metadata carries the
+   * verdicts; nothing is decided from the track label.
    */
   isVirtualCamera(label: string | null): boolean;
+  /**
+   * @deprecated Resolves without doing anything since ml-wasm-kit v2.14.52,
+   * which removed the binding: the pre-capture check runs inside the protected
+   * camera step (`ICameraCycleCapability.startCameraCycle`), so a `prc()` then
+   * `poc()` sequence keeps working. Scheduled for removal in 3.0.0.
+   */
   prc(): Promise<void>;
+  /**
+   * Runs the native post-capture check. `output` is kept for the binding's
+   * arity and is not written since ml-wasm-kit v2.14.53 — see
+   * {@link VirtualCameraCheckOutput}.
+   */
   poc(output: VirtualCameraCheckOutput): Promise<void>;
   rsp(): Promise<void>;
   ssl(): void;

package/dist/MultipartRecordingProvider-D9mauUdS.esm.js

@@ -0,0 +1,146 @@
+import { n as getMultipartRecorderMimeType } from "./mediaRecorderOptions-B9-IEVtV.esm.js";
+//#region ../infra/src/providers/browser/MultipartRecordingProvider.ts
+/**
+* How often `MediaRecorder` hands us buffered data (incremental blobs).
+* 500 ms keeps each blob — and therefore each upload chunk — small: less
+* tail lost when a session is interrupted, and a smaller first blob (init
+* header + keyframe), which is the largest and most timeout-prone chunk.
+* Not lower: request rate doubles per halving, and browsers stop honoring
+* very small timeslices reliably.
+*/
+const TIMESLICE_MS = 500;
+/**
+* Encoder target for the full video-selfie session. Higher than the
+* short-clip liveness path (0.5–1 Mbps) so a multi-minute session keeps
+* usable quality. It's a ceiling — a still scene still encodes well below it.
+*/
+const VIDEO_BITS_PER_SECOND = 25e5;
+/**
+* Records a stream and emits every `MediaRecorder` timeslice blob as its own
+* part, in order. Each blob is a whole container fragment (WebM cluster /
+* fMP4 `moof`+`mdat`), which is the property the video-selfie-service's
+* gap-splicing depends on — parts must never cut a fragment at a byte
+* offset. The service stages sub-5 MiB chunks and combines them server-side,
+* so emitting the smallest whole-fragment unit (~0.5 s of video) maximizes
+* what an interrupted session can salvage.
+*
+* Page-lifecycle orchestration lives in Core: it pauses this recorder before a
+* backgrounded camera can stall, restores the camera/compositor, and only then
+* resumes this same media container.
+*/
+var MultipartRecordingProvider = class {
+	constructor() {
+		this.mediaRecorder = null;
+		this._isRecording = false;
+		this._hasError = false;
+		this._error = null;
+		this.mimeType = "";
+		this.partNumber = 0;
+		this.onPart = null;
+	}
+	get isRecording() {
+		return this._isRecording;
+	}
+	get hasError() {
+		return this._hasError;
+	}
+	get error() {
+		return this._error;
+	}
+	startRecording(stream, onPart) {
+		this.reset();
+		this.partNumber = 0;
+		this.onPart = onPart;
+		try {
+			this.mimeType = getMultipartRecorderMimeType();
+			const recorder = new MediaRecorder(stream.clone(), {
+				mimeType: this.mimeType,
+				videoBitsPerSecond: VIDEO_BITS_PER_SECOND
+			});
+			recorder.ondataavailable = (event) => {
+				if (event.data.size > 0 && this.onPart) {
+					this.partNumber += 1;
+					this.onPart({
+						chunk: event.data,
+						partNumber: this.partNumber
+					});
+				}
+			};
+			recorder.onerror = (event) => {
+				const detail = event instanceof ErrorEvent && event.error instanceof Error ? event.error.message : event.type;
+				this._error = `Recording error: ${detail}`;
+				this._isRecording = false;
+				this._hasError = true;
+			};
+			recorder.start(TIMESLICE_MS);
+			this.mediaRecorder = recorder;
+			this._isRecording = true;
+			this._error = null;
+			this._hasError = false;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to start recording: ${detail}`;
+			this._hasError = true;
+		}
+	}
+	pauseRecording() {
+		const recorder = this.mediaRecorder;
+		if (!recorder || !this._isRecording || this._hasError) return false;
+		if (recorder.state === "paused") return true;
+		if (recorder.state !== "recording") return false;
+		try {
+			recorder.pause();
+			return true;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to pause recording: ${detail}`;
+			this._hasError = true;
+			return false;
+		}
+	}
+	resumeRecording() {
+		const recorder = this.mediaRecorder;
+		if (!recorder || !this._isRecording || this._hasError) return false;
+		if (recorder.state === "recording") return true;
+		if (recorder.state !== "paused") return false;
+		try {
+			recorder.resume();
+			return true;
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			this._error = `Failed to resume recording: ${detail}`;
+			this._hasError = true;
+			return false;
+		}
+	}
+	stopRecording() {
+		const recorder = this.mediaRecorder;
+		return new Promise((resolve) => {
+			if (recorder && this._isRecording) {
+				recorder.onstop = () => {
+					resolve();
+				};
+				recorder.stop();
+				this._isRecording = false;
+			} else resolve();
+			recorder?.stream?.getTracks().forEach((track) => track.stop());
+		});
+	}
+	reset() {
+		const recorder = this.mediaRecorder;
+		if (recorder) {
+			recorder.ondataavailable = null;
+			recorder.onerror = null;
+			recorder.onstop = null;
+			if (recorder.state !== "inactive") recorder.stop();
+			recorder.stream.getTracks().forEach((track) => track.stop());
+			this.mediaRecorder = null;
+		}
+		this.onPart = null;
+		this._isRecording = false;
+		this._error = null;
+		this._hasError = false;
+	}
+};
+//#endregion
+export { MultipartRecordingProvider as t };

package/dist/{PhoneValidationProvider-SZiOS0jB.esm.js → PhoneValidationProvider-Co4zk2en.esm.js}

@@ -9859,6 +9859,13 @@ var PhoneValidationProvider = class {
 		} catch {}
 		return null;
 	}
+	nationalNumber(phone, country) {
+		try {
+			return parsePhoneNumber(phone, country)?.nationalNumber ?? null;
+		} catch {
+			return null;
+		}
+	}
 };
 //#endregion
 export { metadata_min_json_default as C, withMetadataArgument as S, VALID_PUNCTUATION as _, PhoneNumber as a, getCountryCallingCode as b, applyInternationalSeparatorStyle as c, getCountryByCallingCode as d, getCountryByNationalNumber as f, VALID_DIGITS as g, PLUS_CHARS as h, parseDigits as i, extractCountryCallingCode as l, stripIddPrefix as m, PhoneValidationProvider_exports as n, FIRST_GROUP_PATTERN as o, extractNationalNumberFromPossiblyIncompleteNumber as p, parsePhoneNumber as r, formatNationalNumberUsingFormat as s, PhoneValidationProvider as t, extractCountryCallingCodeFromInternationalNumberWithoutPlusSign as u, checkNumberLength as v, isObject as x, Metadata as y };

package/dist/{StreamCanvasCapture-7JRf-2ck.d.ts → StreamCanvasCapture-C3xNfOsv.d.ts}

@@ -1,5 +1,5 @@
 import { y as IncodeCanvas } from "./createFaceAvatar-lYX0VTYs.js";
-import "./IWasmUtilCapability-GF2n7sfm.js";
+import "./IWasmUtilCapability-Cqiaxydi.js";
 import { t as CameraStream } from "./camera-9wWD-pwg.js";
 //#region ../infra/src/capabilities/IMotionSensorCapability.d.ts
 type MotionStatus = 'PASS' | 'FAIL' | 'UNCLEAR';
@@ -12,6 +12,11 @@ type MetadataService = {
   checkForVirtualCameraByLabel(videoTrack: MediaStreamTrack | null): Promise<boolean>;
   analyzeFrame(imageData: ImageData): Promise<void>;
   setMotionStatus(status: string): void;
+  /**
+   * @deprecated No-op since ml-wasm-kit v2.14.54 removed `setBackgroundMode`:
+   * the kit's own visibility observers record background time in the capture
+   * metadata. Scheduled for removal in 3.0.0.
+   */
   setBackgroundMode(backgroundMode: boolean): void;
   estimatePerformance(): string;
   getMetadata(): string;
@@ -19,7 +24,7 @@ type MetadataService = {
   getPipelineState(): string;
   /**
    * Prepares pipeline state for metadata collection.
-   * Must be called before setMotionStatus, getCheck, setBackgroundMode, and getMetadata.
+   * Must be called before setMotionStatus, getCheck, and getMetadata.
    */
   preparePipelineState(): void;
 };
@@ -53,7 +58,11 @@ type DeepsightService = {
   checkVirtualCamera(videoTrack: MediaStreamTrack): Promise<boolean>;
   performVirtualCameraCheck(sessionToken: string | null, source: FrameSource): Promise<void>;
   /**
-   * Runs PRC warmup and stores DS flag using infrastructure providers.
+   * @deprecated No-op since ml-wasm-kit v2.14.52 removed `prc`: the
+   * pre-capture check runs inside the protected camera step
+   * (`ICameraCycleCapability.startCameraCycle`) that the protected attempt
+   * drives, and there is no stand-alone warm-up any more. Scheduled for
+   * removal in 3.0.0.
    */
   performPrcCheck(params: DeepsightPrcCheckParams): Promise<void>;
   analyzeFrame(imageData: ImageData): Promise<void>;

package/dist/StreamCanvasProcessingSession-CBnbTnOr.esm.js

@@ -0,0 +1,42 @@
+//#region ../infra/src/media/StreamCanvasProcessingSession.ts
+var StreamCanvasProcessingSession = class {
+	/**
+	* Creates a processing session that reacts to `StreamCanvasCapture` frame events
+	* and drives a provider's `processFrame()` method with backpressure.
+	*/
+	constructor(params) {
+		this.disposed = false;
+		this.isProcessing = false;
+		this.onFrameEvent = () => {
+			if (this.disposed || this.isProcessing) return;
+			const frame = this.capturer.getLatestFrame();
+			if (!frame) return;
+			this.onFrame?.(frame);
+			this.isProcessing = true;
+			this.provider.processFrame(frame).catch(() => {}).finally(() => {
+				this.isProcessing = false;
+			});
+		};
+		this.capturer = params.capturer;
+		this.provider = params.provider;
+		this.onFrame = params.onFrame;
+		this.capturer.addEventListener("frame", this.onFrameEvent);
+	}
+	/**
+	* Unsubscribes from frame events and resets the provider.
+	*/
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.capturer.removeEventListener("frame", this.onFrameEvent);
+		this.provider.reset();
+	}
+	/**
+	* Returns whether the session has been disposed.
+	*/
+	isDisposed() {
+		return this.disposed;
+	}
+};
+//#endregion
+export { StreamCanvasProcessingSession as t };

package/dist/{WasmUtilProvider-DtJuBdt-.esm.js → WasmUtilProvider-Dp2V-Uct.esm.js}

@@ -1,6 +1,6 @@
 import { n as __exportAll } from "./rolldown-runtime-B-1-B7_t.esm.js";
-import { c as wasmCallWrapper, d as noteUnlockedCallStart, s as ML_CALL_MAX_POLLS, u as noteUnlockedCallEnd } from "./wasmWebClient-BjZw_7OB.esm.js";
-import { c as wasmRuntime, i as isWasmReady, o as waitForWasm, r as getWasmStatus, s as warmupWasm } from "./warmup-BElYWRh7.esm.js";
+import { c as wasmCallWrapper, d as noteUnlockedCallStart, s as ML_CALL_MAX_POLLS, u as noteUnlockedCallEnd } from "./wasmWebClient-BDrax6Eu.esm.js";
+import { i as isWasmReady, l as wasmRuntime, o as waitForWasm, r as getWasmStatus, s as warmupWasm } from "./warmup-DtB0DJpl.esm.js";
 //#region ../infra/src/wasm/utilityWasmApi.ts
 /**
 * Utility / metadata domain facade over {@link WasmRuntime}.
@@ -10,7 +10,8 @@ import { c as wasmRuntime, i as isWasmReady, o as waitForWasm, r as getWasmStatu
 * persist and that must be replayed into it at call time —
 *
 * - `dsEnabled_` (deepsight) is passed as an argument on every
-*   `prc`/`poc`/`rsp`/`ssl` call;
+*   `poc`/`rsp`/`ssl` call, and read back through {@link getDsEnabled} by
+*   `CameraCycleProvider` for the camera step's `ds` option;
 * - `inspectorOpened_` is pushed into C++ inside {@link getMetadata}, right
 *   before reading the metadata, because `setInspectorOpened` may legitimately be
 *   called before WASM is initialized.
@@ -21,10 +22,24 @@ import { c as wasmRuntime, i as isWasmReady, o as waitForWasm, r as getWasmStatu
 * `fpPrefetch_` is a third, derived piece of JS state: the memoized `ppf` poll
 * that `getFPData` awaits, keyed by the embind handle it was started on.
 *
-* `prc`/`poc`/`rsp` are the only methods here that hold the ML semaphore.
+* `poc`/`rsp` are the only methods here that hold the ML semaphore (the camera
+* step's `cst` holds it from `WasmRuntime`).
 * `ssl`/`stl`/`osv`/`oev`/`ckvcks`/`sbc`/`ppf` and everything else are unlocked **by design**
 * (decision D6) — never add locking.
 *
+* Three members are deprecated native-free shims for bindings ml-wasm-kit
+* deleted: `prc` (v2.14.52) rejects with a fixed error; `setZc` and
+* `setBackgroundMode` (v2.14.54) are no-ops. `WasmUtilProvider` is public
+* (`@incodetech/core/extensibility`) and `major` changesets are forbidden, so
+* they follow the `isVirtualCamera` / `processPhoto` precedent until 3.0.0.
+*
+* `smv` (restored in ml-wasm-kit v2.14.54-pre5; `true` selects v2 since pre6)
+* is guarded like upstream but routes through `WasmRuntime.setMetadataV2Enabled`,
+* which latches the
+* selection and replays it after every `initialize()` — the kit keeps it as
+* realm state (ADR 0009 §6). The SDK-facing unguarded entry is
+* `wasmMetadataVersionSync.ts`.
+*
 * Method names, argument order and the pre-initialization error strings are
 * copied verbatim from the mirrored upstream `wasmApi.ts` so a WASM version bump
 * stays a diff against upstream (`docs/processes/WASM_VERSION_MIGRATION.md`).
@@ -58,8 +73,9 @@ var UtilityWasmApi = class {
 	}
 	/**
 	* @deprecated Native label inspection has been unavailable since
-	* v2.14.49-post1; scheduled for removal in 3.0.0. Protected PRC/POC owns
-	* the authoritative decision: use `prc()` followed by `poc()` instead.
+	* v2.14.49-post1; scheduled for removal in 3.0.0. The protected camera step
+	* (`ICameraCycleCapability.startCameraCycle`) runs the pre-capture checks
+	* and the signed capture metadata carries the verdicts.
 	*/
 	isVirtualCamera(_label) {
 		return false;
@@ -105,9 +121,12 @@ var UtilityWasmApi = class {
 	setCameraInfo(cameraInfo, overrideExisting = true) {
 		this.runtime.requireUtilityApi("Unable to set camera info, cpp API hasn't been initialized").setCameraInfo(cameraInfo, overrideExisting);
 	}
-	setZc(zc) {
-		this.runtime.requireUtilityApi("Unable to set zc, cpp API hasn't been initialized").setZc(zc);
-	}
+	/**
+	* @deprecated Native-free no-op. ml-wasm-kit v2.14.54 removed `setZc`: the
+	* zoom check is gone and `iad.zc` is the constant `PASS` in the capture
+	* metadata. Scheduled for removal in 3.0.0.
+	*/
+	setZc(_zc) {}
 	setMotionStatus(motionStatus) {
 		this.runtime.requireUtilityApi("Unable to set motion status, cpp API hasn't been initialized").setMotionStatus(motionStatus);
 	}
@@ -117,12 +136,19 @@ var UtilityWasmApi = class {
 	getInspectorOpened() {
 		return this.inspectorOpened_;
 	}
-	setBackgroundMode(backgroundMode) {
-		this.runtime.requireUtilityApi("Unable to set background mode, cpp API hasn't been initialized").setBackgroundMode(backgroundMode);
-	}
+	/**
+	* @deprecated Native-free no-op. ml-wasm-kit v2.14.54 removed
+	* `setBackgroundMode`: the kit's own visibility observers record background
+	* time. Scheduled for removal in 3.0.0.
+	*/
+	setBackgroundMode(_backgroundMode) {}
 	setDsEnabled(enabled) {
 		this.dsEnabled_ = enabled;
 	}
+	/** The JS-side deepsight flag, for callers that replay it into the kit themselves. */
+	getDsEnabled() {
+		return this.dsEnabled_;
+	}
 	getCheck() {
 		const utilityApi = this.runtime.requireUtilityApi("Unable to get check, cpp API hasn't been initialized");
 		noteUnlockedCallStart("getCheck");
@@ -146,6 +172,16 @@ var UtilityWasmApi = class {
 		this.runtime.requireUtilityApi("Unable to sbc, cpp API hasn't been initialized").sbc(enabled);
 	}
 	/**
+	* Capture-metadata format selector (`smv`, ml-wasm-kit v2.14.54-pre6):
+	* `true` selects the v2 document, `false` the v1 document (the module
+	* default). Guarded like upstream; the selection is latched on the runtime
+	* so it survives re-initialization (ADR 0009 §6).
+	*/
+	smv(enabled) {
+		this.runtime.requireUtilityApi("Unable to smv, cpp API hasn't been initialized");
+		this.runtime.setMetadataV2Enabled(enabled);
+	}
+	/**
 	* Reads one fingerprint signal bucket (see {@link SignalDataType}), encrypted
 	* by the native module. Waits for the one-time async prefetch (`ppf`) first.
 	* An empty string means the bucket has no data.
@@ -184,13 +220,15 @@ var UtilityWasmApi = class {
 		});
 		return promise;
 	}
-	async prc() {
-		const message = "Unable to prc, cpp API hasn't been initialized";
-		this.runtime.requireUtilityApi(message);
-		await wasmCallWrapper(this.runtime.mlCallSemaphore, () => this.runtime.requireUtilityApi(message).prc(this.dsEnabled_, false), true, {
-			maxPolls: ML_CALL_MAX_POLLS,
-			label: "prc"
-		});
+	/**
+	* @deprecated Resolves without doing anything. ml-wasm-kit v2.14.52 removed
+	* `prc`: the pre-capture check runs inside the protected camera step
+	* (`ICameraCycleCapability.startCameraCycle`), which holds the ML semaphore
+	* for it, so a caller that still awaits `prc()` before `poc()` loses
+	* nothing. Scheduled for removal in 3.0.0.
+	*/
+	prc() {
+		return Promise.resolve();
 	}
 	async poc(output) {
 		const message = "Unable to poc, cpp API hasn't been initialized";
@@ -272,6 +310,10 @@ var BaseWasmProvider = class {
 	*/
 	async initializeBase(config, pipeline) {
 		if (this._isInitialized) return;
+		if (this.pipelineType === void 0 && wasmRuntime.isInitialized()) {
+			this._isInitialized = true;
+			return;
+		}
 		const status = getWasmStatus();
 		if (status.isLoading || isWasmReady() || status.error) {
 			if (!(status.isLoading && status.loadedPipelines.includes(pipeline))) await waitForWasm();
@@ -385,15 +427,21 @@ var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
 		this.ensureInitialized();
 		utilityWasmApi.setMotionStatus(status);
 	}
+	/**
+	* @deprecated Native-free no-op since ml-wasm-kit v2.14.54; scheduled for
+	* removal in 3.0.0. Like the other shims it never requires initialization.
+	*/
 	setBackgroundMode(backgroundMode) {
-		this.ensureInitialized();
 		utilityWasmApi.setBackgroundMode(backgroundMode);
 	}
 	setOnDeviceMode(enabled) {
 		wasmRuntime.setOnDeviceMode(enabled);
 	}
+	/**
+	* @deprecated Native-free no-op since ml-wasm-kit v2.14.54; scheduled for
+	* removal in 3.0.0. Like the other shims it never requires initialization.
+	*/
 	setZc(zc) {
-		this.ensureInitialized();
 		utilityWasmApi.setZc(zc);
 	}
 	setInspectorOpened(opened) {
@@ -448,8 +496,13 @@ var WasmUtilProvider = class WasmUtilProvider extends BaseWasmProvider {
 	isVirtualCamera(label) {
 		return utilityWasmApi.isVirtualCamera(label);
 	}
+	/**
+	* @deprecated Resolves without doing anything since ml-wasm-kit v2.14.52:
+	* the pre-capture check runs inside the protected camera step, so existing
+	* `prc()` then `poc()` call sites keep working. Scheduled for removal in
+	* 3.0.0.
+	*/
 	async prc() {
-		this.ensureInitialized();
 		await utilityWasmApi.prc();
 	}
 	async poc(output) {