@incodetech/core 2.2.0-rc.8 → 2.3.0-rc.0

package/dist/{idCaptureManager-BJAquKfp.esm.js → idCaptureManager-Vby8oYqh.esm.js}

@@ -1,12 +1,12 @@
-import { t as BrowserStorageProvider } from "./BrowserStorageProvider-k-FDkC4W.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
+import { l as BrowserStorageProvider } from "./setup-msLybMbC.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-BqUCwLY8.esm.js";
-import { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-BX1BiLDK.esm.js";
-import { o as resetWasmMotionPrimedForModule, r as primeMotionFromUserGestureIfNeeded } from "./permissionServices-UvUcOSRb.esm.js";
-import { n as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-fi-Gq1AH.esm.js";
-import { m as resolveIdCaptureThresholds, p as resolveCaptureOptimizingTreatment } from "./idCaptureServices-CM6ki4IH.esm.js";
+import { t as setWasmDsFlagSync } from "./wasmDsFlagSync-B2e8p268.esm.js";
+import { t as BrowserVisibilityObserverProvider } from "./BrowserVisibilityObserverProvider-BrJN1B8A.esm.js";
+import { o as resetWasmMotionPrimedForModule, r as primeMotionFromUserGestureIfNeeded } from "./permissionServices-Bj_fyWtv.esm.js";
+import { a as createIdProtectedCaptureController, n as provideIdProtectedCaptureController, o as findIdProtectedCaptureController, s as getManualUploadTabs, t as idCaptureMachine } from "./idCaptureStateMachine-CmqihkUy.esm.js";
+import { v as resolveCaptureOptimizingTreatment, y as resolveIdCaptureThresholds } from "./idCaptureServices-CJIxD9ep.esm.js";
 //#region src/modules/id/digitalUpload/instrumentation.ts
 const TERMINAL_REASONS = /* @__PURE__ */ new Set(["DIGITAL_ID_REQUESTED_BUT_OTHER_PROVIDED", "ID_TYPE_UNACCEPTABLE"]);
 function isHoldingState(value) {
@@ -41,6 +41,51 @@ function mapDigitalIdScreenName(value, failReason) {
 	return "uploadDigitalid.review.default";
 }
 //#endregion
+//#region src/modules/id/deviceWallet/instrumentation.ts
+/**
+* Maps a device-wallet child-machine snapshot to a tracked screen name.
+* Family is `deviceWallet.*` — emitted cross-family under the parent
+* `idCapture` module token, same as `mapDigitalIdScreenName`. See
+* `docs/patterns/INSTRUMENTATION.md`.
+*/
+function mapDeviceWalletScreenName(value, failReason) {
+	if (value === "presenting") return "deviceWallet.wallet.default";
+	if (value === "failed") {
+		if (failReason === "NO_CREDENTIAL") return "deviceWallet.error.nocredential";
+		if (failReason === "UNSUPPORTED_PLATFORM") return "deviceWallet.error.unsupported";
+		return "deviceWallet.error.default";
+	}
+	return "deviceWallet.loading.default";
+}
+//#endregion
+//#region src/modules/digital-id-redirect/instrumentation.ts
+/**
+* Maps a digital-ID web-redirect (Trinsic iDIN/FTN) child-machine snapshot value
+* to the ID-Capture "Tracked Events" screen name. Like `digitalUpload`'s
+* `mapDigitalIdScreenName`, this is emitted cross-family under the parent
+* `idCapture` module token (all ID-Capture children ride under
+* `eventModuleNames.idCapture`) on `event.screen`.
+*
+* Names mirror the user-visible phases the ID-Capture UI renders
+* (`digitalIdRedirect.tsx`): loader / redirecting / succeeded / failed / error.
+* The provider chooser is intentionally absent — inside ID-Capture the provider
+* is preset from `config.digitalIds`, so no chooser screen is shown.
+* `finished`/`closed` are terminal and surface no screen of their own.
+*
+* TODO(design): confirm the exact strings against the digital-id-redirect Figma
+* "Tracked Events" canvas when it exists (mirrors the digitalUpload source note).
+* See docs/patterns/INSTRUMENTATION.md.
+*/
+function mapDigitalIdRedirectScreenName(value) {
+	switch (value) {
+		case "readyToRedirect": return "idCapture.digitalIdRedirect.redirecting.default";
+		case "succeeded": return "idCapture.digitalIdRedirect.succeeded.default";
+		case "failed": return "idCapture.digitalIdRedirect.failed.default";
+		case "error": return "idCapture.digitalIdRedirect.error.default";
+		default: return "idCapture.digitalIdRedirect.loader.default";
+	}
+}
+//#endregion
 //#region src/modules/id/manualUpload/instrumentation.ts
 /**
 * Maps an ID Manual Upload child-machine snapshot to the exact Figma
@@ -208,17 +253,43 @@ function shouldCaptureBack(context) {
 function shouldCaptureFront(context) {
 	return context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
 }
-function mapCaptureState(snapshot, context) {
+/**
+* Resolves the document method represented by camera-facing manager states.
+*
+* Machine context keeps `selectedDocumentType` as the literal chooser
+* selection. Direct-entry flows never dispatch `SELECT_DOCUMENT`, so resolve
+* their effective type only at the public manager boundary. An explicit
+* selection always wins, including non-camera methods. Without one, infer only
+* from the machine's already-derived available camera methods: capture-mode
+* flags such as `onlyBack` and `usSmartCapture` must not manufacture an ID
+* method for a Digital-ID-only or otherwise malformed configuration.
+*/
+function getEffectiveSelectedDocumentType(context) {
+	if (context.selectedDocumentType !== void 0) return context.selectedDocumentType;
+	let isIdAvailable = false;
+	let isPassportAvailable = false;
+	for (const docType of context.availableDocumentTypes ?? []) {
+		if (docType === "id") isIdAvailable = true;
+		if (docType === "passport") isPassportAvailable = true;
+	}
+	if (isIdAvailable && isPassportAvailable) return context.currentMode === "passport" ? "passport" : "id";
+	if (isIdAvailable) return "id";
+	if (isPassportAvailable) return "passport";
+}
+function mapCaptureState(snapshot, context, presentationStream) {
 	const captureStatus = getCaptureStatus(snapshot) ?? "initializing";
 	const { uploadError, uploadResponse } = context;
 	return {
 		status: "capture",
 		captureStatus,
-		stream: context.stream,
+		stream: presentationStream,
+		usingBackCamera: context.usingBackCamera ?? true,
 		detectionStatus: context.detectionStatus,
 		attemptsRemaining: context.attemptsRemaining,
 		uploadError,
 		currentMode: context.currentMode,
+		selectedDocumentType: getEffectiveSelectedDocumentType(context),
+		tutorialEnabled: context.config.showTutorial === true,
 		counterValue: context.counterValue,
 		orientation: context.orientation,
 		idType: context.idType,
@@ -231,14 +302,52 @@ function mapCaptureState(snapshot, context) {
 		captureFeedbackMode: context.captureFeedbackMode,
 		uploadErrorMessage: uploadError ? getErrorTitleKey(uploadError, context.currentMode) : void 0,
 		uploadErrorDescription: uploadError ? getErrorSubtitleKey(uploadError, uploadResponse, context.currentMode) : void 0,
+		acceptedDocuments: uploadResponse?.acceptedDocuments,
+		countryCode: uploadResponse?.countryCode,
 		needsBackCapture: shouldCaptureBack(context),
 		needsFrontCapture: shouldCaptureFront(context),
 		showCaptureButtonInAuto: context.config.showCaptureButtonInAuto ?? false,
 		canRetry: context.attemptsRemaining > 0
 	};
 }
-function isLoadingPhase(snapshot) {
-	return snapshot.matches({ capture: "checkingStream" }) || snapshot.matches({ capture: "initializingDeepsight" }) || snapshot.matches({ capture: "initializing" }) || snapshot.matches({ permissions: "idle" });
+function mapPermissionsState(snapshot, context) {
+	return {
+		status: "permissions",
+		permissionStatus: getPermissionStatus(snapshot) ?? "idle",
+		selectedDocumentType: getEffectiveSelectedDocumentType(context),
+		currentMode: context.currentMode,
+		tutorialEnabled: context.config.showTutorial === true
+	};
+}
+function getLoadingPhase(snapshot) {
+	if (snapshot.matches({ capture: "checkingStream" })) return "checkingStream";
+	if (snapshot.matches({ capture: "initializingDeepsight" })) return "initializingDeepsight";
+	if (snapshot.matches({ capture: "initializing" })) return "initializingCamera";
+	if (snapshot.matches({ permissions: "idle" })) return "permissionsIdle";
+}
+function mapLoadingState(snapshot, phase) {
+	return {
+		status: "loading",
+		phase,
+		tutorialEnabled: snapshot.context.config.showTutorial === true,
+		selectedDocumentType: getEffectiveSelectedDocumentType(snapshot.context),
+		currentMode: snapshot.context.currentMode
+	};
+}
+function getTutorialPhase(snapshot) {
+	if (snapshot.matches({ tutorial: "checkingPermission" })) return "checkingPermission";
+	if (snapshot.matches({ tutorial: "waitingForPermission" })) return "waitingForPermission";
+	if (snapshot.matches({ tutorial: { initializingCamera: { userIntent: "clicked" } } })) return "waitingForCamera";
+	if (snapshot.matches({ tutorial: "initializingCamera" })) return "initializingCamera";
+	return "ready";
+}
+function mapTutorialState(snapshot, context) {
+	return {
+		status: "tutorial",
+		phase: getTutorialPhase(snapshot),
+		selectedDocumentType: getEffectiveSelectedDocumentType(context),
+		currentMode: context.currentMode
+	};
 }
 function mapManualUploadState(snapshot) {
 	const { config } = snapshot.context;
@@ -258,14 +367,17 @@ function mapManualUploadState(snapshot) {
 	/**
 	* Manual upload is client-authoritative for the back side: the slot must be
 	* shown or hidden before any upload round-trip, so there is no
-	* `skipBackIdCapture` to defer to yet. `config.onlyFront` is therefore read
-	* directly here — restoring V1 parity (ENG-50532). The camera path is the
-	* opposite: it forwards the flag and waits for the server's answer.
+	* `skipBackIdCapture` to defer to yet. The side-only flags are therefore read
+	* directly here (`onlyFront`: ENG-50532; `onlyBack`: ENG-51547). The camera
+	* path is the opposite: it forwards only-front and waits for the server's
+	* answer.
 	*/
 	const onlyFront = config.onlyFront === true;
-	const idTabCanContinue = (childCtx?.frontUploaded ?? false) && (onlyFront || backUploaded);
-	const canContinue = childCtx?.activeTab === "id" ? idTabCanContinue : childCtx?.passportUploaded ?? false;
-	const showBackSlot = !onlyFront;
+	const onlyBack = config.onlyBack === true;
+	const idTabCanContinue = onlyBack && backUploaded || !onlyBack && (childCtx?.frontUploaded ?? false) && (onlyFront || backUploaded);
+	const canContinue = childCtx?.activeTab === "id" ? idTabCanContinue : !onlyBack && (childCtx?.passportUploaded ?? false);
+	const showFrontSlot = !onlyBack;
+	const showBackSlot = onlyBack || !onlyFront;
 	return {
 		status: "manualUpload",
 		phase,
@@ -273,6 +385,7 @@ function mapManualUploadState(snapshot) {
 		activeTab: childCtx?.activeTab ?? "id",
 		showIdTab,
 		showPassportTab,
+		showFrontSlot,
 		showBackSlot,
 		frontFileName: childCtx?.frontFile?.name,
 		backFileName: childCtx?.backFile?.name,
@@ -312,34 +425,55 @@ function mapDigitalUploadState(snapshot) {
 		pickerRequestId: childCtx?.pickerRequestId ?? 0
 	};
 }
-function mapState(snapshot) {
+function mapDigitalIdRedirectState(snapshot) {
+	const childSnapshot = snapshot.children["digitalIdRedirect"]?.getSnapshot();
+	const childCtx = childSnapshot?.context;
+	const childValue = childSnapshot?.value;
+	return {
+		status: "digitalIdRedirect",
+		phase: (() => {
+			if (childValue === "readyToRedirect") return "redirecting";
+			if (childValue === "succeeded") return "success";
+			if (childValue === "failed") return "failed";
+			if (childValue === "error") return "error";
+			return "loading";
+		})(),
+		launchUrl: childCtx?.launchUrl,
+		failureReason: childCtx?.failureReason,
+		providerId: childCtx?.selectedProvider ?? childCtx?.config.provider
+	};
+}
+function mapDeviceWalletState(snapshot) {
+	const childSnapshot = snapshot.children["deviceWallet"]?.getSnapshot();
+	const childCtx = childSnapshot?.context;
+	const childValue = childSnapshot?.value;
+	return {
+		status: "deviceWallet",
+		phase: (() => {
+			if (childValue === "presenting") return "presenting";
+			if (childValue === "decrypting") return "decrypting";
+			if (childValue === "failed") return "failed";
+			return "requesting";
+		})(),
+		failReason: childCtx?.failReason ?? null,
+		platform: childCtx?.platform
+	};
+}
+function mapState(snapshot, presentationStream) {
 	const { context } = snapshot;
 	if (snapshot.matches("idle")) return { status: "idle" };
-	if (isLoadingPhase(snapshot)) return { status: "loading" };
+	const loadingPhase = getLoadingPhase(snapshot);
+	if (loadingPhase) return mapLoadingState(snapshot, loadingPhase);
 	if (snapshot.matches("chooser")) return {
 		status: "chooser",
 		availableDocumentTypes: context.availableDocumentTypes
 	};
-	if (snapshot.matches("loading")) return { status: "loading" };
-	if (snapshot.matches("tutorial")) return {
-		status: "tutorial",
-		selectedDocumentType: context.selectedDocumentType,
-		currentMode: context.currentMode
-	};
+	if (snapshot.matches("loading")) return mapLoadingState(snapshot, "bootstrapping");
+	if (snapshot.matches("tutorial")) return mapTutorialState(snapshot, context);
 	if (snapshot.matches("ageVerification")) return { status: "ageVerification" };
 	if (snapshot.matches("closed")) return { status: "closed" };
-	if (snapshot.matches("permissions")) {
-		const permissionStatus = getPermissionStatus(snapshot);
-		if (permissionStatus === void 0) return {
-			status: "permissions",
-			permissionStatus: "idle"
-		};
-		return {
-			status: "permissions",
-			permissionStatus
-		};
-	}
-	if (snapshot.matches("capture")) return mapCaptureState(snapshot, context);
+	if (snapshot.matches("permissions")) return mapPermissionsState(snapshot, context);
+	if (snapshot.matches("capture")) return mapCaptureState(snapshot, context, presentationStream);
 	if (snapshot.matches("mandatoryConsent")) return {
 		status: "mandatoryConsent",
 		regulationType: context.uploadResponse?.regulationType ?? "Other"
@@ -377,6 +511,8 @@ function mapState(snapshot) {
 	};
 	if (snapshot.matches("manualIdUpload")) return mapManualUploadState(snapshot);
 	if (snapshot.matches("digitalIdUpload")) return mapDigitalUploadState(snapshot);
+	if (snapshot.matches("digitalIdRedirect") || snapshot.matches("digitalIdRedirectReturning")) return mapDigitalIdRedirectState(snapshot);
+	if (snapshot.matches("deviceWallet") || snapshot.matches("digitalIdRouting")) return mapDeviceWalletState(snapshot);
 	return { status: "idle" };
 }
 function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished }) {
@@ -385,7 +521,7 @@ function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished })
 	return {
 		load() {
 			const { config } = actor.getSnapshot().context;
-			if (config.ds === true) setWasmDsFlagSync(true);
+			setWasmDsFlagSync(config.ds === true);
 			resetWasmMotionPrimedForModule();
 			actor.send({ type: "LOAD" });
 		},
@@ -408,6 +544,14 @@ function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished })
 			}
 			actor.send({ type: "NEXT_STEP" });
 		},
+		/**
+		* Requests camera (and, when deepsight is enabled, motion) permission.
+		* Effective in `permissions.idle`, `permissions.waitingForUser`,
+		* `permissions.motionOnly`, `permissions.learnMore`, `tutorial.ready`,
+		* `tutorial.checkingPermission`, and `tutorial.initializingCamera` (while
+		* the camera pre-warms it records the user's intent to continue, so the
+		* tutorial advances to capture as soon as the warm-up finishes).
+		*/
 		requestPermission() {
 			trackElementClicked?.("requestPermission");
 			actor.send({ type: "REQUEST_PERMISSION" });
@@ -536,6 +680,36 @@ function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished })
 		digitalUploadChooseAnother() {
 			trackElementClicked?.("digitalUpload.chooseAnother");
 			actor.send({ type: "DIGITAL_UPLOAD_CHOOSE_ANOTHER" });
+		},
+		/** Retry a failed Digital ID web-redirect — creates a NEW verification. */
+		digitalIdRedirectRetry() {
+			trackElementClicked?.("digitalIdRedirect.retry");
+			actor.send({ type: "DIGITAL_ID_REDIRECT_RETRY" });
+		},
+		/** Fall back from the Digital ID web-redirect to the chooser. */
+		digitalIdRedirectUseAnotherMethod() {
+			trackElementClicked?.("digitalIdRedirect.useAnotherMethod");
+			actor.send({ type: "DIGITAL_ID_REDIRECT_USE_ANOTHER_METHOD" });
+		},
+		/** Acknowledge the Digital ID web-redirect success screen and advance. */
+		digitalIdRedirectContinue() {
+			trackElementClicked?.("digitalIdRedirect.continue");
+			actor.send({ type: "DIGITAL_ID_REDIRECT_CONTINUE" });
+		},
+		/** Refresh an expiring launch URL (no new verification / billing event). */
+		digitalIdRedirectRefresh() {
+			trackElementClicked?.("digitalIdRedirect.refresh");
+			actor.send({ type: "DIGITAL_ID_REDIRECT_REFRESH" });
+		},
+		/** Retry a failed device-wallet (mDL) handshake from the start. */
+		deviceWalletRetry() {
+			trackElementClicked?.("deviceWallet.retry");
+			actor.send({ type: "DEVICE_WALLET_RETRY" });
+		},
+		/** Fall back from the device-wallet handshake to the chooser. */
+		deviceWalletUseAnotherMethod() {
+			trackElementClicked?.("deviceWallet.useAnotherMethod");
+			actor.send({ type: "DEVICE_WALLET_USE_ANOTHER_METHOD" });
 		}
 	};
 }
@@ -674,6 +848,17 @@ function getIdCaptureScreenName(snapshot) {
 			const childContext = child?.context;
 			return mapIdManualUploadScreenName(child?.value, childContext) ?? "idCapture.manualIdUpload";
 		}
+		case "digitalIdRedirect":
+		case "digitalIdRedirectReturning": {
+			const child = snapshot.children["digitalIdRedirect"]?.getSnapshot();
+			return mapDigitalIdRedirectScreenName(child?.value);
+		}
+		case "deviceWallet":
+		case "digitalIdRouting": {
+			const child = snapshot.children["deviceWallet"]?.getSnapshot();
+			const childContext = child?.context;
+			return mapDeviceWalletScreenName(child?.value, childContext?.failReason ?? null);
+		}
 		default: return `idCapture.${topLevel}`;
 	}
 }
