@incodetech/core 2.0.0 → 2.0.1-rc.0

package/dist/idCaptureManager-ZPkD7Gjk.esm.js

@@ -0,0 +1,581 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as BrowserStorageProvider } from "./BrowserStorageProvider-CuOW1Er2.esm.js";
+import { h as mapDigitalIdScreenName, t as idCaptureMachine } from "./idCaptureStateMachine-BK0bPHoc.esm.js";
+
+//#region src/internal/idCapture/idCaptureManagerFactory.ts
+function getPermissionStatus(snapshot) {
+	if (!snapshot.matches("permissions")) return;
+	if (snapshot.matches({ permissions: "idle" })) return "idle";
+	if (snapshot.matches({ permissions: "waitingForUser" })) return "idle";
+	if (snapshot.matches({ permissions: "learnMore" })) return "learnMore";
+	if (snapshot.matches({ permissions: "requesting" })) return "requesting";
+	if (snapshot.matches({ permissions: "denied" })) return "denied";
+}
+function getCaptureStatus(snapshot) {
+	const matches = {
+		initializing: snapshot.matches({ capture: "initializing" }),
+		detecting: snapshot.matches({ capture: "detecting" }),
+		manualCaptureWaiting: snapshot.matches({ capture: "manualCaptureWaiting" }),
+		capturing: snapshot.matches({ capture: "capturing" }),
+		capturingManual: snapshot.matches({ capture: "capturingManual" }),
+		uploading: snapshot.matches({ capture: "uploading" }),
+		uploadError: snapshot.matches({ capture: "uploadError" }),
+		success: snapshot.matches({ capture: "success" })
+	};
+	if (matches.initializing) return "initializing";
+	if (matches.detecting || matches.manualCaptureWaiting) return "detecting";
+	if (matches.capturing || matches.capturingManual) return "capturing";
+	if (matches.uploading) return "uploading";
+	if (matches.uploadError) return "uploadError";
+	if (matches.success) return "success";
+}
+/**
+* Returns an i18n key for the error title. The UI layer is responsible for
+* calling `t()` on the returned key.
+*
+* Passport-aware keys are emitted for error codes that have user-facing copy
+* specific to passports (e.g. CLASSIFICATION_FAILED → ".titlePassport").
+* Other codes fall back to the shared key.
+*/
+function getErrorTitleKey(errorCode, currentMode) {
+	if (!errorCode) return void 0;
+	const isPassport = currentMode === "passport";
+	if (errorCode === "CLASSIFICATION_FAILED") return isPassport ? "idv2.capture.processing.errors.classification.titlePassport" : "idv2.capture.processing.errors.classification.title";
+	return {
+		UPLOAD_ERROR: "idv2.capture.processing.errors.upload.title",
+		CLASSIFICATION_FAILED: "idv2.capture.processing.errors.classification.title",
+		LOW_SHARPNESS: "idv2.capture.processing.errors.sharpness.title",
+		GLARE_DETECTED: "idv2.capture.processing.errors.glare.title",
+		WRONG_DOCUMENT_SIDE: "idv2.capture.processing.errors.wrongSide.title",
+		ID_TYPE_UNACCEPTABLE: "idv2.capture.processing.errors.unacceptable.title",
+		READABILITY_ISSUE: "idv2.capture.processing.errors.readability.title",
+		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "idv2.capture.processing.errors.default.title",
+		RETRY_EXHAUSTED_SKIP_BACK: "idv2.capture.processing.errors.default.title",
+		NO_MORE_TRIES: "idv2.capture.processing.errors.default.title",
+		UNEXPECTED_ERROR: "idv2.capture.processing.errors.default.title",
+		NO_TOKEN: "idv2.capture.processing.errors.default.title",
+		PERMISSION_DENIED: "idv2.capture.processing.errors.default.title",
+		USER_CANCELLED: "idv2.capture.processing.errors.default.title",
+		SERVER_ERROR: "idv2.capture.processing.errors.default.title"
+	}[errorCode];
+}
+/**
+* Returns an i18n key for the error subtitle. The UI layer is responsible for
+* calling `t()` on the returned key.
+*
+* Passport-aware keys are emitted for error codes that have user-facing copy
+* specific to passports (e.g. CLASSIFICATION_FAILED → ".subtitlePassport").
+* Other codes fall back to the shared key.
+*/
+function getErrorSubtitleKey(errorCode, uploadResponse, currentMode) {
+	if (!errorCode) return void 0;
+	const isPassport = currentMode === "passport";
+	if (errorCode === "WRONG_DOCUMENT_SIDE") return uploadResponse?.side === "back" ? "idv2.capture.processing.errors.wrongSide.back.subtitle" : "idv2.capture.processing.errors.wrongSide.front.subtitle";
+	if (errorCode === "CLASSIFICATION_FAILED") return isPassport ? "idv2.capture.processing.errors.classification.subtitlePassport" : "idv2.capture.processing.errors.classification.subtitle";
+	return {
+		UPLOAD_ERROR: "idv2.capture.processing.errors.upload.subtitle",
+		CLASSIFICATION_FAILED: "idv2.capture.processing.errors.classification.subtitle",
+		LOW_SHARPNESS: "idv2.capture.processing.errors.sharpness.subtitle",
+		GLARE_DETECTED: "idv2.capture.processing.errors.glare.subtitle",
+		WRONG_DOCUMENT_SIDE: "idv2.capture.processing.errors.wrongSide.front.subtitle",
+		ID_TYPE_UNACCEPTABLE: "idv2.capture.processing.errors.unacceptable.subtitle",
+		READABILITY_ISSUE: "idv2.capture.processing.errors.readability.subtitle",
+		RETRY_EXHAUSTED_CONTINUE_TO_BACK: "idv2.capture.processing.errors.default.subtitle",
+		RETRY_EXHAUSTED_SKIP_BACK: "idv2.capture.processing.errors.default.subtitle",
+		NO_MORE_TRIES: "idv2.capture.processing.errors.default.subtitle",
+		UNEXPECTED_ERROR: "idv2.capture.processing.errors.default.subtitle",
+		NO_TOKEN: "idv2.capture.processing.errors.default.subtitle",
+		PERMISSION_DENIED: "idv2.capture.processing.errors.default.subtitle",
+		USER_CANCELLED: "idv2.capture.processing.errors.default.subtitle",
+		SERVER_ERROR: "idv2.capture.processing.errors.default.subtitle"
+	}[errorCode];
+}
+function shouldCaptureBack(context) {
+	if (context.isDigitalUpload) return false;
+	if (!(context.currentMode === "front" || context.currentMode === "passport")) return false;
+	if (context.config.onlyBack) return false;
+	if (context.config.usSmartCapture && context.currentMode === "front") return false;
+	const serverSkipped = context.uploadResponse?.skipBackIdCapture === true;
+	const forceBackForNonPassport = context.config.alwaysCaptureBackOfId === true && context.currentMode !== "passport";
+	return !serverSkipped || forceBackForNonPassport;
+}
+function shouldCaptureFront(context) {
+	return context.config.usSmartCapture === true && context.currentMode === "back" && context.uploadResponse?.forceFrontIdCapture === true;
+}
+function mapCaptureState(snapshot, context) {
+	const captureStatus = getCaptureStatus(snapshot) ?? "initializing";
+	const { uploadError, uploadResponse } = context;
+	return {
+		status: "capture",
+		captureStatus,
+		stream: context.stream,
+		detectionStatus: context.detectionStatus,
+		debugFrame: void 0,
+		attemptsRemaining: context.attemptsRemaining,
+		uploadError,
+		currentMode: context.currentMode,
+		counterValue: context.counterValue,
+		orientation: context.orientation,
+		idType: context.idType,
+		previewImageUrl: context.previewImageUrl,
+		uploadProgress: context.uploadProgress ?? 0,
+		ageAssurance: context.config.ageAssurance === true,
+		uploadErrorMessage: uploadError ? getErrorTitleKey(uploadError, context.currentMode) : void 0,
+		uploadErrorDescription: uploadError ? getErrorSubtitleKey(uploadError, uploadResponse, context.currentMode) : void 0,
+		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 mapManualUploadState(snapshot) {
+	const { config } = snapshot.context;
+	const childSnapshot = snapshot.children["manualIdUpload"]?.getSnapshot();
+	const childCtx = childSnapshot?.context;
+	const childValue = childSnapshot?.value;
+	const phase = childValue === "retriesExhausted" ? "exhausted" : childValue === "uploadingFront" || childValue === "uploadingBack" || childValue === "uploadingPassport" ? "uploading" : "selecting";
+	const uploadingSide = childValue === "uploadingFront" ? "front" : childValue === "uploadingBack" ? "back" : childValue === "uploadingPassport" ? "passport" : void 0;
+	/**
+	* Server told us the document doesn't need a back side (e.g. passport-class
+	* docs, single-sided IDs). Treat the back slot as uploaded so the UI shows
+	* a green check rather than hiding the slot — matches v1's behavior and
+	* keeps both slots visible once the front has been processed.
+	*/
+	const backUploaded = (childCtx?.backUploaded ?? false) || (childCtx?.skipBackFromServer ?? false);
+	const idTabCanContinue = (childCtx?.frontUploaded ?? false) && backUploaded;
+	const canContinue = childCtx?.activeTab === "id" ? idTabCanContinue : childCtx?.passportUploaded ?? false;
+	return {
+		status: "manualUpload",
+		phase,
+		uploadingSide,
+		activeTab: childCtx?.activeTab ?? "id",
+		showIdTab: config.enableId ?? true,
+		showPassportTab: config.enablePassport ?? false,
+		showBackSlot: true,
+		frontFileName: childCtx?.frontFile?.name,
+		backFileName: childCtx?.backFile?.name,
+		passportFileName: childCtx?.passportFile?.name,
+		frontUploaded: childCtx?.frontUploaded ?? false,
+		backUploaded,
+		passportUploaded: childCtx?.passportUploaded ?? false,
+		canContinue,
+		retriesLeft: childCtx?.retriesLeft ?? snapshot.context.config.captureAttempts,
+		errorKey: childCtx?.errorMessage ?? null
+	};
+}
+function mapDigitalUploadState(snapshot) {
+	const childSnapshot = snapshot.children["digitalIdUpload"]?.getSnapshot();
+	const childCtx = childSnapshot?.context;
+	const childValue = childSnapshot?.value;
+	return {
+		status: "digitalIdUpload",
+		phase: (() => {
+			if (childValue === "tutorial") return "tutorial";
+			if (childValue === "selecting") return "selecting";
+			if (childValue === "reviewing") return "reviewing";
+			if (childValue === "success") return "success";
+			if (childValue === "error") return "error";
+			if (childValue === "fileTooLarge") return "fileTooLarge";
+			if (childValue === "retriesExhausted") return "exhausted";
+			if (childSnapshot?.matches({ uploading: "holding" })) return "holding";
+			if (childSnapshot?.matches({ uploading: "analyzing" })) return "uploading";
+			return "selecting";
+		})(),
+		file: childCtx?.file ?? null,
+		fileName: childCtx?.file?.name,
+		failReason: childCtx?.failReason ?? null,
+		attemptsRemaining: childCtx?.attemptsRemaining ?? snapshot.context.config.captureAttempts,
+		uploadProgress: childCtx?.uploadProgress ?? 0,
+		pickerRequestId: childCtx?.pickerRequestId ?? 0
+	};
+}
+function mapState(snapshot) {
+	const { context } = snapshot;
+	if (snapshot.matches("idle")) return { status: "idle" };
+	if (isLoadingPhase(snapshot)) return { status: "loading" };
+	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("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("mandatoryConsent")) return {
+		status: "mandatoryConsent",
+		regulationType: context.uploadResponse?.regulationType ?? "Other"
+	};
+	if (snapshot.matches("frontFinished")) return { status: "frontFinished" };
+	if (snapshot.matches("backFinished")) return { status: "backFinished" };
+	if (snapshot.matches("processing")) return { status: "processing" };
+	if (snapshot.matches("expiredExhausted")) return { status: "expiredExhausted" };
+	if (snapshot.matches("expired")) {
+		const counter = context.expiredFromUpload ? context.expiredAttempts : context.processingExpiredAttempts;
+		return {
+			status: "expired",
+			attemptsRemaining: Math.max(0, context.config.captureAttempts - counter)
+		};
+	}
+	if (snapshot.matches("finished")) return { status: "finished" };
+	if (snapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	if (snapshot.matches("manualIdUpload")) return mapManualUploadState(snapshot);
+	if (snapshot.matches("digitalIdUpload")) return mapDigitalUploadState(snapshot);
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked, trackCaptureAttemptFinished }) {
+	const snapshot = actor.getSnapshot();
+	if (snapshot.context.dependencies) snapshot.context.dependencies.trackCaptureAttemptFinished = trackCaptureAttemptFinished;
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		selectDocument(documentType) {
+			trackElementClicked?.(`selectDocument.${documentType}`);
+			actor.send({
+				type: "SELECT_DOCUMENT",
+				documentType
+			});
+		},
+		nextStep() {
+			trackElementClicked?.("nextStep");
+			actor.send({ type: "NEXT_STEP" });
+		},
+		requestPermission() {
+			trackElementClicked?.("requestPermission");
+			actor.send({ type: "REQUEST_PERMISSION" });
+		},
+		goToLearnMore() {
+			trackElementClicked?.("goToLearnMore");
+			actor.send({ type: "GO_TO_LEARN_MORE" });
+		},
+		back() {
+			trackElementClicked?.("back");
+			actor.send({ type: "BACK" });
+		},
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "QUIT" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		retryCapture() {
+			trackElementClicked?.("retryCapture");
+			actor.send({ type: "RETRY_CAPTURE" });
+		},
+		continueExhausted() {
+			trackElementClicked?.("continueExhausted");
+			actor.send({ type: "CONTINUE_EXHAUSTED" });
+		},
+		continueFromError() {
+			trackElementClicked?.("continueFromError");
+			actor.send({ type: "CONTINUE_FROM_ERROR" });
+		},
+		capture() {
+			trackElementClicked?.("capture");
+			actor.send({ type: "MANUAL_CAPTURE" });
+		},
+		switchToManualCapture() {
+			trackElementClicked?.("switchToManualCapture");
+			actor.send({ type: "SWITCH_TO_MANUAL_CAPTURE" });
+		},
+		continueToBack() {
+			trackElementClicked?.("continueToBack");
+			actor.send({ type: "CONTINUE_TO_BACK" });
+		},
+		continueToFront() {
+			trackElementClicked?.("continueToFront");
+			actor.send({ type: "CONTINUE_TO_FRONT" });
+		},
+		skipBack() {
+			trackElementClicked?.("skipBack");
+			actor.send({ type: "SKIP_BACK" });
+		},
+		acceptMandatoryConsent() {
+			trackElementClicked?.("acceptMandatoryConsent");
+			actor.send({ type: "CONSENT_ACCEPT" });
+		},
+		cancelMandatoryConsent() {
+			trackElementClicked?.("cancelMandatoryConsent");
+			actor.send({ type: "CONSENT_CANCEL" });
+		},
+		updateDetectionArea(detectionArea) {
+			actor.send({
+				type: "UPDATE_DETECTION_AREA",
+				detectionArea
+			});
+		},
+		manualUploadChangeTab(tab) {
+			trackElementClicked?.(`manualUpload.tab.${tab}`);
+			actor.send({
+				type: "MANUAL_UPLOAD_TAB_CHANGED",
+				tab
+			});
+		},
+		manualUploadSelectFile(side, file) {
+			trackElementClicked?.(`manualUpload.select.${side}`);
+			actor.send({
+				type: "MANUAL_UPLOAD_FILE_SELECTED",
+				side,
+				file
+			});
+		},
+		manualUploadContinue() {
+			trackElementClicked?.("manualUpload.continue");
+			actor.send({ type: "MANUAL_UPLOAD_CONTINUE" });
+		},
+		manualUploadReset() {
+			trackElementClicked?.("manualUpload.reset");
+			actor.send({ type: "MANUAL_UPLOAD_RESET" });
+		},
+		digitalUploadNextStep() {
+			trackElementClicked?.("digitalUpload.nextStep");
+			actor.send({ type: "DIGITAL_UPLOAD_NEXT_STEP" });
+		},
+		digitalUploadPickFile(file) {
+			trackElementClicked?.("digitalUpload.pickFile");
+			actor.send({
+				type: "DIGITAL_UPLOAD_FILE_PICKED",
+				file
+			});
+		},
+		digitalUploadConfirm() {
+			trackElementClicked?.("digitalUpload.confirmFile");
+			actor.send({ type: "DIGITAL_UPLOAD_CONFIRM" });
+		},
+		digitalUploadReplace() {
+			trackElementClicked?.("digitalUpload.replaceFile");
+			actor.send({ type: "DIGITAL_UPLOAD_REPLACE" });
+		},
+		digitalUploadRetry() {
+			trackElementClicked?.("digitalUpload.retry");
+			actor.send({ type: "DIGITAL_UPLOAD_RETRY" });
+		},
+		digitalUploadScanInstead() {
+			trackElementClicked?.("digitalUpload.scanInstead");
+			actor.send({ type: "DIGITAL_UPLOAD_SCAN_INSTEAD" });
+		},
+		digitalUploadChooseAnother() {
+			trackElementClicked?.("digitalUpload.chooseAnother");
+			actor.send({ type: "DIGITAL_UPLOAD_CHOOSE_ANOTHER" });
+		}
+	};
+}
+const FRONT_SCREENS = {
+	tutorial: "idCapture.tutorial.front",
+	capturePrefix: "idCapture.frontCapture",
+	analyzingPrefix: "idCapture.frontAnalyzing",
+	errorPrefix: "idCapture.frontCaptureError",
+	successPrefix: "idCapture.frontCaptureSuccess",
+	liveCueSide: "showfront"
+};
+const BACK_SCREENS = {
+	tutorial: "idCapture.tutorial.back",
+	capturePrefix: "idCapture.backCapture",
+	analyzingPrefix: "idCapture.backAnalyzing",
+	errorPrefix: "idCapture.backCaptureError",
+	successPrefix: "idCapture.backCaptureSuccess",
+	liveCueSide: "showback"
+};
+const PASSPORT_SCREENS = { tutorial: "idCapture.tutorial.passport" };
+function getSideScreens(mode) {
+	if (mode === "back") return BACK_SCREENS;
+	if (mode === "passport") return {
+		...FRONT_SCREENS,
+		...PASSPORT_SCREENS
+	};
+	return FRONT_SCREENS;
+}
+function getCaptureLiveCueScreen(screens, detectionStatus) {
+	switch (detectionStatus) {
+		case "wrongSide": return `${screens.capturePrefix}.livecue-${screens.liveCueSide}`;
+		case "blur": return `${screens.capturePrefix}.livecue-blur`;
+		case "farAway":
+		case "idNotDetected": return `${screens.capturePrefix}.livecue-align`;
+		case "glare": return `${screens.capturePrefix}.livecue-glare`;
+		case "offline": return `${screens.capturePrefix}.livecue-dark`;
+		case "manualCapture": return `${screens.capturePrefix}.manual`;
+		case "capturing": return `${screens.capturePrefix}.takingphoto`;
+		case "detecting":
+		case "idle":
+		default: return `${screens.capturePrefix}.default`;
+	}
+}
+function getCaptureErrorScreen(screens, errorCode) {
+	switch (errorCode) {
+		case "WRONG_DOCUMENT_SIDE": return `${screens.errorPrefix}.wrongside`;
+		case "GLARE_DETECTED": return `${screens.errorPrefix}.glare`;
+		case "LOW_SHARPNESS": return `${screens.errorPrefix}.blur`;
+		case "READABILITY_ISSUE": return `${screens.errorPrefix}.notreadable`;
+		case "ID_TYPE_UNACCEPTABLE":
+		case "CLASSIFICATION_FAILED": return `${screens.errorPrefix}.notaccepted`;
+		case "RETRY_EXHAUSTED_CONTINUE_TO_BACK":
+		case "RETRY_EXHAUSTED_SKIP_BACK":
+		case "NO_MORE_TRIES": return `${screens.errorPrefix}.failedExhausted`;
+		case "NO_TOKEN":
+		case "SERVER_ERROR": return `${screens.errorPrefix}.nointernet`;
+		case "UPLOAD_ERROR":
+		case "UNEXPECTED_ERROR":
+		case "PERMISSION_DENIED":
+		case "USER_CANCELLED":
+		default: return `${screens.errorPrefix}.failed`;
+	}
+}
+function getSuccessScreen(snapshot, screens) {
+	const { config } = snapshot.context;
+	if (config?.onlyBack === true || config?.showCaptureButtonInAuto === true) return `${screens.successPrefix}.captureonly`;
+	return `${screens.successPrefix}.default`;
+}
+function getCaptureSubstateScreen(snapshot, screens) {
+	const { value, context } = snapshot;
+	if (typeof value !== "object" || value === null) return void 0;
+	const captureValue = value.capture;
+	if (captureValue === void 0) return void 0;
+	if (typeof captureValue === "string") switch (captureValue) {
+		case "checkingStream":
+		case "initializing":
+		case "initializingDeepsight": return "idCapture.loader.preparingcamera";
+		case "detecting": return getCaptureLiveCueScreen(screens, context.detectionStatus);
+		case "manualCaptureWaiting": return `${screens.capturePrefix}.manual`;
+		case "capturing": return `${screens.capturePrefix}.takingphoto`;
+		case "capturingManual": return `${screens.capturePrefix}.manual`;
+		case "uploading":
+		case "validatingUpload": return `${screens.analyzingPrefix}.uploading`;
+		case "uploadError": return getCaptureErrorScreen(screens, context.uploadError);
+		case "success": return getSuccessScreen(snapshot, screens);
+	}
+	if (typeof captureValue === "object" && captureValue !== null) {
+		const substates = Object.keys(captureValue);
+		if (substates.includes("checkingStream") || substates.includes("initializing") || substates.includes("initializingDeepsight")) return "idCapture.loader.preparingcamera";
+		if (substates.includes("detecting")) return getCaptureLiveCueScreen(screens, context.detectionStatus);
+		if (substates.includes("manualCaptureWaiting")) return `${screens.capturePrefix}.manual`;
+		if (substates.includes("capturing")) return `${screens.capturePrefix}.takingphoto`;
+		if (substates.includes("capturingManual")) return `${screens.capturePrefix}.manual`;
+		if (substates.includes("uploading") || substates.includes("validatingUpload")) return `${screens.analyzingPrefix}.uploading`;
+		if (substates.includes("uploadError")) return getCaptureErrorScreen(screens, context.uploadError);
+		if (substates.includes("success")) return getSuccessScreen(snapshot, screens);
+	}
+	return `${screens.capturePrefix}.default`;
+}
+function getPermissionScreen(value) {
+	if (typeof value !== "object" || value === null) return "idCapture.permissions.default";
+	switch (value.permissions) {
+		case "requesting": return "idCapture.permissions.required";
+		case "denied": return "idCapture.permissions.quit";
+		case "learnMore": return "idCapture.commonissues.default";
+		case "idle":
+		case "waitingForUser":
+		default: return "idCapture.permissions.default";
+	}
+}
+function getIdCaptureScreenName(snapshot) {
+	const { value, context } = snapshot;
+	if (value === void 0 || value === null) return void 0;
+	const topLevel = typeof value === "string" ? value : typeof value === "object" ? Object.keys(value)[0] : void 0;
+	if (topLevel === void 0) return void 0;
+	const side = context.currentMode;
+	const screens = getSideScreens(side);
+	switch (topLevel) {
+		case "idle": return "idCapture.loader.default";
+		case "chooser": return "idCapture.documentchooser";
+		case "loading": return "idCapture.loader.default";
+		case "tutorial": return screens.tutorial;
+		case "ageVerification": return "idCapture.tutorial.ageverification";
+		case "permissions": return getPermissionScreen(value);
+		case "capture": return getCaptureSubstateScreen(snapshot, screens);
+		case "mandatoryConsent": return "idCapture.mandatoryConsent";
+		case "frontFinished": return "idCapture.flipid.showback";
+		case "backFinished": return "idCapture.flipid.showfront";
+		case "processing": return `${screens.analyzingPrefix}.processing`;
+		case "expired": return "idCapture.expired";
+		case "expiredExhausted": return "idCapture.expiredExhausted";
+		case "finished": return "idCapture.finished";
+		case "closed": return "idCapture.closed";
+		case "error": return "idCapture.error";
+		case "digitalIdUpload": {
+			const child = snapshot.children["digitalIdUpload"]?.getSnapshot();
+			const childContext = child?.context;
+			return mapDigitalIdScreenName(child?.value, childContext?.failReason ?? null);
+		}
+		default: return `idCapture.${topLevel}`;
+	}
+}
+function mapIdCaptureScreenName(snapshot) {
+	return getIdCaptureScreenName(snapshot);
+}
+function getIdCaptureErrorPayload(snapshot) {
+	const errorCode = snapshot.context.uploadError;
+	if (errorCode === void 0) return;
+	return { errorCode };
+}
+/**
+* Builds the public ID capture manager from an already-created actor.
+* Used by both `createIdCaptureManager` and `createIdCaptureOnlyManager`.
+*
+* The internal cast to `IdCaptureActor` narrows the union for `createManager`,
+* which is typed against the regular machine. Variants produced via
+* `idCaptureMachine.provide({...})` share the same context and event types,
+* so the cast is sound at runtime — only the actor implementation differs.
+*/
+function createIdCaptureManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.idCapture, {
+			getEventScreenName: mapIdCaptureScreenName,
+			getErrorPayload: getIdCaptureErrorPayload
+		})
+	});
+}
+
+//#endregion
+//#region src/modules/id/idCaptureActor.ts
+function createIdCaptureActor(options) {
+	const dependencies = options.dependencies ?? { storage: new BrowserStorageProvider() };
+	return createActor(idCaptureMachine, { input: {
+		config: options.config,
+		dependencies
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/id/idCaptureManager.ts
+/**
+* Creates a manager for the regular ID capture flow. The shared
+* `mapState`/`createApi`/state-types live in
+* `internal/idCapture/idCaptureManagerFactory.ts`; this file is a thin
+* wrapper that creates the actor and delegates to the factory.
+*
+* For the captureOnly flow (rich payload delivered locally via `onCapture`),
+* use `createIdCaptureOnlyManager`.
+*/
+function createIdCaptureManager(options) {
+	return createIdCaptureManagerFromActor(createIdCaptureActor(options));
+}
+
+//#endregion
+export { createIdCaptureActor as n, createIdCaptureManagerFromActor as r, createIdCaptureManager as t };