@incodetech/core 2.4.0 → 2.4.1-agentic.1

package/dist/{deepsightService-CKTYDIXD.esm.js → deepsightLoader-B7DEYoyY.esm.js}

@@ -1,28 +1,25 @@
-import { t as api } from "./api-Cz90EHyu.esm.js";
-import { h as isBrowserSimulation, v as getThumbmarkId, x as fingerprintSignalsReporter } from "./sessionInitializer-BTjYgE-V.esm.js";
-import { t as addDeviceStats } from "./stats-BEvexnKC.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-Dp2V-Uct.esm.js";
+import { u as trueSightLog } from "./trueSightService-GuLthUVK.esm.js";
+import { t as SDK_VERSION } from "./sdkVersion-CDd_gaR7.esm.js";
+import { C as fingerprintSignalsReporter, S as BrowserEnvironmentProvider, n as getDisableIpify, r as getFingerprintEnabled, v as isBrowserSimulation, w as SDK_PLATFORM, x as IpifyProvider } from "./sessionInitializer-DsL7X2j9.esm.js";
 import { t as getParsedUserAgent } from "./getParsedUserAgent-DhQPeKqw.esm.js";
 import { t as getUserAgent } from "./getBrowser-CBiibsL-.esm.js";
-import { i as requestCameraAccess, o as stopCameraStream } from "./camera-sIa9ceW2.esm.js";
-import { t as IncodeCanvas } from "./canvas-BxFzWTt-.esm.js";
-import { t as createHiddenVideoElement } from "./video-BtSWtHy1.esm.js";
+import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-BtiR5pig.esm.js";
+import { t as MotionSensorProvider } from "./MotionSensorProvider-DYxh8TjR.esm.js";
 import { t as getDeviceInfo } from "./getDeviceClass-CeBiEayS.esm.js";
+import { n as runVirtualCameraCheck } from "./virtualCameraCheck-eFOm2C9q.esm.js";
 //#region src/internal/deepsight/metadataService.ts