@@ -770,28 +955,56 @@ function getIdCaptureErrorPayload(snapshot) {
 * `docs/patterns/CAPABILITY.md`). Pass a fake/no-op to override (tests do).
 */
 function createIdCaptureManagerFromActor(actor, visibilityObserver = new BrowserVisibilityObserverProvider()) {
+	const protectedCaptureController = findIdProtectedCaptureController(actor);
+	protectedCaptureController?.setVisible(visibilityObserver.isVisible());
 	return createManager({
 		actor,
-		mapState,
+		mapState: (snapshot) => mapState(snapshot, protectedCaptureController?.getProjection().stream),
 		createApi,
 		instrumentation: createManagerInstrumentation(eventModuleNames.idCapture, {
 			getEventScreenName: mapIdCaptureScreenName,
 			getErrorName: getIdCaptureErrorName,
 			getErrorPayload: getIdCaptureErrorPayload,
-			visibilityObserver
+			visibilityObserver: {
+				isVisible: () => visibilityObserver.isVisible(),
+				onVisibilityChange: (listener) => visibilityObserver.onVisibilityChange((visible) => {
+					protectedCaptureController?.setVisible(visible);
+					actor.send({ type: visible ? "FOREGROUND" : "BACKGROUND" });
+					listener(visible);
+				})
+			}
 		})
 	});
 }
 //#endregion
