@incodetech/core 2.2.0 → 2.3.0-rc.0

package/dist/FaceDetectionProvider-DTetAE8H.esm.js

@@ -0,0 +1,476 @@
+import { t as ensureWasmPipelines } from "./setup-msLybMbC.esm.js";
+import { s as wasmRuntime } from "./warmup-CUUnwYxe.esm.js";
+import { i as BaseWasmProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { c as trueSightHintTransition, r as noteTrueSightCaptureActivity } from "./trueSightService-CKrrfV0Q.esm.js";
+import "./sessionInitializer-BLoK7SP9.esm.js";
+import { t as addDeviceStats } from "./stats-DkK-f8JT.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 { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
+import { a as StreamCanvasProcessingSession, n as startRecording, r as stopRecording$1, t as createRecordingSession } from "./recordingsRepository-CCWy13M-.esm.js";
+import { i as hasBackCamera, n as getBackCameraStream, r as getDesktopCameraStream, t as ensureFrontCameraStream } from "./backCameraStream-BOtyQowf.esm.js";
+//#region src/internal/faceCapture/onDeviceFaceResults.ts
+/**
+* On-device still-face capture is owned by the protected camera-cycle actor.
+* Core uses this guard only to select the backwards-compatible validation and
+* processing behavior after the native actor posts completion-only results.
+*/
+const isOnDeviceMode = (config) => config.onDeviceFaceResultsSubmissionEnabled === true;
+//#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;
+	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
+	};
+}
+/**
+* Encrypts the provided selfie image using WASM.
+*/
+async function encryptSelfieImage({ canvas, dependencies }) {
+	const base64Image = canvas.getBase64Image();
+	if (!base64Image) throw new Error("Canvas image is empty or null");
+	return (await dependencies.getWasmUtil()).encryptImage(base64Image);
+}
+function startDetection(params) {
+	let lastStatus;
+	let session;
+	const { provider } = params;
+	const setStatus = (status) => {
+		if (session?.isDisposed() === true) return;
+		if (lastStatus === status) return;
+		lastStatus = status;
+		trueSightHintTransition("module.face-capture", "faceScan", status);
+		params.onUpdate(status);
+	};
+	const stopDetectionLoop = () => {
+		session?.dispose();
+		noteTrueSightCaptureActivity(false);
+	};
+	const reset = () => {
+		provider.reset();
+	};
+	const cleanup = () => {
+		stopDetectionLoop();
+	};
+	(async () => {
+		try {
+			provider.setCallbacks({
+				onFarAway: () => setStatus("tooFar"),
+				onTooClose: () => setStatus("tooClose"),
+				onTooManyFaces: () => setStatus("tooManyFaces"),
+				onNoFace: () => setStatus("idle"),
+				onCenterFace: () => setStatus("centerFace"),
+				onGetReady: () => setStatus("getReady"),
+				onGetReadyFinished: () => setStatus("getReadyFinished"),
+				onDark: () => {
+					if (params.config.validateBrightness) setStatus("dark");
+				},
+				onBlur: () => setStatus("blur"),
+				onFaceAngle: () => setStatus("faceAngle"),
+				onLenses: () => {
+					if (params.config.validateLenses) setStatus("lenses");
+				},
+				onMask: () => {
+					if (params.config.validateFaceMask) setStatus("faceMask");
+				},
+				onEyesClosed: () => {
+					if (params.config.validateClosedEyes) setStatus("eyesClosed");
+				},
+				onHeadWear: () => {
+					if (params.config.validateHeadCover) setStatus("headWear");
+				},
+				onFaceOccluded: () => setStatus("faceOcclusion"),
+				onFaceData: params.onPose,
+				onSwitchToManualCapture: () => {
+					setStatus("manualCapture");
+					stopDetectionLoop();
+				},
+				onCapture: (canvas, faceCoordinates) => {
+					setStatus("success");
+					params.onSuccess(canvas, faceCoordinates);
+					cleanup();
+				}
+			});
+			setStatus("detecting");
+			session = new StreamCanvasProcessingSession({
+				capturer: params.capturer,
+				provider,
+				onFrame: params.onFrame
+			});
+			noteTrueSightCaptureActivity(true);
+		} catch {
+			setStatus("error");
+			cleanup();
+		}
+	})();
+	return {
+		cleanup,
+		reset
+	};
+}
+function buildResolutionFromStream(stream) {
+	const track = stream.getVideoTracks()[0];
+	if (!track) return;
+	const settings = track.getSettings();
+	const width = settings.width;
+	const height = settings.height;
+	if (typeof width === "number" && typeof height === "number") return `${width}x${height}`;
+}
+async function startRecordingSession(params) {
+	if (params.config.deepsightLiveness === "VIDEOLIVENESS") return;
+	if (params.config.enableFaceRecording !== true) return;
+	if (params.existing) return params.existing;
+	const provider = params.config.recording?.capability;
+	if (!provider) return;
+	const clonedStream = params.clonedStream;
+	const hasAudio = clonedStream.getAudioTracks().length > 0;
+	const resolution = buildResolutionFromStream(clonedStream);
+	const session = await createRecordingSession("selfie");
+	const connection = await provider.connect({
+		sessionToken: session.token,
+		stream: clonedStream,
+		events: {}
+	});
+	await startRecording({
+		videoRecordingId: session.videoRecordingId,
+		type: "selfie",
+		resolution,
+		hasAudio
+	});
+	return {
+		token: session.token,
+		sessionId: session.sessionId,
+		videoRecordingId: session.videoRecordingId,
+		connection,
+		resolution,
+		hasAudio
+	};
+}
+async function stopRecording(session) {
+	try {
+		await stopRecording$1(session.videoRecordingId);
+	} finally {
+		await session.connection.disconnect();
+	}
+}
+async function initializeDeepsightSession(options) {
+	const { loadDeepsightSession } = await import("./deepsightLoader-Dm7ejW4v.esm.js");
+	return loadDeepsightSession({
+		ds: options.ds,
+		storage: options.storage
+	});
+}
+//#endregion
+//#region ../infra/src/wasm/faceProcessingWasmApi.ts
+const PROCESS_PHOTO_UNSUPPORTED_ERROR = "[Incode SDK] processPhoto is unsupported since ml-wasm-kit v2.14.49-post1 and will be removed in 3.0.0. Use the protected camera cycle (captureProtectedFrame) for manual capture.";
+var FaceProcessingWasmApi = class {
+	constructor(runtime = wasmRuntime) {
+		this.runtime = runtime;
+	}
+	async setFacePositionConstraints(type, minX, minY, maxX, maxY) {
+		this.runtime.requireFaceProcessingApi("Unable to set face position constraints, cpp API hasn't been initialized").setFacePositionConstraints(this.runtime.pipelineTypeToWasmEnum(type), minX, minY, maxX, maxY);
+	}
+	async setFaceDetectionThresholds(type, brightnessThreshold, blurrinessThreshold, tiltRotationAngleThreshold, minMagicCropSize, autocaptureInterval, minFaceQualityScore, faceOcclusionThreshold, getReadyDelay, framesAggregationInterval, minFramesWithFace) {
+		this.runtime.requireFaceProcessingApi("Unable to set face detection thresholds, cpp API hasn't been initialized").setFaceProcessingThresholds(this.runtime.pipelineTypeToWasmEnum(type), brightnessThreshold, blurrinessThreshold, tiltRotationAngleThreshold, minMagicCropSize, autocaptureInterval, minFaceQualityScore, faceOcclusionThreshold, getReadyDelay, framesAggregationInterval, minFramesWithFace);
+	}
+	async setFaceAttributesThresholds(type, headwearThreshold, lensesThreshold, closedEyesThreshold, maskThreshold) {
+		this.runtime.requireFaceProcessingApi("Unable to set face attributes thresholds, cpp API hasn't been initialized").setFaceAttributesThresholds(this.runtime.pipelineTypeToWasmEnum(type), headwearThreshold, lensesThreshold, closedEyesThreshold, maskThreshold);
+	}
+	async setFaceChecksEnabled(type, isLensesCheckEnabled, isMaskCheckEnabled, isClosedEyesCheckEnabled, isHeadWearCheckEnabled, isOcclusionCheckEnabled) {
+		this.runtime.requireFaceProcessingApi("Unable to set face checks enabled flags, cpp API hasn't been initialized").setFaceChecksEnabled(this.runtime.pipelineTypeToWasmEnum(type), isLensesCheckEnabled, isMaskCheckEnabled, isClosedEyesCheckEnabled, isHeadWearCheckEnabled, isOcclusionCheckEnabled);
+	}
+	async setFaceDetectionMode(type, isVideoSelfie) {
+		this.runtime.requireFaceProcessingApi("Unable to set face detection mode, cpp API hasn't been initialized").setFaceProcessingMode(this.runtime.pipelineTypeToWasmEnum(type), isVideoSelfie);
+	}
+	async setFaceDetectionCallbacks(type, onFarAway, onTooClose, onTooManyFaces, onNoFace, onCapture, onGetReady, onGetReadyFinished, onCenterFace, onDark, onBlur, onFaceAngle, onLenses, onMask, onEyesClosed, onHeadWear, onSwitchToManualCapture, onFaceOccluded) {
+		this.runtime.requireFaceProcessingApi("Unable to set face detection callbacks, cpp API hasn't been initialized").setFaceProcessingCallbacks(this.runtime.pipelineTypeToWasmEnum(type), onFarAway, onTooClose, onTooManyFaces, onNoFace, onCapture, onGetReady, onGetReadyFinished, onCenterFace, onDark, onBlur, onFaceAngle, onLenses, onMask, onEyesClosed, onHeadWear, onSwitchToManualCapture, onFaceOccluded);
+	}
+	/**
+	* @deprecated Removed from ml-wasm-kit in v2.14.49-post1; scheduled for
+	* removal in 3.0.0. The signature stays available for source compatibility,
+	* but the canvas never reaches native code. Use
+	* `CameraCycleProvider.captureProtectedFrame` (the protected camera cycle's
+	* manual capture) instead.
+	*/
+	processPhoto(_canvas) {
+		throw new Error(PROCESS_PHOTO_UNSUPPORTED_ERROR);
+	}
+	/**
+	* POSTs the staged on-device face-results JSON to `/omni/add/face-results`
+	* via the C++ `WebApi`. The C++ side encrypts the body with
+	* `SessionEncryptor` and routes through the WASM `WebClient` with inline
+	* encryption (`ie=true`) — this does NOT depend on the WebClient E2EE
+	* session setup, so it works whether `setupWasmConnection` was called with
+	* `encryptionEnabled` true or false.
+	*
+	* Reads from the `WebApi` instance the runtime constructs eagerly in
+	* `initialize()`. The C++ `OnDeviceSelfieWorkflow` has already staged the
+	* aggregated best-shot results into that instance via
+	* `WebApi::setFaceResults(...)` during per-frame processing (auto-capture) or
+	* through the protected camera-cycle manual-capture path.
+	*/
+	postFaceResults(config) {
+		return this.runtime.requireWebApi("Unable to post face results, cpp API hasn't been initialized").postFaceResults(config ?? {});
+	}
+	/**
+	* Kept-dead: mirrors upstream `wasmApi.runSelfieCapture`. Nothing in the SDK
+	* calls it; it exists so the mirror stays 1:1 with upstream at the pinned tag.
+	*/
+	async runSelfieCapture(image) {
+		const faceProcessingWasmApi = this.runtime.requireFaceProcessingApi("Unable to run Selfie Capture, cpp API hasn't been initialized");
+		if (image) {
+			await this.runtime.allocateImageBuffers(image.width, image.height);
+			this.runtime.writeFrame(image);
+		}
+		return faceProcessingWasmApi.runSelfieCapture();
+	}
+};
+const faceProcessingWasmApi = new FaceProcessingWasmApi();
+//#endregion
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.ts
+/**
+* Best-effort `delete()` for Emscripten `embind`-bound handles. Plain
+* JS values lack a `.delete` method and are skipped; proxy objects
+* have it and need it called once to free the underlying C++ memory.
+* Swallows errors because this runs at 15–30 Hz on the detection hot
+* path — a throwing cleanup must never abort frame processing.
+*/
+function tryDeleteEmbindHandle(value) {
+	const maybeDelete = value?.delete;
+	if (typeof maybeDelete !== "function") return;
+	try {
+		maybeDelete.call(value);
+	} catch {}
+}
+var FaceDetectionProvider = class extends BaseWasmProvider {
+	constructor() {
+		super(4);
+		this.defaultThresholds = {
+			frameMinX: 0,
+			frameMinY: 0,
+			frameMaxX: 1,
+			frameMaxY: 1,
+			brightnessThreshold: 50,
+			blurrinessThreshold: 50,
+			tiltRotationAngleThreshold: 15,
+			minMagicCropSize: 200,
+			headwearThreshold: .86,
+			lensesThreshold: .95,
+			closedEyesThreshold: .9,
+			maskThreshold: .85,
+			minFaceQualityScore: .63,
+			faceOcclusionThreshold: .3,
+			getReadyDelay: 2e3,
+			framesAggregationInterval: 2e3,
+			minFramesWithFace: 3
+		};
+		this.currentFrame = null;
+	}
+	async processFrame(image) {
+		this.currentFrame = image;
+		const result = await this.processFrameWasm(image);
+		if (this.onFaceDataCallback && result?.faces) {
+			let face;
+			try {
+				if ((typeof result.faces.size === "function" ? result.faces.size() : 0) > 0) {
+					face = typeof result.faces.get === "function" ? result.faces.get(0) : void 0;
+					if (face) this.onFaceDataCallback(face, {
+						width: image.width,
+						height: image.height
+					});
+				}
+			} catch {} finally {
+				tryDeleteEmbindHandle(face);
+				tryDeleteEmbindHandle(result.faces);
+				tryDeleteEmbindHandle(result);
+			}
+		}
+	}
+	async initialize(config) {
+		if (config.videoSelfie === true) {
+			this.pipelineType = 3;
+			await this.initializeBase(config, "videoSelfie");
+		} else if (config.useOnDeviceWorkflow === true) {
+			this.pipelineType = 5;
+			await this.initializeBase(config, "onDeviceSelfie");
+		} else await this.initializeBase(config, "selfie");
+		this.applyDefaults(config.autocaptureInterval ?? 0);
+		if (config.videoSelfie === true) this.setVideoSelfieMode(true);
+	}
+	processPhoto(canvas) {
+		faceProcessingWasmApi.processPhoto(canvas);
+	}
+	async postFaceResults(config) {
+		this.ensureInitialized();
+		return faceProcessingWasmApi.postFaceResults(config);
+	}
+	setCallbacks(callbacks) {
+		this.ensureInitialized();
+		this.onFaceDataCallback = callbacks.onFaceData;
+		const onCaptureWrapper = (wasmCanvas, face) => {
+			if (!wasmCanvas) return;
+			const frameCanvas = new IncodeCanvas(wasmCanvas);
+			frameCanvas.updateBase64Image();
+			frameCanvas.updateBlob();
+			const faceCoordinates = face ? this.formatFaceCoordinates(face) : this.createDefaultFaceCoordinates(frameCanvas);
+			callbacks.onCapture?.(frameCanvas, faceCoordinates);
+		};
+		this.currentOnCaptureWrapper = onCaptureWrapper;
+		faceProcessingWasmApi.setFaceDetectionCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onTooClose ?? (() => {}), callbacks.onTooManyFaces ?? (() => {}), callbacks.onNoFace ?? (() => {}), onCaptureWrapper, callbacks.onGetReady ?? (() => {}), callbacks.onGetReadyFinished ?? (() => {}), callbacks.onCenterFace ?? (() => {}), callbacks.onDark ?? (() => {}), callbacks.onBlur ?? (() => {}), callbacks.onFaceAngle ?? (() => {}), callbacks.onLenses ?? (() => {}), callbacks.onMask ?? (() => {}), callbacks.onEyesClosed ?? (() => {}), callbacks.onHeadWear ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onFaceOccluded ?? (() => {}));
+	}
+	setPositionConstraints(constraints) {
+		this.ensureInitialized();
+		faceProcessingWasmApi.setFacePositionConstraints(this.getPipelineType(), constraints.minX, constraints.minY, constraints.maxX, constraints.maxY);
+	}
+	applyDefaults(autocaptureInterval = 0) {
+		this.ensureInitialized();
+		this.setThresholds({
+			brightnessThreshold: this.defaultThresholds.brightnessThreshold,
+			blurrinessThreshold: this.defaultThresholds.blurrinessThreshold,
+			tiltRotationAngleThreshold: this.defaultThresholds.tiltRotationAngleThreshold,
+			minMagicCropSize: this.defaultThresholds.minMagicCropSize,
+			autocaptureInterval,
+			minFaceQualityScore: this.defaultThresholds.minFaceQualityScore,
+			faceOcclusionThreshold: this.defaultThresholds.faceOcclusionThreshold,
+			getReadyDelay: this.defaultThresholds.getReadyDelay,
+			framesAggregationInterval: this.defaultThresholds.framesAggregationInterval,
+			minFramesWithFace: this.defaultThresholds.minFramesWithFace
+		});
+		this.setPositionConstraints({
+			minX: this.defaultThresholds.frameMinX,
+			minY: this.defaultThresholds.frameMinY,
+			maxX: this.defaultThresholds.frameMaxX,
+			maxY: this.defaultThresholds.frameMaxY
+		});
+		this.setAttributesThresholds({
+			headwearThreshold: this.defaultThresholds.headwearThreshold,
+			lensesThreshold: this.defaultThresholds.lensesThreshold,
+			closedEyesThreshold: this.defaultThresholds.closedEyesThreshold,
+			maskThreshold: this.defaultThresholds.maskThreshold
+		});
+	}
+	setAutocaptureInterval(interval) {
+		this.ensureInitialized();
+		if (!this.currentThresholds) {
+			this.applyDefaults(interval);
+			return;
+		}
+		this.setThresholds({
+			...this.currentThresholds,
+			autocaptureInterval: interval
+		});
+	}
+	setThresholds(thresholds) {
+		this.ensureInitialized();
+		this.currentThresholds = { ...thresholds };
+		faceProcessingWasmApi.setFaceDetectionThresholds(this.getPipelineType(), thresholds.brightnessThreshold, thresholds.blurrinessThreshold, thresholds.tiltRotationAngleThreshold, thresholds.minMagicCropSize, thresholds.autocaptureInterval, thresholds.minFaceQualityScore, thresholds.faceOcclusionThreshold, thresholds.getReadyDelay, thresholds.framesAggregationInterval, thresholds.minFramesWithFace);
+	}
+	setAttributesThresholds(thresholds) {
+		this.ensureInitialized();
+		faceProcessingWasmApi.setFaceAttributesThresholds(this.getPipelineType(), thresholds.headwearThreshold, thresholds.lensesThreshold, thresholds.closedEyesThreshold, thresholds.maskThreshold);
+	}
+	setChecksEnabled(config) {
+		this.ensureInitialized();
+		faceProcessingWasmApi.setFaceChecksEnabled(this.getPipelineType(), config.lenses, config.mask, config.closedEyes, config.headWear, config.occlusion);
+	}
+	setVideoSelfieMode(enabled) {
+		this.ensureInitialized();
+		faceProcessingWasmApi.setFaceDetectionMode(this.getPipelineType(), enabled);
+	}
+	forceCapture() {
+		if (!this.currentFrame || !this.currentOnCaptureWrapper) return;
+		const frame = IncodeCanvas.fromImageData(this.currentFrame);
+		this.currentOnCaptureWrapper(frame.canvas);
+	}
+	reset() {
+		super.reset();
+		this.currentFrame = null;
+		this.onFaceDataCallback = void 0;
+		this.currentOnCaptureWrapper = void 0;
+	}
+	createDefaultFaceCoordinates(canvas) {
+		return {
+			rightEyeX: 0,
+			rightEyeY: 0,
+			leftEyeX: 0,
+			leftEyeY: 0,
+			noseTipX: 0,
+			noseTipY: 0,
+			rightMouthX: 0,
+			rightMouthY: 0,
+			mouthX: 0,
+			mouthY: 0,
+			x: 0,
+			y: 0,
+			width: canvas.width() ?? 0,
+			height: canvas.height() ?? 0
+		};
+	}
+	formatFaceCoordinates(face) {
+		return {
+			rightEyeX: face.rightEye.x,
+			rightEyeY: face.rightEye.y,
+			leftEyeX: face.leftEye.x,
+			leftEyeY: face.leftEye.y,
+			noseTipX: face.noseTip.x,
+			noseTipY: face.noseTip.y,
+			rightMouthX: face.rightMouthCorner.x,
+			rightMouthY: face.rightMouthCorner.y,
+			mouthX: face.leftMouthCorner.x,
+			mouthY: face.leftMouthCorner.y,
+			x: face.rect.x,
+			y: face.rect.y,
+			width: face.rect.width,
+			height: face.rect.height
+		};
+	}
+};
+//#endregion
+export { sendLabelInspectionEvent as a, stopRecording as c, initializeDeepsightSession as i, stopStream as l, encryptSelfieImage as n, startDetection as o, initializeCamera as r, startRecordingSession as s, FaceDetectionProvider as t, isOnDeviceMode as u };