-function createMetadataService(wasmUtil, visibility, browserEnv, ipLookup) {
+function createMetadataService(wasmUtil, browserEnv, ipLookup) {
 	return {
 		async initialize(sdkVersion, disableIpify = false, disableFingerprint = false) {
-			wasmUtil.setSdkPlatform("WEBAPP");
+			wasmUtil.setSdkPlatform(SDK_PLATFORM);
 			wasmUtil.setSdkVersion(sdkVersion);
 			const ua = getUserAgent();
 			const parsedUa = getParsedUserAgent(ua);
 			const isMobile = /Android|iPhone|iPad|iPod/i.test(ua);
 			const deviceInfo = getDeviceInfo();
 			let fingerprintHash = "";
-			if (!disableFingerprint) try {
-				fingerprintHash = await getThumbmarkId();
-			} catch {
-				fingerprintHash = browserEnv.generateCanvasFingerprint();
-			}
+			if (!disableFingerprint) fingerprintHash = browserEnv.generateCanvasFingerprint();
 			const ip = disableIpify ? "" : await ipLookup.getIp();
 			const screenDimensions = browserEnv.getScreenDimensions();
 			const model = [parsedUa.device.vendor, parsedUa.device.model].filter(Boolean).join(" ");
@@ -31,6 +28,7 @@ function createMetadataService(wasmUtil, visibility, browserEnv, ipLookup) {
 				model,
 				os: parsedUa.os.name ?? "",
 				osVersion: parsedUa.os.version ?? "",
+				osVer: parsedUa.os.version ?? "",
 				screenDimensions,
 				numTouchPoints: deviceInfo.maxTouchPoints,
 				fingerprintHash,
@@ -84,10 +82,7 @@ function createMetadataService(wasmUtil, visibility, browserEnv, ipLookup) {
 		setMotionStatus(status) {
 			wasmUtil.setMotionStatus(status);
 		},
-		setBackgroundMode(backgroundMode) {
-			wasmUtil.setBackgroundMode(backgroundMode || visibility.wasBackgrounded);
-			visibility.reset();
-		},
+		setBackgroundMode(_backgroundMode) {},
 		estimatePerformance() {
 			return wasmUtil.estimatePerformance();
 		},
@@ -130,60 +125,15 @@ function createMotionStatusService(motionSensor) {
 	};
 }
 //#endregion
-//#region src/internal/virtualCameraCheck.ts
-const frameSources = {
-	front: "FRONT_ID",
-	back: "BACK_ID",
-	selfie: "SELFIE"
-};
-/**
-* Sends the analyzed frame image to the backend for logging.
-*/
-async function logFrame({ source, base64Image, token }) {
-	try {
-		return (await api.post("/omni/log/frame/v2", { base64Image }, {
-			query: { source },
-			headers: { "X-Incode-Hardware-Id": token }
-		})).data;
-	} catch {
-		return;
-	}
-}
-/**
-* Runs the WASM virtual camera check and handles logging and stats.
-*/
-async function runVirtualCameraCheck({ wasmUtil, source, token }) {
-	const output = {
-		canvas: null,
-		itr: null,
-		skipped: null
-	};
-	await wasmUtil.poc(output);
-	if (output.skipped !== false) return;
-	if (output.canvas && token) {
-		const base64Image = new IncodeCanvas(output.canvas).getBase64Image();
-		if (base64Image) logFrame({
-			source,
-			base64Image,
-			token
-		});
-	}
-	if (output.itr === true) {
-		addDeviceStats({ virtualCameraDetected: true });
-		wasmUtil.setZc("FAIL");
-	} else if (output.itr === false) wasmUtil.setZc("PASS");
-}
-//#endregion
 //#region src/internal/deepsight/deepsightService.ts
 function createDeepsightService(config) {
-	const metadata = createMetadataService(config.wasmUtil, config.visibility, config.browserEnv, config.ipLookup);
+	const metadata = createMetadataService(config.wasmUtil, config.browserEnv, config.ipLookup);
 	const motion = createMotionStatusService(config.motionSensor);
 	const finalizeCaptureMetadata = () => {
 		metadata.preparePipelineState();
 		const motionStatus = motion.check();
 		metadata.setMotionStatus(motionStatus);
 		metadata.getCheck();
-		metadata.setBackgroundMode(false);
 	};
 	return {
 		metadata,
@@ -212,16 +162,7 @@ function createDeepsightService(config) {
 				token: sessionToken
 			});
 		},
-		async performPrcCheck(params) {
-			const prcStream = await requestCameraAccess(params.constraints);
-			const hiddenVideo = createHiddenVideoElement(prcStream);
-			try {
-				await config.wasmUtil.prc();
-			} finally {
-				hiddenVideo.dispose();
-				stopCameraStream(prcStream);
-			}
-		},
+		async performPrcCheck(_params) {},
 		async analyzeFrame(imageData) {
 			await motion.start();
 			await metadata.analyzeFrame(imageData);
@@ -249,4 +190,29 @@ function createDeepsightService(config) {
 	};
 }
 //#endregion
-export { frameSources as n, runVirtualCameraCheck as r, createDeepsightService as t };
+//#region src/internal/deepsight/deepsightLoader.ts
+async function loadDeepsightSession(options) {
+	try {
+		return await loadDeepsightSessionInternal(options);
+	} catch (error) {
+		trueSightLog("warning", "deepsight", "other", `deepsight load failed error=${String(error)}`);
+		throw error;
+	}
+}
+async function loadDeepsightSessionInternal(options) {
+	setWasmDsFlagSync(options.ds === true);
+	const service = createDeepsightService({
+		sdkVersion: SDK_VERSION,
+		wasmUtil: await WasmUtilProvider.getInstance(),
+		browserEnv: new BrowserEnvironmentProvider(),
+		motionSensor: new MotionSensorProvider(),
+		ipLookup: new IpifyProvider()
+	});
+	const disableIpify = options.disableIpify ?? getDisableIpify();
+	const disableFingerprint = options.disableFingerprint ?? !getFingerprintEnabled();
+	await service.initialize(disableIpify, disableFingerprint);
+	await service.startMotionSensors();
+	return service;
+}
+//#endregion
+export { loadDeepsightSession };

package/dist/{createCameraCycleOwnership-Dj_LHUvN.esm.js → desktopCameraElection-BGMtYwk3.esm.js}

@@ -1,7 +1,12 @@
-import { t as getTimestamp } from "./IBrowserEnvironmentCapability-DEaRRk-R.esm.js";
-import { c as wasmRuntime, l as CAMERA_CYCLE_OWNERSHIP_DOMAIN, u as getCameraCycleOwnershipDomain } from "./warmup-BElYWRh7.esm.js";
-import { t as api, u as endpoints } from "./api-Cz90EHyu.esm.js";
+import { n as getTimestamp } from "./IBrowserEnvironmentCapability-D7JG7ML3.esm.js";
+import { d as getCameraCycleOwnershipDomain, l as wasmRuntime, u as CAMERA_CYCLE_OWNERSHIP_DOMAIN } from "./warmup-DtB0DJpl.esm.js";
+import { i as utilityWasmApi } from "./WasmUtilProvider-Dp2V-Uct.esm.js";
+import { t as api, u as endpoints } from "./api-CpP4PS4S.esm.js";
 import { t as fromCallback } from "./xstate-actors.esm-8Gzepa_A.esm.js";
+import { l as markCameraGrantedInDocument, n as enumerateVideoDevices, o as clearCameraGrantedInDocument, s as isCameraDenialErrorName } from "./camera-E_Kcre4O.esm.js";
+import { l as queryCameraPermission } from "./permissionServices-D190ATGD.esm.js";
+import { r as selectBestBackDevice, t as isBackCameraLabel } from "./backCameraLabel-yda5ugE4.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-DoIWuKI8.esm.js";
 //#region ../infra/src/capabilities/ICameraCycleCapability.ts
 /**
 * Fixed protected-endpoint identifiers owned by ml-wasm-kit.
@@ -30,6 +35,57 @@ async function flagIdManualReview() {
 	} catch {}
 }
 //#endregion
+//#region ../infra/src/media/cameraCycleFailure.ts
+/**
+* Reads the `DOMException`-style name of what the kit's camera step handed to
+* `onCameraFailed`. The kit forwards the browser's rejection unchanged on every
+* branch but one, so this is the error's own `name` when it has one. The
+* exception is the unnamed iPad front-camera failure; see
+* {@link classifyCameraCycleFailure}. That value has no name, so this returns
+* `undefined` for it.
+*/
+function cameraCycleFailureName(error) {
+	if (typeof error !== "object" || error === null) return;
+	const { name } = error;
+	return typeof name === "string" && name.length > 0 ? name : void 0;
+}
+/**
+* True for the value the kit's iPad front-camera branch reports for every
+* `getUserMedia` rejection. `InitialStreamAcquisition::formatFailureForHost`
+* copies the error's own enumerable properties into a plain object tagged
+* `type: 'permissionDenied'`, which drops the prototype `name` getter. A busy
+* camera and a real denial therefore look the same, and the branch never
+* retries.
+*/
+function isUnnamedIpadCameraFailure(error) {
+	return typeof error === "object" && error !== null && cameraCycleFailureName(error) === void 0 && error.type === "permissionDenied";
+}
+/** How long a permission query may take before the failure counts as unknown. */
+const PERMISSION_QUERY_TIMEOUT_MS = 1e3;
+async function queryWithTimeout(query) {
+	let timer;
+	try {
+		return await Promise.race([query(), new Promise((resolve) => {
+			timer = setTimeout(() => resolve("prompt"), PERMISSION_QUERY_TIMEOUT_MS);
+		})]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+/**
+* Resolves what an `onCameraFailed` value means before anyone routes on it.
+* Named failures pass through unchanged. For the unnamed iPad front-camera
+* failure, the browser's camera permission decides: `denied` becomes a
+* `NotAllowedError`, so the permission screen handles it. Anything else stays
+* unnamed and takes the generic, retryable error path. The SDK's own
+* permission step succeeded moments before the camera step, so a failure there
+* is far more likely a busy or over-constrained camera than a denial.
+*/
+async function classifyCameraCycleFailure(error, query = queryCameraPermission) {
+	if (!isUnnamedIpadCameraFailure(error)) return error;
+	return await queryWithTimeout(query) === "denied" ? new DOMException("Camera permission denied", "NotAllowedError") : error;
+}
+//#endregion
 //#region ../infra/src/providers/wasm/CameraCycleProvider.ts
 function asRecord(value) {
 	return typeof value === "object" && value !== null ? value : null;
@@ -123,12 +179,45 @@ function sanitizeProtectedResponse(request, raw) {
 	}
 }
 var CameraCycleProvider = class {
-	constructor(runtime = wasmRuntime) {
+	constructor(runtime = wasmRuntime, deepsightFlag = utilityWasmApi) {
 		this.runtime = runtime;
+		this.deepsightFlag = deepsightFlag;
 		this[CAMERA_CYCLE_OWNERSHIP_DOMAIN] = getCameraCycleOwnershipDomain(runtime);
 	}
-	adoptStream(stream, constraints, options) {
-		return this.runtime.adoptCameraStream(stream, constraints, options);
+	/**
+	* Fills `ds` from the SDK's deepsight flag — the JS-side `dsEnabled_` the
+	* utility facade replays into every `poc`/`rsp` call — unless the caller set
+	* it, so the in-step pre-capture IAD sees the flag `prc` used to receive.
+	*
+	* A failure is held until the step settles and classified first
+	* (`classifyCameraCycleFailure`): the unnamed iPad front-camera failure
+	* becomes a `NotAllowedError` only when the browser reports the camera
+	* permission as denied.
+	*
+	* Also feeds the document camera-grant memo, which `getUserMedia` paths feed
+	* through `trackCameraAcquisition` and the kit cannot: READY marks the grant,
+	* a permission denial clears it, any other failure leaves it untouched.
+	*/
+	async startCameraCycle(options, callbacks) {
+		const step = {};
+		await this.runtime.startCameraCycle({
+			...options,
+			ds: options.ds ?? this.deepsightFlag.getDsEnabled()
+		}, {
+			onNewFrame: callbacks.onNewFrame,
+			onFirstFrame: callbacks.onFirstFrame,
+			onCameraReady: (audioStream) => {
+				markCameraGrantedInDocument();
+				callbacks.onCameraReady(audioStream);
+			},
+			onCameraFailed: (error) => {
+				step.failure ??= { error };
+			}
+		});
+		if (!step.failure) return;
+		const error = await classifyCameraCycleFailure(step.failure.error);
+		if (isCameraDenialErrorName(cameraCycleFailureName(error))) clearCameraGrantedInDocument();
+		callbacks.onCameraFailed(error);
 	}
 	setWorkflowConsuming(workflow, consuming) {
 		if (consuming && (workflow === 2 || workflow === 3)) throw new Error("[Incode SDK] Protected still capture is unavailable for video-selfie workflows.");
@@ -205,7 +294,7 @@ const runProtectedAttempt = ({ input, sendBack, receive }) => {
 	let pendingReadyStream = null;
 	let pendingDeliveryEvent = null;
 	let visibilityGeneration = 0;
-	let unadoptedStream = input.streamSource.kind === "preAcquired" ? input.streamSource.stream : null;
+	let hostStream = null;
 	let resourcesReleased = false;
 	let cycleTransferred = false;
 	let commandQueue = Promise.resolve();
@@ -223,9 +312,8 @@ const runProtectedAttempt = ({ input, sendBack, receive }) => {
 		if (startupStartedAt === void 0 || !input.onStartupTiming) return;
 		try {
 			input.onStartupTiming({
-				acquireMs: startupTiming.acquireMs ?? 0,
-				adoptMs: startupTiming.adoptMs ?? 0,
-				prcMs: startupTiming.prcMs ?? 0,
+				cameraStepMs: startupTiming.cameraStepMs ?? 0,
+				...startupTiming.firstFrameMs === void 0 ? {} : { firstFrameMs: startupTiming.firstFrameMs },
 				displayStreamMs: startupTiming.displayStreamMs ?? 0,
 				configureMs: startupTiming.configureMs ?? 0,
 				recorderMs: startupTiming.recorderMs ?? 0,
@@ -237,12 +325,13 @@ const runProtectedAttempt = ({ input, sendBack, receive }) => {
 	const sendParent = (event) => {
 		sendBack(event);
 	};
-	const releaseRawStream = (stream) => {
+	const stopTracks = (stream) => {
+		if (!stream) return;
 		try {
-			input.releaseUnadoptedStream(stream);
+			stream.getTracks().forEach((track) => track.stop());
 		} catch {}
 	};
-	const reportFailure = (stage, code, http = {}) => {
+	const reportFailure = (stage, code, details = {}) => {
 		if (!active) return;
 		sendParent({
 			type: "PROTECTED_ATTEMPT_FAILED",
@@ -250,7 +339,7 @@ const runProtectedAttempt = ({ input, sendBack, receive }) => {
 			failure: {
 				stage,
 				code,
-				...http
+				...details
 			}
 		});
 	};
@@ -272,8 +361,8 @@ const runProtectedAttempt = ({ input, sendBack, receive }) => {
 		postPocDisplayStream = null;
 		pendingDeliveryEvent = null;
 		finalizeDeferred = false;
-		if (unadoptedStream) releaseRawStream(unadoptedStream);
-		unadoptedStream = null;
+		stopTracks(hostStream);
+		hostStream = null;
 		if (cycleTransferred) input.cycleOwnership.releaseByAttempt();
 		else input.cycleOwnership.releaseByController();
 	};
@@ -283,8 +372,8 @@ const runProtectedAttempt = ({ input, sendBack, receive }) => {
 		ready = false;
 		releaseResources();
 	};
-	const failClosed = (stage, code) => {
-		reportFailure(stage, code);
+	const failClosed = (stage, code, details = {}) => {
+		reportFailure(stage, code, details);
 		deactivate();
 	};
 	const stopConsuming = () => {
@@ -345,38 +434,52 @@ const runProtectedAttempt = ({ input, sendBack, receive }) => {
 		let stage = "acquire";
 		try {
 			startupStartedAt = now();
-			const acquisitionStartedAt = now();
-			const acquired = input.streamSource.kind === "preAcquired" ? {
-				stream: input.streamSource.stream,
-				constraints: input.streamSource.constraints
-			} : await input.streamSource.acquire(abortController.signal);
-			startupTiming.acquireMs = Math.max(0, now() - acquisitionStartedAt);
+			const cameraStepStartedAt = now();
+			const options = await input.cameraStep();
 			if (!active || abortController.signal.aborted) {
-				releaseRawStream(acquired.stream);
+				stopTracks(options.hs);
 				return;
 			}
-			unadoptedStream = acquired.stream;
-			stage = "adopt";
-			if (input.beforeAdopt) {
-				await input.beforeAdopt(acquired.stream);
-				if (!active || abortController.signal.aborted) return;
+			hostStream = options.hs ?? null;
+			if (input.preflight) {
+				stage = "configure";
+				input.preflight();
+				stage = "acquire";
+			}
+			const step = { outcome: null };
+			await input.cycle.startCameraCycle(options, {
+				onFirstFrame: () => {
+					startupTiming.firstFrameMs ??= Math.max(0, now() - cameraStepStartedAt);
+				},
+				onCameraReady: (audioStream) => {
+					stopTracks(audioStream);
+					step.outcome ??= { ready: true };
+				},
+				onCameraFailed: (error) => {
+					step.outcome ??= {
+						ready: false,
+						error
+					};
+				}
+			});
+			startupTiming.cameraStepMs = Math.max(0, now() - cameraStepStartedAt);
+			if (!active) return;
+			if (step.outcome === null) throw new Error("protected camera step ended without an outcome");
+			if (!step.outcome.ready) {
+				failClosed("acquire", "protected-attempt-acquire-failed", { errorName: cameraCycleFailureName(step.outcome.error) });
+				return;
 			}
-			const adoption = measure(() => input.cycle.adoptStream(acquired.stream, acquired.constraints, input.captureOptions));
-			startupTiming.adoptMs = adoption.durationMs;
-			if (!adoption.value) throw new Error("protected camera stream adoption was rejected");
-			unadoptedStream = null;
 			input.cycleOwnership.transferToAttempt();
 			cycleTransferred = true;
-			stage = "prc";
-			const prcStartedAt = now();
-			await input.runPrc();
-			startupTiming.prcMs = Math.max(0, now() - prcStartedAt);
-			if (!active) return;
 			const displayStreamResult = measure(() => input.cycle.getUnprotectedStream());
 			startupTiming.displayStreamMs = displayStreamResult.durationMs;
 			const displayStream = displayStreamResult.value;
 			if (!displayStream) throw new Error("protected camera cycle did not provide a stream");
 			stage = "configure";
+			if (input.afterReady) {
+				await input.afterReady(displayStream);
+				if (!active) return;
+			}
 			const configureStartedAt = now();
 			await input.configureWorkflow();
 			startupTiming.configureMs = Math.max(0, now() - configureStartedAt);
@@ -833,4 +936,38 @@ function createCameraCycleOwnership(cycle) {
 	};
 }
 //#endregion
-export { flagIdManualReview as a, flagFaceManualReview as i, runProtectedAttempt as n, PROTECTED_CAPTURE_TARGET as o, cameraCycleProvider as r, createCameraCycleOwnership as t };
+//#region src/internal/camera/desktopCameraElection.ts
+/**
+* Picks the exact camera the kit's camera step should open on desktop.
+*
+* On desktop, ml-wasm-kit ignores the facing preference and always requests
+* `facingMode: 'user'` (`InitialStreamConstraints::desktopVideoSpec`), but it
+* honours an exact device id (`di`). Electing the device here restores the
+* ENG-47583 host corrections without JavaScript opening a camera:
+* - a rear capture pins the best back-labelled device, so a Surface opens its
+*   rear camera for ID (#543);
+* - a front capture pins the first device not labelled as a back camera, but
+*   only when a back camera exists, so the browser cannot hand the rear camera
+*   back for a selfie after an ID capture (#551).
+*
+* Returns `''`, which leaves the choice to the kit, off desktop, when labels
+* are unavailable, or when nothing needs pinning. Labels are available here
+* because the SDK's permission step runs before every capture. Like #551,
+* "first non-back device" can pick a Windows Hello IR sensor on machines that
+* expose one; that tradeoff is unchanged.
+*/
+async function electDesktopCameraDevice(facing) {
+	if (getDeviceClass() !== "desktop") return "";
+	let devices;
+	try {
+		devices = await enumerateVideoDevices();
+	} catch {
+		return "";
+	}
+	const backDevices = devices.filter((device) => isBackCameraLabel(device.label));
+	if (backDevices.length === 0) return "";
+	if (facing === "environment") return selectBestBackDevice(backDevices).deviceId;
+	return devices.find((device) => device.label !== "" && !isBackCameraLabel(device.label))?.deviceId ?? "";
+}
+//#endregion
+export { flagFaceManualReview as a, cameraCycleProvider as i, createCameraCycleOwnership as n, flagIdManualReview as o, runProtectedAttempt as r, PROTECTED_CAPTURE_TARGET as s, electDesktopCameraDevice as t };

package/dist/device.esm.js

@@ -1,8 +1,8 @@
-import { a as isIOS, f as isTabletWithoutAndroid, l as isIslandBrowser, n as isAndroidWebView, o as isIOSWebView, r as isBraveBrowser, s as isIPad } from "./platform-DkcRc9JV.esm.js";
+import { a as isIOS, l as isIslandBrowser, n as isAndroidWebView, o as isIOSWebView, p as isTabletWithoutAndroid, r as isBraveBrowser, s as isIPad } from "./platform-aPh7gTWh.esm.js";
 import { n as getUserAgentBrands, t as getUserAgent } from "./getBrowser-CBiibsL-.esm.js";
 import { t as getBrowser } from "./getBrowser-Cbe1C4Tn.esm.js";
 import { t as getDeviceInfo } from "./getDeviceClass-CeBiEayS.esm.js";
-import { t as getDeviceClass } from "./getDeviceClass-bsWdEDxP.esm.js";
+import { t as getDeviceClass } from "./getDeviceClass-DoIWuKI8.esm.js";
 //#region src/internal/device/browserSupportClassification.ts
 /**
 * Third-party in-app browsers. These are real WebViews — `isAndroidWebView` and

package/dist/document-capture.d.ts

@@ -1,3 +1,3 @@
-import { a as DocumentCaptureErrorCode, c as DocumentType, n as DOCUMENT_CAPTURE_ERROR_CODES, r as DocumentCaptureConfig, s as DocumentCaptureNextPageType } from "./types-DUnFZ08M.js";
-import { a as DocumentCaptureActor, i as createDocumentCaptureManagerFromActor, n as DocumentCaptureState, o as documentCaptureMachine, r as createDocumentCaptureManager, t as DocumentCaptureManager } from "./documentCaptureManager-DkyDtm3Y.js";
-export { DOCUMENT_CAPTURE_ERROR_CODES, type DocumentCaptureActor, type DocumentCaptureConfig, type DocumentCaptureErrorCode, type DocumentCaptureManager, type DocumentCaptureNextPageType, type DocumentCaptureState, type DocumentType, createDocumentCaptureManager, createDocumentCaptureManagerFromActor, documentCaptureMachine };
+import { a as DocumentCaptureErrorCode, c as DocumentType, n as DOCUMENT_CAPTURE_ERROR_CODES, r as DocumentCaptureConfig, s as DocumentCaptureNextPageType, u as DocumentUploadStatus } from "./types-CyNndVAT.js";
+import { a as DocumentCaptureActor, i as createDocumentCaptureManagerFromActor, n as DocumentCaptureState, o as documentCaptureMachine, r as createDocumentCaptureManager, t as DocumentCaptureManager } from "./documentCaptureManager-CD5iQiUI.js";
+export { DOCUMENT_CAPTURE_ERROR_CODES, type DocumentCaptureActor, type DocumentCaptureConfig, type DocumentCaptureErrorCode, type DocumentCaptureManager, type DocumentCaptureNextPageType, type DocumentCaptureState, type DocumentType, type DocumentUploadStatus, createDocumentCaptureManager, createDocumentCaptureManagerFromActor, documentCaptureMachine };

package/dist/document-capture.esm.js

@@ -1,3 +1,3 @@
-import { r as DOCUMENT_CAPTURE_ERROR_CODES, t as documentCaptureMachine } from "./documentCaptureStateMachine-B8i7GnLh.esm.js";
-import { n as createDocumentCaptureManagerFromActor, t as createDocumentCaptureManager } from "./documentCaptureManager-DUJwpKC5.esm.js";
+import { r as DOCUMENT_CAPTURE_ERROR_CODES, t as documentCaptureMachine } from "./documentCaptureStateMachine-DCvWQhFG.esm.js";
+import { n as createDocumentCaptureManagerFromActor, t as createDocumentCaptureManager } from "./documentCaptureManager-DLPqruXJ.esm.js";
 export { DOCUMENT_CAPTURE_ERROR_CODES, createDocumentCaptureManager, createDocumentCaptureManagerFromActor, documentCaptureMachine };