@incodetech/core 2.4.0 → 2.4.1-agentic

package/dist/{deepsightLoader-DeNvGU3c.esm.js → deepsightLoader-DMxtowCm.esm.js}

@@ -1,31 +1,10 @@
-import { t as WasmUtilProvider } from "./WasmUtilProvider-DtJuBdt-.esm.js";
-import { u as trueSightLog } from "./trueSightService-BMT-TubT.esm.js";
-import { t as SDK_VERSION } from "./sdkVersion-CsIbltJF.esm.js";
-import { _ as IpifyProvider, b as BrowserEnvironmentProvider, n as getFingerprintEnabled, t as getDisableIpify } from "./sessionInitializer-BTjYgE-V.esm.js";
-import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-CYj5LL9z.esm.js";
+import { t as WasmUtilProvider } from "./WasmUtilProvider-GTkoJyFY.esm.js";
+import { u as trueSightLog } from "./trueSightService-BujtUIW6.esm.js";
+import { t as SDK_VERSION } from "./sdkVersion-C3_P-Qbq.esm.js";
+import { b as IpifyProvider, n as getFingerprintEnabled, t as getDisableIpify, x as BrowserEnvironmentProvider } from "./sessionInitializer-CWFT4dfw.esm.js";
+import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-BhU5H2oR.esm.js";
 import { t as MotionSensorProvider } from "./MotionSensorProvider-DYxh8TjR.esm.js";
