@incodetech/core 2.2.0 → 2.3.0-rc.0

package/dist/id.esm.js

@@ -1,11 +1,21 @@
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
-import { n as eventModuleNames } from "./events-DYiyoSlx.esm.js";
+import { n as eventModuleNames } from "./events-ijlbX_Wx.esm.js";
 import { i as assign, s as createActor } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { a as MANUAL_UPLOAD_MAX_RETRIES, i as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, r as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, t as idCaptureMachine } from "./idCaptureStateMachine-kZ5OpdfM.esm.js";
-import { n as createIdCaptureActor, r as createIdCaptureManagerFromActor, t as createIdCaptureManager } from "./idCaptureManager-BYwTZ2H8.esm.js";
-import { a as processId, c as stopStream, d as validateUploadResponse, f as ID_ERROR_CODES, i as preloadIdRecordingProvider, l as uploadIdImage, m as resolveIdCaptureThresholds, n as barcodeToBase64, o as startRecordingSession, r as initializeIdCapture, s as stopRecording, t as addBarcode, u as uploadManualIdFile } from "./idCaptureServices-44kwQItl.esm.js";
-import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-GpvMuz9o.esm.js";
+import { a as createIdProtectedCaptureController, c as DIGITAL_ID_DOCUMENT_TYPES, d as resolveDigitalIdImplementation, f as MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, h as resolveWalletPlatform, i as createIdCaptureOnlyDeliveryActor, l as DIGITAL_ID_REGISTRY, m as MANUAL_UPLOAD_MAX_RETRIES, n as provideIdProtectedCaptureController, p as MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, r as attachIdProtectedCaptureController, t as idCaptureMachine, u as isRedirectFlowType } from "./idCaptureStateMachine-CmqihkUy.esm.js";
+import { n as createIdCaptureActor, r as createIdCaptureManagerFromActor, t as createIdCaptureManager } from "./idCaptureManager-Vby8oYqh.esm.js";
+import { _ as ID_ERROR_CODES, a as getRealQualityValue, c as preloadIdRecordingProvider, d as startRecordingSession, f as stopRecording, g as validateUploadResponse, h as uploadManualIdFile, i as finalizeRecordingSession, l as prepareRecordingForCameraRetry, m as uploadIdImage, n as barcodeToBase64, o as initializeIdCapture, p as stopStream, r as disposeRecordingSession, s as pauseRecordingForAttempt, t as addBarcode, u as processId, y as resolveIdCaptureThresholds } from "./idCaptureServices-CJIxD9ep.esm.js";
+import { t as invokeOnCaptureCallback } from "./invokeOnCaptureCallback-BjzPjJ_p.esm.js";
+//#region src/modules/id/deviceWallet/deviceWalletErrors.ts
+/**
+* Fail reason → i18n key for the device-wallet error screen (same shape as
+* `DIGITAL_UPLOAD_ERROR_KEYS`). Keys are authored in i18nexus.
+*/
+const DEVICE_WALLET_ERROR_KEYS = {
+	UNSUPPORTED_PLATFORM: "idv2.deviceWallet.unsupportedPlatformDescription",
+	NO_CREDENTIAL: "idv2.deviceWallet.noCredentialDescription",
+	WALLET_ERROR: "idv2.deviceWallet.errorDescription"
+};
+//#endregion
 //#region src/modules/id/idCaptureOnlyStateMachine.ts
 function buildSubImage(canvas) {
 	if (!canvas) return void 0;
@@ -60,42 +70,31 @@ async function finalizeIdCaptureOnly(input, signal) {
 * recording steps are local instead of remote.
 */
 const idCaptureOnlyMachine = idCaptureMachine.provide({
-	actors: {
-		/**
-		* "Upload" becomes local finalize. Returns the rich payload typed as
-		* `CaptureIdResponse` so the base machine's inline `assign` continues to
-		* work; the variant's overridden `storeCapturedImage` action then routes
-		* the payload into `captureOnlyImages` keyed by the current side.
-		*/
-		uploadIdImage: fromPromise(async ({ input, signal }) => {
-			return await finalizeIdCaptureOnly(input, signal);
+	actors: { 
+	/** No backend processing in captureOnly. */
+processId: fromPromise(async () => ({ isDocumentExpired: false })) },
+	actions: {
+		attachProtectedController: assign(({ self }) => {
+			attachIdProtectedCaptureController(self, createIdProtectedCaptureController({ finalizeCaptureOnly: finalizeIdCaptureOnly }));
+			return {};
 		}),
-		/** No backend processing in captureOnly. */
-		processId: fromPromise(async () => ({ isDocumentExpired: false })),
 		/**
-		* No recording session in captureOnly: no backend session, no video
-		* upload, no OpenVidu connection. The payload surfaced via `onCapture`
-		* does not include any recording artifacts.
+		* Routes the rich payload from local delivery into `captureOnlyImages`
+		* keyed by side instead of the regular `capturedImages` slot.
 		*/
-		startRecording: fromPromise(async () => void 0)
+		storeCapturedImage: assign(({ context, event }) => {
+			if (!("output" in event) || !context.currentMode) return { captureOnlyImages: context.captureOnlyImages };
+			const image = event.output;
+			const side = context.currentMode === "back" ? "back" : "front";
+			return {
+				captureOnlyImages: {
+					...context.captureOnlyImages,
+					[side]: image
+				},
+				previewImageUrl: image.croppedImage?.url ?? image.url ?? context.previewImageUrl
+			};
+		})
 	},
-	actions: { 
-	/**
-	* Routes the rich payload from `uploadIdImage` into `captureOnlyImages`
-	* keyed by side instead of the regular `capturedImages` slot.
-	*/
-storeCapturedImage: assign(({ context, event }) => {
-		if (!("output" in event) || !context.currentMode) return { captureOnlyImages: context.captureOnlyImages };
-		const image = event.output;
-		const side = context.currentMode === "back" ? "back" : "front";
-		return {
-			captureOnlyImages: {
-				...context.captureOnlyImages,
-				[side]: image
-			},
-			previewImageUrl: image.croppedImage?.url ?? image.url ?? context.previewImageUrl
-		};
-	}) },
 	guards: {
 		hasUploadValidationError: () => false,
 		/**
@@ -114,6 +113,9 @@ storeCapturedImage: assign(({ context, event }) => {
 		}
 	}
 });
+function provideIdCaptureOnlyController(controller) {
+	return provideIdProtectedCaptureController(idCaptureOnlyMachine, controller).provide({ actors: { captureOnlyDelivery: createIdCaptureOnlyDeliveryActor(controller) } });
+}
 //#endregion
 //#region src/modules/id/idCaptureOnlyActor.ts
 /**
@@ -147,17 +149,17 @@ const DEFAULT_ID_CAPTURE_ONLY_CONFIG = {
 	perCountryPerDocOverrides: {}
 };
 function createIdCaptureOnlyActor(options) {
-	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
 	const mergedConfig = {
 		...DEFAULT_ID_CAPTURE_ONLY_CONFIG,
 		...options.config
 	};
-	return createActor(idCaptureOnlyMachine, { input: {
-		config: {
-			...mergedConfig,
-			thresholds: resolveIdCaptureThresholds(mergedConfig)
-		},
-		dependencies
+	const config = {
+		...mergedConfig,
+		thresholds: resolveIdCaptureThresholds(mergedConfig)
+	};
+	return createActor(provideIdCaptureOnlyController(createIdProtectedCaptureController({ finalizeCaptureOnly: finalizeIdCaptureOnly })), { input: {
+		config,
+		dependencies: options.dependencies
 	} }).start();
 }
 //#endregion
@@ -211,4 +213,4 @@ function createIdCaptureOnlyManager(options) {
 	return createIdCaptureOnlyManagerFromActor(createIdCaptureOnlyActor(options), options.config);
 }
 //#endregion
-export { ID_ERROR_CODES, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, MANUAL_UPLOAD_MAX_RETRIES, addBarcode, barcodeToBase64, createIdCaptureActor, createIdCaptureManager, createIdCaptureOnlyActor, createIdCaptureOnlyManager, createIdCaptureOnlyManagerFromActor, idCaptureMachine, idCaptureOnlyMachine, initializeIdCapture, preloadIdRecordingProvider, processId, startRecordingSession, stopRecording, stopStream, uploadIdImage, uploadManualIdFile, validateUploadResponse };
+export { DEVICE_WALLET_ERROR_KEYS, DIGITAL_ID_DOCUMENT_TYPES, DIGITAL_ID_REGISTRY, ID_ERROR_CODES, MANUAL_UPLOAD_EXHAUSTION_FORWARD_MS, MANUAL_UPLOAD_MAX_FILE_SIZE_BYTES, MANUAL_UPLOAD_MAX_RETRIES, addBarcode, barcodeToBase64, createIdCaptureActor, createIdCaptureManager, createIdCaptureOnlyActor, createIdCaptureOnlyManager, createIdCaptureOnlyManagerFromActor, disposeRecordingSession, finalizeRecordingSession, getRealQualityValue, idCaptureMachine, idCaptureOnlyMachine, initializeIdCapture, isRedirectFlowType, pauseRecordingForAttempt, preloadIdRecordingProvider, prepareRecordingForCameraRetry, processId, resolveDigitalIdImplementation, resolveWalletPlatform, startRecordingSession, stopRecording, stopStream, uploadIdImage, uploadManualIdFile, validateUploadResponse };

package/dist/idCaptureDefaults-BcxjQDI3.esm.js

@@ -0,0 +1,484 @@
+import { b as resolveWasmSource, p as WASM_MODEL_FILES } from "./wasmWebClient-B7baE-Wf.esm.js";
+import { p as getBarcodeEnhanceModelUrl } from "./setup-msLybMbC.esm.js";
+import { s as wasmRuntime, t as getResolvedModelSource } from "./warmup-CUUnwYxe.esm.js";
+import { i as BaseWasmProvider } from "./safeStorage-B-trhxg6.esm.js";
+import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
+//#region ../infra/src/media/CameraCompositor.ts
+const MAX_COMPOSITE_LONG_EDGE = 1280;
+const MAX_COMPOSITE_SHORT_EDGE = 720;
+const FRAME_INTERVAL_TOLERANCE_RATIO = .9;
+const DEFAULT_RESUME_TIMEOUT_MS = 2e3;
+/**
+* Composites the *active* camera into a canvas and exposes the canvas as a
+* single, stable `MediaStream` to record. Switching cameras (front ↔ back)
+* just repoints what the canvas draws — the output stream and its audio track
+* are never replaced — so a single `MediaRecorder` produces one continuous
+* video that follows the camera switches (V1 parity), instead of restarting
+* per camera.
+*
+* The audio track from the initial stream is carried through unchanged across
+* video switches, so there's no audio glitch when the camera flips.
+*/
+var CameraCompositor = class {
+	constructor(options = {}) {
+		this.canvas = null;
+		this.ctx = null;
+		this.video = null;
+		this.frameRequestId = null;
+		this.frameRequestKind = null;
+		this.lastDrawTimeMs = null;
+		this.lastVideoTimeSeconds = null;
+		this.audioTrack = null;
+		this.videoTrack = null;
+		this.composite = null;
+		this.fps = options.fps ?? 30;
+		this.frameIntervalMs = this.fps > 0 ? 1e3 / this.fps : 0;
+		this.resumeTimeoutMs = options.resumeTimeoutMs ?? DEFAULT_RESUME_TIMEOUT_MS;
+	}
+	/**
+	* Begin compositing `stream` and return the composite stream to record. The
+	* stream's audio track (if any) is carried through unchanged across later
+	* `switchVideo` calls.
+	*/
+	start(stream) {
+		this.canvas = document.createElement("canvas");
+		this.ctx = this.canvas.getContext("2d");
+		this.video = document.createElement("video");
+		this.video.muted = true;
+		this.video.playsInline = true;
+		this.audioTrack = stream.getAudioTracks()[0] ?? null;
+		this.setVideoSource(stream);
+		const composite = this.canvas.captureStream(this.fps);
+		if (this.audioTrack) composite.addTrack(this.audioTrack);
+		this.composite = composite;
+		this.startDrawLoop();
+		return composite;
+	}
+	/**
+	* Swap the camera feeding the canvas without interrupting the composite
+	* stream. Pass a video-only stream (audio is kept from `start`). The previous
+	* video track is stopped.
+	*/
+	switchVideo(stream) {
+		if (!this.composite) return;
+		const previousVideoTrack = this.videoTrack;
+		this.setVideoSource(stream);
+		this.startDrawLoop();
+		if (previousVideoTrack) previousVideoTrack.stop();
+	}
+	/** The composite stream being recorded, if compositing is active. */
+	get stream() {
+		return this.composite ?? void 0;
+	}
+	/** Pause source playback and drawing while the page is backgrounded. */
+	pause() {
+		this.finishResume("timed-out");
+		this.cancelDrawLoop();
+		this.video?.pause();
+	}
+	/**
+	* Restart source playback and wait for a genuinely new camera frame to be
+	* drawn into the stable canvas stream. The caller must not resume encoding
+	* until this resolves with `resumed`.
+	*/
+	async resume(signal) {
+		const video = this.video;
+		if (!video || !this.composite) return "timed-out";
+		if (this.audioTrack?.readyState === "ended") return "audio-ended";
+		if (!this.videoTrack || this.videoTrack.readyState === "ended") return "video-ended";
+		if (signal?.aborted) return "timed-out";
+		try {
+			await video.play();
+		} catch {
+			return "timed-out";
+		}
+		if (signal?.aborted) return "timed-out";
+		this.finishResume("timed-out");
+		return new Promise((resolve) => {
+			const timeout = setTimeout(() => {
+				this.finishResume("timed-out");
+			}, this.resumeTimeoutMs);
+			if (signal) {
+				const onAbort = () => this.finishResume("timed-out");
+				this.resumeWaiter = {
+					resolve,
+					timeout,
+					signal,
+					onAbort
+				};
+				signal.addEventListener("abort", onAbort, { once: true });
+				if (signal.aborted) {
+					this.finishResume("timed-out");
+					return;
+				}
+			} else this.resumeWaiter = {
+				resolve,
+				timeout
+			};
+			this.startDrawLoop(false);
+		});
+	}
+	/** Stop compositing and release the canvas, audio, and video tracks. */
+	stop() {
+		this.finishResume("timed-out");
+		this.cancelDrawLoop();
+		this.videoTrack?.stop();
+		this.audioTrack?.stop();
+		this.composite?.getTracks().forEach((track) => track.stop());
+		if (this.video) this.video.srcObject = null;
+		this.canvas = null;
+		this.ctx = null;
+		this.video = null;
+		this.videoTrack = null;
+		this.audioTrack = null;
+		this.composite = null;
+	}
+	setVideoSource(stream) {
+		this.videoTrack = stream.getVideoTracks()[0] ?? null;
+		const video = this.video;
+		if (!video) return;
+		video.srcObject = new MediaStream(stream.getVideoTracks());
+		video.play().catch(() => {});
+	}
+	startDrawLoop(resetSourceTime = true) {
+		this.cancelDrawLoop();
+		this.lastDrawTimeMs = null;
+		if (resetSourceTime) this.lastVideoTimeSeconds = null;
+		const draw = (timeMs) => {
+			const elapsed = this.lastDrawTimeMs === null ? Infinity : timeMs - this.lastDrawTimeMs;
+			if ((this.frameIntervalMs === 0 || elapsed >= this.frameIntervalMs * FRAME_INTERVAL_TOLERANCE_RATIO) && this.drawCurrentFrame()) {
+				this.lastDrawTimeMs = timeMs;
+				this.finishResume("resumed");
+			}
+			this.scheduleNextFrame(draw);
+		};
+		this.scheduleNextFrame(draw);
+	}
+	finishResume(result) {
+		const waiter = this.resumeWaiter;
+		if (!waiter) return;
+		this.resumeWaiter = void 0;
+		clearTimeout(waiter.timeout);
+		if ("signal" in waiter) waiter.signal.removeEventListener("abort", waiter.onAbort);
+		waiter.resolve(result);
+	}
+	scheduleNextFrame(callback) {
+		const video = this.video;
+		if (video && typeof video.requestVideoFrameCallback === "function") {
+			this.frameRequestKind = "video";
+			this.frameRequestId = video.requestVideoFrameCallback(callback);
+			return;
+		}
+		this.frameRequestKind = "animation";
+		this.frameRequestId = requestAnimationFrame(callback);
+	}
+	cancelDrawLoop() {
+		if (this.frameRequestId === null) return;
+		if (this.frameRequestKind === "video" && this.video && typeof this.video.cancelVideoFrameCallback === "function") this.video.cancelVideoFrameCallback(this.frameRequestId);
+		else cancelAnimationFrame(this.frameRequestId);
+		this.frameRequestId = null;
+		this.frameRequestKind = null;
+	}
+	drawCurrentFrame() {
+		const video = this.video;
+		const canvas = this.canvas;
+		const ctx = this.ctx;
+		if (!video || !canvas || !ctx || video.videoWidth <= 0) return false;
+		if (this.lastVideoTimeSeconds === video.currentTime) return false;
+		const dimensions = this.getBoundedDimensions(video.videoWidth, video.videoHeight);
+		if (canvas.width !== dimensions.width || canvas.height !== dimensions.height) {
+			canvas.width = dimensions.width;
+			canvas.height = dimensions.height;
+		}
+		ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+		this.lastVideoTimeSeconds = video.currentTime;
+		return true;
+	}
+	getBoundedDimensions(width, height) {
+		const longEdge = Math.max(width, height);
+		const shortEdge = Math.min(width, height);
+		const scale = Math.min(1, MAX_COMPOSITE_LONG_EDGE / longEdge, MAX_COMPOSITE_SHORT_EDGE / shortEdge);
+		return {
+			width: Math.max(1, Math.round(width * scale)),
+			height: Math.max(1, Math.round(height * scale))
+		};
+	}
+};
+//#endregion
+//#region ../infra/src/wasm/idCaptureWasmApi.ts
+var IdCaptureWasmApi = class {
+	constructor(runtime = wasmRuntime) {
+		this.runtime = runtime;
+	}
+	async setIdCaptureThresholds(type, blurThreshold, blurChangeThreshold, glareThreshold, clsThreshold, sideThreshold, iouThreshold, idDetectedTimeout, autocaptureTimeout, framesAggregationInterval) {
+		this.runtime.requireIdCaptureApi("Unable to set thresholds, cpp API hasn't been initialized").setIdCaptureThresholds(this.runtime.pipelineTypeToWasmEnum(type), blurThreshold, blurChangeThreshold, glareThreshold, clsThreshold, sideThreshold, iouThreshold, idDetectedTimeout, autocaptureTimeout, framesAggregationInterval);
+	}
+	async setIdCaptureCallbacks(type, onFarAway, onDetectionStarted, onMaskChange, onBlur, onGlare, onCapturing, onCapture, onBestFrame, onIDNotDetected, onSwitchToManualCapture, onIDTypeChange, onIDSideChange, onCapturingCounterValueChange) {
+		this.runtime.requireIdCaptureApi("Unable to set callbacks, cpp API hasn't been initialized").setIdCaptureCallbacks(this.runtime.pipelineTypeToWasmEnum(type), onFarAway, onDetectionStarted, onMaskChange, onBlur, onGlare, onCapturing, onCapture, onBestFrame, onIDNotDetected, onSwitchToManualCapture, onIDTypeChange, onIDSideChange, onCapturingCounterValueChange);
+	}
+	async setIdCaptureGeometryParams(type, areaDown, areaUp, areaIOSPassportUp, areaIOSPassportDown, widthIOSUp, widthIOSDown, widthDown, widthUp, windowOuterWidth, windowOuterHeight, windowInnerWidth, windowInnerHeight) {
+		this.runtime.requireIdCaptureApi("Unable to set geometry params, cpp API hasn't been initialized").setIdCaptureGeometryParams(this.runtime.pipelineTypeToWasmEnum(type), areaDown, areaUp, areaIOSPassportUp, areaIOSPassportDown, widthIOSUp, widthIOSDown, widthDown, widthUp, windowOuterWidth, windowOuterHeight, windowInnerWidth, windowInnerHeight);
+	}
+	async setIdCaptureConfigParams(type, isFixedMask, isIPhone14OrHigher, idType, isBlurCheckEnabled, isGlareCheckEnabled, _isIdFaceQualityCheckEnabled, isIouCheckEnabled, _isFPSLimitEnabled) {
+		this.runtime.requireIdCaptureApi("Unable to set config params, cpp API hasn't been initialized").setIdCaptureConfigParams(this.runtime.pipelineTypeToWasmEnum(type), isFixedMask, isIPhone14OrHigher, idType, isBlurCheckEnabled, isGlareCheckEnabled, isIouCheckEnabled);
+	}
+	setIdCaptureModelType(pipelineType, modelType) {
+		this.runtime.requireIdCaptureApi("Unable to set model type, cpp API hasn't been initialized").setIdCaptureModelType(this.runtime.pipelineTypeToWasmEnum(pipelineType), this.runtime.IdCaptureModelTypeToWasmEnum(modelType));
+	}
+	setIdBarcodeCaptureEnabled(pipelineType, enabled) {
+		this.runtime.requireIdCaptureApi("Unable to set barcode capture enabled, cpp API hasn't been initialized").setIdBarcodeCaptureEnabled(this.runtime.pipelineTypeToWasmEnum(pipelineType), enabled);
+	}
+	setIdBarcodeAutoCaptureOnDecode(pipelineType, enabled) {
+		this.runtime.requireIdCaptureApi("Unable to set barcode auto-capture-on-decode, cpp API hasn't been initialized").setIdBarcodeAutoCaptureOnDecode(this.runtime.pipelineTypeToWasmEnum(pipelineType), enabled);
+	}
+	setIdBarcodeDecodedCallback(pipelineType, onBarcodeDecoded) {
+		this.runtime.requireIdCaptureApi("Unable to set barcode decoded callback, cpp API hasn't been initialized").setIdBarcodeDecodedCallback(this.runtime.pipelineTypeToWasmEnum(pipelineType), onBarcodeDecoded);
+	}
+	async setIdBarcodeEnhancementModel(pipelineType, modelPath) {
+		const message = "Unable to set barcode enhancement model, cpp API hasn't been initialized";
+		this.runtime.requireIdCaptureApi(message);
+		const buffer = await resolveWasmSource(modelPath, "barcode model");
+		return this.runtime.requireIdCaptureApi(message).setBarcodeEnhancementModel(this.runtime.pipelineTypeToWasmEnum(pipelineType), buffer);
+	}
+	IdPerspectiveTransform(image, frameRect) {
+		return this.runtime.requireIdCaptureApi("Unable to perform perspective transform, cpp API hasn't been initialized").IdPerspectiveTransform(image, frameRect);
+	}
+	/**
+	* Kept-dead: mirrors upstream `wasmApi.runIdCapture`. Nothing in the SDK calls
+	* it; it exists so the mirror stays 1:1 with upstream at the pinned tag.
+	*/
+	async runIdCapture(image) {
+		const idCaptureWasmApi = this.runtime.requireIdCaptureApi("Unable to run Id Capture, cpp API hasn't been initialized");
+		if (image) {
+			await this.runtime.allocateImageBuffers(image.width, image.height);
+			this.runtime.writeFrame(image);
+		}
+		return idCaptureWasmApi.runIdCapture();
+	}
+};
+const idCaptureWasmApi = new IdCaptureWasmApi();
+//#endregion
+//#region ../infra/src/providers/wasm/IdCaptureProvider.ts
+var IdCaptureProvider = class extends BaseWasmProvider {
+	constructor(protectedWorkflow) {
+		super(protectedWorkflow ?? 0);
+		this.lastProcessResult = null;
+		this.capturedCanvas = null;
+		this.originalCapturedCanvas = null;
+		this.lastDecodedBarcode = null;
+		this.barcodeEnhancementModelLoaded = false;
+	}
+	async initialize(config) {
+		if (config.videoSelfie === true) {
+			if (this.pipelineType !== 0) throw new Error("[Incode SDK] Protected ID workflows are unavailable for video selfie.");
+			this.pipelineType = 2;
+			await this.initializeBase(config, "videoSelfieId");
+		} else await this.initializeBase(config, "idCapture");
+	}
+	setCallbacks(callbacks) {
+		this.ensureInitialized();
+		const onCaptureWrapper = (canvas) => {
+			callbacks.onCapture?.(canvas);
+		};
+		idCaptureWasmApi.setIdCaptureCallbacks(this.getPipelineType(), callbacks.onFarAway ?? (() => {}), callbacks.onDetectionStarted ?? (() => {}), callbacks.onMaskChange ? (show, mask, top, orientation) => callbacks.onMaskChange?.(show, mask, top, orientation) : () => {}, callbacks.onBlur ?? (() => {}), callbacks.onGlare ?? (() => {}), callbacks.onCapturing ?? (() => {}), callbacks.onCapture ? onCaptureWrapper : () => {}, callbacks.onBestFrame ? (blur, glare, orientation) => callbacks.onBestFrame?.(blur, glare, orientation) : () => {}, callbacks.onIdNotDetected ?? (() => {}), callbacks.onSwitchToManualCapture ?? (() => {}), callbacks.onIdTypeChange ? (idType) => callbacks.onIdTypeChange?.(idType) : () => {}, callbacks.onIdSideChange ? (side) => callbacks.onIdSideChange?.(side) : () => {}, callbacks.onCapturingCounterValueChange ? (value) => callbacks.onCapturingCounterValueChange?.(value) : () => {});
+		if (callbacks.onBarcodeDecoded) {
+			const onBarcodeDecoded = callbacks.onBarcodeDecoded;
+			idCaptureWasmApi.setIdBarcodeDecodedCallback(this.getPipelineType(), (decoded) => {
+				this.lastDecodedBarcode = decoded;
+				onBarcodeDecoded(decoded);
+			});
+		} else idCaptureWasmApi.setIdBarcodeDecodedCallback(this.getPipelineType(), () => {});
+	}
+	setThresholds(thresholds) {
+		this.ensureInitialized();
+		idCaptureWasmApi.setIdCaptureThresholds(this.getPipelineType(), thresholds.blurThreshold, thresholds.blurChangeThreshold, thresholds.glareThreshold, thresholds.clsThreshold, thresholds.sideThreshold, thresholds.iouThreshold, thresholds.idDetectedTimeout, thresholds.autocaptureTimeout, thresholds.framesAggregationInterval);
+	}
+	setGeometry(geometry) {
+		this.ensureInitialized();
+		idCaptureWasmApi.setIdCaptureGeometryParams(this.getPipelineType(), geometry.areaDown, geometry.areaUp, geometry.areaIOSPassportUp, geometry.areaIOSPassportDown, geometry.widthIOSUp, geometry.widthIOSDown, geometry.widthDown, geometry.widthUp, geometry.windowOuterWidth, geometry.windowOuterHeight, geometry.windowInnerWidth, geometry.windowInnerHeight);
+	}
+	setSettings(settings) {
+		this.ensureInitialized();
+		idCaptureWasmApi.setIdCaptureConfigParams(this.getPipelineType(), settings.isFixedMask, settings.isIPhone14OrHigher, settings.idType, settings.blurCheckEnabled, settings.glareCheckEnabled, settings.faceQualityCheckEnabled, settings.iouCheckEnabled, settings.fpsLimitEnabled);
+	}
+	setModelType(modelType) {
+		this.ensureInitialized();
+		let wasmModelType;
+		switch (modelType) {
+			case "v1":
+				wasmModelType = 0;
+				break;
+			case "v2":
+				wasmModelType = 1;
+				break;
+			case "v3":
+				wasmModelType = 2;
+				break;
+			default: throw new Error(`Unknown model type: ${modelType}`);
+		}
+		idCaptureWasmApi.setIdCaptureModelType(this.getPipelineType(), wasmModelType);
+	}
+	setBarcodeCaptureEnabled(enabled) {
+		this.ensureInitialized();
+		idCaptureWasmApi.setIdBarcodeCaptureEnabled(this.getPipelineType(), enabled);
+	}
+	setBarcodeAutoCaptureOnDecode(enabled) {
+		this.ensureInitialized();
+		idCaptureWasmApi.setIdBarcodeAutoCaptureOnDecode(this.getPipelineType(), enabled);
+	}
+	async setBarcodeEnhancementModel() {
+		this.ensureInitialized();
+		if (this.barcodeEnhancementModelLoaded) return true;
+		const modelUrl = getResolvedModelSource(WASM_MODEL_FILES.barcode, "idCapture") ?? getBarcodeEnhanceModelUrl();
+		const applied = await idCaptureWasmApi.setIdBarcodeEnhancementModel(this.getPipelineType(), modelUrl);
+		this.barcodeEnhancementModelLoaded = applied;
+		return applied;
+	}
+	getLastDecodedBarcode() {
+		return this.lastDecodedBarcode;
+	}
+	/**
+	* Processes a frame through the WASM pipeline and stores the result.
+	*/
+	async processFrame(image) {
+		const result = await this.processFrameWasm(image);
+		const pipelineType = this.getPipelineType();
+		if (result && (pipelineType === 0 || pipelineType === 2)) this.lastProcessResult = result;
+		else this.lastProcessResult = null;
+	}
+	/**
+	* Gets the last process result from the most recent frame processing.
+	* @returns The last process result with quad coordinates, or null if not available
+	*/
+	getLastProcessResult() {
+		return this.lastProcessResult;
+	}
+	transformPerspective(canvas, frameRect) {
+		this.ensureInitialized();
+		const originalWidth = canvas.width();
+		const originalHeight = canvas.height();
+		try {
+			const imageData = canvas.getImageData();
+			if (!imageData) return canvas;
+			const transformedCanvas = idCaptureWasmApi.IdPerspectiveTransform(imageData, frameRect);
+			if (transformedCanvas) {
+				const wrappedCanvas = new IncodeCanvas(transformedCanvas);
+				const wrappedWidth = wrappedCanvas.width();
+				const wrappedHeight = wrappedCanvas.height();
+				if (wrappedWidth === originalWidth && wrappedHeight === originalHeight) {
+					const croppedCanvas = this.cropCanvasToRect(wrappedCanvas, {
+						x: Math.round(frameRect.x),
+						y: Math.round(frameRect.y),
+						w: Math.round(frameRect.w),
+						h: Math.round(frameRect.h)
+					});
+					if (croppedCanvas) return croppedCanvas;
+				}
+				return wrappedCanvas;
+			}
+			return canvas;
+		} catch (_error) {
+			return canvas;
+		}
+	}
+	/**
+	* Crops a canvas to the specified rectangle region.
+	* @param canvas - The canvas to crop
+	* @param rect - The rectangle to crop to (x, y, w, h)
+	* @returns A new IncodeCanvas with the cropped region, or null if cropping fails
+	*/
+	cropCanvasToRect(canvas, rect) {
+		const canvasWidth = canvas.width();
+		const canvasHeight = canvas.height();
+		if (!canvasWidth || !canvasHeight) return null;
+		const x = Math.max(0, Math.min(rect.x, canvasWidth));
+		const y = Math.max(0, Math.min(rect.y, canvasHeight));
+		const w = Math.max(1, Math.min(rect.w, canvasWidth - x));
+		const h = Math.max(1, Math.min(rect.h, canvasHeight - y));
+		const croppedCanvasElement = document.createElement("canvas");
+		croppedCanvasElement.width = w;
+		croppedCanvasElement.height = h;
+		const ctx = croppedCanvasElement.getContext("2d");
+		if (!ctx) return null;
+		ctx.drawImage(canvas.canvas, x, y, w, h, 0, 0, w, h);
+		return new IncodeCanvas(croppedCanvasElement);
+	}
+	/**
+	* Gets the captured canvas (transformed for preview).
+	* @returns The captured canvas, or null if not available
+	*/
+	getCapturedCanvas() {
+		return this.capturedCanvas;
+	}
+	/**
+	* Gets the original captured canvas (full frame for upload).
+	* @returns The original captured canvas, or null if not available
+	*/
+	getOriginalCapturedCanvas() {
+		return this.originalCapturedCanvas;
+	}
+	/**
+	* Sets the captured canvases (original and transformed).
+	* @param original - The original full-frame canvas (for upload)
+	* @param transformed - The transformed canvas (for preview)
+	*/
+	setCapturedCanvases(original, transformed) {
+		this.originalCapturedCanvas = original;
+		this.capturedCanvas = transformed;
+	}
+	/**
+	* Re-arms WASM detection without discarding the captured result.
+	*
+	* Detection-session teardown runs immediately after a successful capture.
+	* The captured canvases must remain available for the subsequent upload and
+	* are only replaced by `setCapturedCanvases()` or cleared by a full reset.
+	*/
+	resetDetectionState() {
+		super.reset();
+		this.lastProcessResult = null;
+		this.lastDecodedBarcode = null;
+	}
+	reset() {
+		this.resetDetectionState();
+		this.capturedCanvas = null;
+		this.originalCapturedCanvas = null;
+	}
+	async dispose() {
+		await super.dispose();
+		this.barcodeEnhancementModelLoaded = false;
+	}
+};
+//#endregion
+//#region ../infra/src/wasm/idCaptureDefaults.ts
+/**
+* Default WASM thresholds for ID capture quality checks.
+* Matches SDK 1's `wasmWorkflowsConfig.ts` production ID profile. Explicit
+* consumer and experiment overrides still take precedence in Core.
+*/
+const DEFAULT_ID_CAPTURE_THRESHOLDS = {
+	blurThreshold: .2,
+	blurChangeThreshold: .2,
+	glareThreshold: .3,
+	clsThreshold: .98,
+	sideThreshold: .8,
+	iouThreshold: .8,
+	idDetectedTimeout: 1e4,
+	autocaptureTimeout: 5e3,
+	framesAggregationInterval: 1700
+};
+/**
+* Default geometry parameters for ID detection.
+* Window dimensions must be provided at runtime.
+*/
+const DEFAULT_ID_CAPTURE_GEOMETRY = {
+	areaDown: 25e3,
+	areaUp: 55e3,
+	areaIOSPassportUp: 3e4,
+	areaIOSPassportDown: 2e4,
+	widthIOSUp: 160,
+	widthIOSDown: 85,
+	widthDown: 110,
+	widthUp: 205
+};
+//#endregion
+export { CameraCompositor as i, DEFAULT_ID_CAPTURE_THRESHOLDS as n, IdCaptureProvider as r, DEFAULT_ID_CAPTURE_GEOMETRY as t };