package/dist/FaceDetectionProvider-LdZ47bWy.d.ts

@@ -0,0 +1,36 @@
+import { c as FaceAttributesThresholds, d as FaceDetectionCallbacks, f as FaceDetectionConfig, h as IFaceDetectionCapability, l as FaceChecksConfig, m as FacePositionConstraints, p as FaceDetectionThresholds, v as WebApiHostRequestConfig } from "./createFaceAvatar-BlcTYgJv.js";
+import { t as BaseWasmProvider } from "./BaseWasmProvider-Dyi6dKp1.js";
+//#region ../infra/src/providers/wasm/FaceDetectionProvider.d.ts
+declare class FaceDetectionProvider extends BaseWasmProvider implements IFaceDetectionCapability {
+  private defaultThresholds;
+  private currentThresholds;
+  private currentFrame;
+  private onFaceDataCallback;
+  constructor();
+  processFrame(image: ImageData): Promise<void>;
+  initialize(config: FaceDetectionConfig): Promise<void>;
+  /**
+   * Last-registered onCapture callback — captured into a private
+   * field so `forceCapture()` (called from outside the WASM-callback
+   * lifecycle) can re-fire the same wrapper. `setCallbacks` rebinds
+   * this on each invocation, so the field always reflects the
+   * current consumer.
+   */
+  private currentOnCaptureWrapper;
+  processPhoto(canvas: HTMLCanvasElement): void;
+  postFaceResults(config?: WebApiHostRequestConfig): Promise<unknown>;
+  setCallbacks(callbacks: FaceDetectionCallbacks): void;
+  setPositionConstraints(constraints: FacePositionConstraints): void;
+  applyDefaults(autocaptureInterval?: number): void;
+  setAutocaptureInterval(interval: number): void;
+  setThresholds(thresholds: FaceDetectionThresholds): void;
+  setAttributesThresholds(thresholds: FaceAttributesThresholds): void;
+  setChecksEnabled(config: FaceChecksConfig): void;
+  setVideoSelfieMode(enabled: boolean): void;
+  forceCapture(): void;
+  reset(): void;
+  private createDefaultFaceCoordinates;
+  private formatFaceCoordinates;
+}
+//#endregion
+export { FaceDetectionProvider as t };