+//#region ../infra/src/providers/browser/BrowserDigitalCredentialsProvider.ts
+var BrowserDigitalCredentialsProvider = class {
+	isAvailable() {
+		return typeof navigator !== "undefined" && typeof navigator.credentials?.get === "function" && typeof globalThis.DigitalCredential !== "undefined";
+	}
+	async get(request, options) {
+		return { response: (await navigator.credentials.get({
+			mediation: "required",
+			signal: options?.signal,
+			digital: { requests: [request] }
+		}))?.data?.response };
+	}
+};
+//#endregion
 //#region src/modules/id/idCaptureActor.ts
 function createIdCaptureActor(options) {
-	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
+	const dependencies = {
+		...options.dependencies,
+		storage: options.dependencies?.storage ?? new BrowserStorageProvider(),
+		credentials: options.dependencies?.credentials ?? new BrowserDigitalCredentialsProvider()
+	};
 	const treatment = resolveCaptureOptimizingTreatment(options.config);
-	return createActor(idCaptureMachine, { input: {
-		config: {
-			...options.config,
-			thresholds: resolveIdCaptureThresholds(options.config, treatment?.framesAggregationInterval)
-		},
+	const config = {
+		...options.config,
+		thresholds: resolveIdCaptureThresholds(options.config, treatment?.framesAggregationInterval)
+	};
+	return createActor(provideIdProtectedCaptureController(idCaptureMachine, createIdProtectedCaptureController()), { input: {
+		config,
 		dependencies,
 		captureFeedbackMode: treatment?.mode ?? "countdown",
 		captureWindowMs: treatment?.captureWindowMs,