-import { t as createDeepsightService } from "./deepsightService-CKTYDIXD.esm.js";
-//#region ../infra/src/providers/browser/VisibilityProvider.ts
-var VisibilityProvider = class {
-	constructor() {
-		this._wasBackgrounded = false;
-		this.visibilityChangeHandler = this.onVisibilityChange.bind(this);
-		document.addEventListener("visibilitychange", this.visibilityChangeHandler);
-	}
-	get wasBackgrounded() {
-		return this._wasBackgrounded;
-	}
-	reset() {
-		this._wasBackgrounded = false;
-	}
-	cleanup() {
-		document.removeEventListener("visibilitychange", this.visibilityChangeHandler);
-	}
-	onVisibilityChange() {
-		if (document.hidden) this._wasBackgrounded = true;
-	}
-};
-//#endregion
+import { t as createDeepsightService } from "./deepsightService-twg3bXqY.esm.js";
 //#region src/internal/deepsight/deepsightLoader.ts
 async function loadDeepsightSession(options) {
 	try {
@@ -40,7 +19,6 @@ async function loadDeepsightSessionInternal(options) {
 	const service = createDeepsightService({
 		sdkVersion: SDK_VERSION,
 		wasmUtil: await WasmUtilProvider.getInstance(),
-		visibility: new VisibilityProvider(),
 		browserEnv: new BrowserEnvironmentProvider(),
 		motionSensor: new MotionSensorProvider(),
 		ipLookup: new IpifyProvider()

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

@@ -1,14 +1,9 @@
-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 { S as fingerprintSignalsReporter, _ as isBrowserSimulation } from "./sessionInitializer-CWFT4dfw.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 getDeviceInfo } from "./getDeviceClass-CeBiEayS.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");
@@ -18,11 +13,7 @@ function createMetadataService(wasmUtil, visibility, browserEnv, ipLookup) {
 			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 +22,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 +76,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();
 		},
@@ -137,53 +126,34 @@ const frameSources = {
 	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.
+* Runs the native post-capture check (`poc`).
+*
+* Since ml-wasm-kit v2.14.53 (ADR 0008, single-run IAD) the binding keeps its
+* output argument for arity but never writes into it: the post-capture
+* verdicts travel only inside the signed capture metadata that the protected
+* upload carries. The JavaScript verdict this function used to derive from
+* that output — the `/omni/log/frame/v2` frame upload, the
+* `virtualCameraDetected` device stat and `setZc` — is gone with it (the same
+* removal ms-incodesmile-web made in ENG-58409). The name is kept so the
+* protected attempts' POC step reads the same.
 */
-async function runVirtualCameraCheck({ wasmUtil, source, token }) {
-	const output = {
+async function runVirtualCameraCheck({ wasmUtil }) {
+	await wasmUtil.poc({
 		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 +182,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);

package/dist/{createCameraCycleOwnership-Dj_LHUvN.esm.js → desktopCameraElection-kHY2IDJi.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-BkfxQZsC.esm.js";
+import { i as utilityWasmApi } from "./WasmUtilProvider-GTkoJyFY.esm.js";
+import { t as api, u as endpoints } from "./api-BO8JA7Pf.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-DnBAN_hW.esm.js";
+import { a as selectBestBackDevice, r as isBackCameraLabel } from "./backCameraStream-C5_NNfUN.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";
+import { a as DocumentCaptureErrorCode, c as DocumentType, n as DOCUMENT_CAPTURE_ERROR_CODES, r as DocumentCaptureConfig, s as DocumentCaptureNextPageType } from "./types-ZTZelfbM.js";
+import { a as DocumentCaptureActor, i as createDocumentCaptureManagerFromActor, n as DocumentCaptureState, o as documentCaptureMachine, r as createDocumentCaptureManager, t as DocumentCaptureManager } from "./documentCaptureManager-6tnnDkMX.js";
 export { DOCUMENT_CAPTURE_ERROR_CODES, type DocumentCaptureActor, type DocumentCaptureConfig, type DocumentCaptureErrorCode, type DocumentCaptureManager, type DocumentCaptureNextPageType, type DocumentCaptureState, type DocumentType, 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-BCwD5Rto.esm.js";
+import { n as createDocumentCaptureManagerFromActor, t as createDocumentCaptureManager } from "./documentCaptureManager-CMSC_Mhd.esm.js";
 export { DOCUMENT_CAPTURE_ERROR_CODES, createDocumentCaptureManager, createDocumentCaptureManagerFromActor, documentCaptureMachine };

package/dist/{documentCaptureManager-DkyDtm3Y.d.ts → documentCaptureManager-6tnnDkMX.d.ts}

@@ -2,7 +2,7 @@ import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorR
 import { t as Manager } from "./Manager-C9T5amUN.js";
 import "./Actor-DpTj5PFb.js";
 import { n as PermissionStatus, t as PermissionResult } from "./types-BEwVKkLJ.js";
-import { a as DocumentCaptureErrorCode, c as DocumentType, i as DocumentCaptureContext, l as DocumentUploadResponse, o as DocumentCaptureInput, r as DocumentCaptureConfig, s as DocumentCaptureNextPageType, t as CapturedDocument, u as FinalizeDocumentResponse } from "./types-DUnFZ08M.js";
+import { a as DocumentCaptureErrorCode, c as DocumentType, i as DocumentCaptureContext, l as DocumentUploadResponse, o as DocumentCaptureInput, r as DocumentCaptureConfig, s as DocumentCaptureNextPageType, t as CapturedDocument, u as FinalizeDocumentResponse } from "./types-ZTZelfbM.js";
 //#region src/modules/document-capture/documentCaptureStateMachine.d.ts
 declare const documentCaptureMachine: StateMachine<DocumentCaptureContext, {
   type: "CAPTURE";
@@ -192,6 +192,10 @@ declare const documentCaptureMachine: StateMachine<DocumentCaptureContext, {
     params: NonReducibleUnknown;
   };
 }>, Values<{
+  isOutOfAttempts: {
+    type: "isOutOfAttempts";
+    params: unknown;
+  };
   allowSkip: {
     type: "allowSkip";
     params: unknown;
@@ -260,7 +264,7 @@ declare const documentCaptureMachine: StateMachine<DocumentCaptureContext, {
   readonly on: {
     readonly CLOSE: ".closed";
   };
-  readonly context: ({ input }: {
+  readonly context: ({ input, self }: {
     spawn: {
       <TSrc extends "uploadDocument" | "requestPermission" | "checkPermission" | "initCamera" | "finalizeDocumentRequest">(logic: TSrc, ...[options]: ({
         src: "uploadDocument";
@@ -524,6 +528,10 @@ declare const documentCaptureMachine: StateMachine<DocumentCaptureContext, {
   };
   readonly states: {
     readonly tutorial: {
+      readonly always: {
+        readonly target: "finished";
+        readonly guard: "isOutOfAttempts";
+      };
       readonly on: {
         readonly OPEN_METHOD_SELECTION: {
           readonly actions: "openMethodSelection";
@@ -1951,6 +1959,8 @@ type DocumentCaptureCapturingState = {
   pageNumber: number;
   /** Resolved max upload size in bytes (defaults to 10MB when unconfigured). */
   maxFileSize: number;
+  title: string | undefined;
+  text: string | undefined;
 };
 type DocumentCapturePreviewState = {
   status: 'preview';
@@ -1985,6 +1995,8 @@ type DocumentCaptureClosedState = {
 };
 type DocumentCaptureNextPageState = {
   status: 'nextPage';
+  title: string | undefined;
+  text: string | undefined;
   imageBase64: string;
   fileType: string;
   fileName: string;

package/dist/{documentCaptureManager-DUJwpKC5.esm.js → documentCaptureManager-CMSC_Mhd.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Du2A4-Qr.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CQteqXfy.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
-import { n as DEFAULT_MAX_FILE_SIZE, r as DOCUMENT_CAPTURE_ERROR_CODES, t as documentCaptureMachine } from "./documentCaptureStateMachine-B8i7GnLh.esm.js";
+import { n as DEFAULT_MAX_FILE_SIZE, r as DOCUMENT_CAPTURE_ERROR_CODES, t as documentCaptureMachine } from "./documentCaptureStateMachine-BCwD5Rto.esm.js";
 //#region src/modules/document-capture/documentCaptureActor.ts
 function createDocumentCaptureActor(options) {
 	return createActor(documentCaptureMachine, { input: { config: options.config } }).start();
@@ -90,25 +90,30 @@ function getPermissionStatus(snapshot) {
 	if (snapshot.matches({ permissions: "idle" })) return "checking";
 	return "idle";
 }
+function getPageCopy(config, pageNumber) {
+	return pageNumber > 1 ? {
+		title: config.step2Title,
+		text: config.step2Text
+	} : {
+		title: config.title,
+		text: config.text
+	};
+}
 function mapState(snapshot) {
 	const typedSnapshot = snapshot;
 	const { context } = typedSnapshot;
-	if (typedSnapshot.matches("tutorial")) {
-		const isSecondPage = context.pageNumber > 1;
-		return {
-			status: "tutorial",
-			title: isSecondPage ? context.config.step2Title ?? context.config.title : context.config.title,
-			text: isSecondPage ? context.config.step2Text ?? context.config.text : context.config.text,
-			allowSkipDocumentCapture: context.config.allowSkipDocumentCapture && context.pageNumber === 1,
-			onlyCapture: context.config.onlyCapture,
-			onlyUpload: context.config.onlyUpload,
-			methodSelectionOpen: context.methodSelectionOpen,
-			onlyPdf: context.config.onlyPdf,
-			error: context.error,
-			pageNumber: context.pageNumber,
-			maxFileSize: context.config.maxFileSize
-		};
-	}
+	if (typedSnapshot.matches("tutorial")) return {
+		status: "tutorial",
+		...getPageCopy(context.config, context.pageNumber),
+		allowSkipDocumentCapture: context.config.allowSkipDocumentCapture && context.pageNumber === 1,
+		onlyCapture: context.config.onlyCapture,
+		onlyUpload: context.config.onlyUpload,
+		methodSelectionOpen: context.methodSelectionOpen,
+		onlyPdf: context.config.onlyPdf,
+		error: context.error,
+		pageNumber: context.pageNumber,
+		maxFileSize: context.config.maxFileSize
+	};
 	if (typedSnapshot.matches("permissions")) return {
 		status: "permissions",
 		permissionStatus: getPermissionStatus(typedSnapshot)
@@ -124,7 +129,8 @@ function mapState(snapshot) {
 		onlyPdf: context.config.onlyPdf,
 		error: context.error,
 		pageNumber: context.pageNumber,
-		maxFileSize: context.config.maxFileSize
+		maxFileSize: context.config.maxFileSize,
+		...getPageCopy(context.config, context.pageNumber)
 	};
 	if (typedSnapshot.matches("preview")) return {
 		status: "preview",
@@ -155,6 +161,7 @@ function mapState(snapshot) {
 	if (typedSnapshot.matches("closed")) return { status: "closed" };
 	if (typedSnapshot.matches("nextPage")) return {
 		status: "nextPage",
+		...getPageCopy(context.config, context.pageNumber + 1),
 		imageBase64: context.capturedDocument?.imageBase64 ?? "",
 		fileType: context.capturedDocument?.fileType ?? "",
 		fileName: context.capturedDocument?.file.name ?? "",