package/dist/{IIdCaptureCapability-DHTT3FC2.d.ts → IIdCaptureCapability-RNiFhvXR.d.ts}

@@ -1,35 +1,5 @@
-import { a as MLProviderConfig, i as IMLProviderCapability, o as IncodeCanvas } from "./IStorageCapability-ORkQfK3F.js";
-//#region ../infra/src/wasm/apiUtilities.d.ts
-/**
- * Shared WASM module loader.
- *
- * The pinned `webLib.wasm` (see `wasmDefaults.ts`) bundles BOTH the ML pipeline
- * APIs (used by `mlWasmJSApi.ts`) AND a C++ `WebClient` HTTP client (used by
- * `wasmWebClient.ts`). Both consumers must share a single instantiated
- * `wasmModule` — calling the glue `Module()` factory twice would re-instantiate
- * the WASM heap and produce divergent state.
- *
- * This module memoizes the load: the first caller (whichever arrives first —
- * ML init or HTTP init) triggers the fetch + glue load, and subsequent callers
- * await the same promise. Idempotent on success; on failure, the singleton is
- * cleared so the next caller retries.
- *
- * SIMD fallback mirrors the legacy behavior: try the SIMD binary + SIMD glue
- * (`webLibSimd.js` + `webLibSimd.wasm`) first, fall back to the non-SIMD pair
- * (`webLib.js` + `webLib.wasm`) on instantiation failure. Each binary MUST be
- * paired with its matching glue — the CDN ships them as paired artifacts and
- * mixing them produces an unusable module.
- */
-declare global {
-  interface Window {
-    Module?: WasmGlueFactory;
-    wasmArrayBuffer: Uint8Array | null;
-  }
-}
-/** Opaque handle for the loaded WASM module instance. */
-type WasmModule = Record<string, unknown>;
-type WasmGlueFactory = () => Promise<WasmModule>;
-//#endregion
+import "./warmup-Cis2p6O0.js";
+import { _ as MLProviderConfig, g as IMLProviderCapability, y as IncodeCanvas } from "./createFaceAvatar-BlcTYgJv.js";
 //#region ../infra/src/wasm/mlWasmBridgeTypes.d.ts
 /**
  * Decoded PDF417 barcode surfaced from the WASM ID-capture pipeline during
@@ -102,7 +72,11 @@ interface IdCaptureCallbacks {
   onBlur?: () => void;
   onGlare?: () => void;
   onCapturing?: () => void;
-  onCapture?: () => void;
+  /**
+   * Receives the exact best-shot canvas detached by the Core ID workflow.
+   * The canvas is presentation-only; protected submission remains native-owned.
+   */
+  onCapture?: (canvas?: HTMLCanvasElement | null) => void;
   onBestFrame?: (blur: number, glare: number, orientation: string) => void;
   onIdNotDetected?: () => void;
   onSwitchToManualCapture?: () => void;