@incodetech/core 2.0.1-rc.0 → 2.1.0-rc.0

package/dist/fiscal-qr.d.ts

@@ -0,0 +1,59 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import "./camera-SRBpPq2X.js";
+import "./StreamCanvasCapture-yyl20qd9.js";
+
+//#region src/modules/fiscal-qr/types.d.ts
+/**
+ * Configuration options for the Fiscal QR module.
+ *
+ * The backend currently sends an empty module configuration for this step.
+ */
+type FiscalQrConfig = Record<string, never>;
+//#endregion
+//#region src/modules/fiscal-qr/fiscalQrManager.d.ts
+type FiscalQrIdleState = {
+  status: 'idle';
+};
+type FiscalQrScanningState = {
+  status: 'scanning';
+  stream?: MediaStream;
+  error?: string;
+};
+type FiscalQrCapturingState = {
+  status: 'capturing';
+  stream?: MediaStream;
+};
+type FiscalQrSuccessState = {
+  status: 'success';
+  stream?: MediaStream;
+};
+type FiscalQrProcessingState = {
+  status: 'processing';
+};
+type FiscalQrErrorState = {
+  status: 'error';
+  error?: string;
+  attempts: number;
+  stream?: MediaStream;
+};
+type FiscalQrVerifiedState = {
+  status: 'verified';
+};
+type FiscalQrFinishedState = {
+  status: 'finished';
+};
+type FiscalQrState = FiscalQrIdleState | FiscalQrScanningState | FiscalQrCapturingState | FiscalQrSuccessState | FiscalQrProcessingState | FiscalQrErrorState | FiscalQrVerifiedState | FiscalQrFinishedState;
+declare function createFiscalQrManager(options: {
+  config: FiscalQrConfig;
+}): Manager<FiscalQrState> & {
+  load(): void;
+  continue(): void;
+  skip(): void;
+  reset(): void;
+};
+type FiscalQrManager = ReturnType<typeof createFiscalQrManager>;
+//#endregion
+//#region src/modules/fiscal-qr/fiscalQrStateMachine.d.ts
+declare const fiscalQrMachine: any;
+//#endregion
+export { type FiscalQrConfig, type FiscalQrManager, type FiscalQrState, createFiscalQrManager, fiscalQrMachine };

package/dist/fiscal-qr.esm.js

@@ -0,0 +1,323 @@
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { h as addEvent, n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import "./platform-SKvEfCBh.esm.js";
+import { a as fromPromise, c as createManager, i as fromCallback, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { i as stopCameraStream } from "./camera-DJWm3V4g.esm.js";
+import "./ITimerCapability-CB0I1Uf2.esm.js";
+import "./canvas-SKcRBxsk.esm.js";
+import { n as getBackCameraStream } from "./backCameraStream-D7Wo4Nbx.esm.js";
+import { t as StreamCanvasCapture } from "./StreamCanvasCapture-ImiDQdVA.esm.js";
+import "./http-Cai3IoLS.esm.js";
+import { BrowserQRCodeReader } from "@zxing/browser";
+
+//#region src/modules/fiscal-qr/fiscalQrConstants.ts
+const QR_SCAN_FPS = 10;
+const INITIAL_FOCUS_DELAY_MS = 800;
+const SCAN_INTERVAL_MS = 500;
+const SUCCESS_DISPLAY_MS = 1500;
+const PROCESSING_DISPLAY_MS = 3e3;
+const ERROR_DISPLAY_MS = 3e3;
+const MAX_ATTEMPTS = 3;
+
+//#endregion
+//#region src/modules/fiscal-qr/qrCodeDecoder.ts
+function createQrCodeDecoder() {
+	const reader = new BrowserQRCodeReader();
+	return { decode(canvas) {
+		try {
+			const text = reader.decodeFromCanvas(canvas.canvas).getText().trim();
+			return text.length > 0 ? text : void 0;
+		} catch {
+			return;
+		}
+	} };
+}
+
+//#endregion
+//#region src/modules/fiscal-qr/fiscalQrUtils.ts
+/**
+* Continuously decodes QR codes from an existing frame capturer until the first
+* hit.
+*
+* When `applyFocusDelay` is true, waits {@link INITIAL_FOCUS_DELAY_MS} (camera
+* focus) before the first attempt; otherwise scans immediately. Either way it
+* then retries every {@link SCAN_INTERVAL_MS}. `onDetected` fires at most once.
+*
+* Takes a shared {@link StreamCanvasCapture} rather than a stream on purpose:
+* the capturer (and its hidden video) is created once for the camera session
+* and reused across scan restarts, so re-entering scanning never spins up a new
+* stream consumer — which would briefly disturb the visible camera feed.
+*
+* @returns a cleanup function that stops the scan loop. It does NOT dispose the
+*   capturer or stop the camera — the caller owns those lifecycles.
+*/
+function startQrScan(frameCapturer, onDetected, applyFocusDelay = true) {
+	const decoder = createQrCodeDecoder();
+	const timer = BrowserTimerProvider.getInstance();
+	let disposed = false;
+	let hasDetected = false;
+	let scanInterval;
+	let focusDelay;
+	const scan = () => {
+		if (disposed || hasDetected) return;
+		const canvas = frameCapturer.getLatestCanvas();
+		if (!canvas) return;
+		try {
+			const link = decoder.decode(canvas);
+			if (link && !disposed && !hasDetected) {
+				hasDetected = true;
+				onDetected(link);
+			}
+		} finally {
+			canvas.dispose();
+		}
+	};
+	const beginScanning = () => {
+		scan();
+		scanInterval = timer.setInterval(scan, SCAN_INTERVAL_MS);
+	};
+	if (applyFocusDelay) focusDelay = timer.setTimeout(beginScanning, INITIAL_FOCUS_DELAY_MS);
+	else beginScanning();
+	return () => {
+		disposed = true;
+		if (focusDelay !== void 0) timer.clearTimeout(focusDelay);
+		if (scanInterval !== void 0) timer.clearInterval(scanInterval);
+	};
+}
+
+//#endregion
+//#region src/modules/fiscal-qr/fiscalQrServices.ts
+/**
+* Submits a scanned Fiscal QR link to the backend.
+*
+* Throws when the request fails OR when the backend rejects the link
+* (`success === false`), so callers can retry/skip — matching the legacy SDK
+* which only advanced when `postResp.success` was truthy.
+*/
+async function submitFiscalQrLink(params, signal) {
+	const res = await api.post(endpoints.addFiscalQrLink, params, { signal });
+	if (!res.ok) throw new Error(`POST failed: ${res.status}`);
+	if (res.data?.success !== true) throw new Error("Fiscal QR link was not accepted");
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/fiscal-qr/fiscalQrStateMachine.ts
+const fiscalQrMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		initCamera: fromPromise(async () => {
+			const { stream } = await getBackCameraStream(void 0);
+			return {
+				stream,
+				frameCapturer: new StreamCanvasCapture(stream, { fps: QR_SCAN_FPS })
+			};
+		}),
+		submitFiscalQrLink: fromPromise(async ({ input, signal }) => {
+			await submitFiscalQrLink({ poaUrl: input.link }, signal);
+		}),
+		detectQrCode: fromCallback(({ input, sendBack }) => {
+			if (!input.frameCapturer) return () => {};
+			return startQrScan(input.frameCapturer, (link) => {
+				sendBack({
+					type: "QR_DETECTED",
+					link
+				});
+			}, input.applyFocusDelay);
+		})
+	},
+	actions: {
+		setLink: assign(({ event }) => {
+			if (event.type !== "QR_DETECTED") return {};
+			return {
+				link: event.link,
+				error: void 0
+			};
+		}),
+		setError: assign(({ event }) => ({ error: event.error?.message ?? "Submit failed" })),
+		setStream: assign(({ event }) => {
+			const { stream, frameCapturer } = event.output;
+			return {
+				stream,
+				frameCapturer,
+				error: void 0
+			};
+		}),
+		stopStream: assign(({ context }) => {
+			context.frameCapturer?.dispose();
+			if (context.stream) stopCameraStream(context.stream);
+			return {
+				stream: void 0,
+				frameCapturer: void 0
+			};
+		}),
+		incrementAttempts: assign(({ context }) => ({ attempts: context.attempts + 1 })),
+		resetSession: assign(() => ({
+			link: "",
+			error: void 0,
+			attempts: 0
+		})),
+		trackSuccess: () => addEvent({
+			code: "complete",
+			module: eventModuleNames.fiscalQr
+		})
+	},
+	guards: { isMaxAttemptsReached: ({ context }) => context.attempts + 1 >= MAX_ATTEMPTS }
+}).createMachine({
+	id: "fiscalQr",
+	initial: "idle",
+	context: ({ input }) => ({
+		config: input.config,
+		link: "",
+		stream: void 0,
+		error: void 0,
+		attempts: 0
+	}),
+	on: { SKIP: ".finished" },
+	states: {
+		idle: { on: {
+			LOAD: "idle",
+			CONTINUE: {
+				target: "initCamera",
+				actions: "resetSession"
+			}
+		} },
+		initCamera: { invoke: {
+			id: "initCamera",
+			src: "initCamera",
+			input: void 0,
+			onDone: {
+				target: "scanning",
+				actions: "setStream"
+			},
+			onError: {
+				target: "scanning",
+				actions: "setError"
+			}
+		} },
+		scanning: {
+			invoke: {
+				id: "detectQrCode",
+				src: "detectQrCode",
+				input: ({ context }) => ({
+					frameCapturer: context.frameCapturer,
+					applyFocusDelay: context.attempts === 0
+				})
+			},
+			on: {
+				QR_DETECTED: {
+					target: "submitting",
+					actions: "setLink"
+				},
+				RESET: {
+					target: "idle",
+					actions: "stopStream"
+				}
+			}
+		},
+		submitting: { invoke: {
+			id: "submitFiscalQrLink",
+			src: "submitFiscalQrLink",
+			input: ({ context }) => ({ link: context.link }),
+			onDone: {
+				target: "success",
+				actions: "trackSuccess"
+			},
+			onError: [{
+				target: "finished",
+				guard: "isMaxAttemptsReached",
+				actions: ["incrementAttempts", "setError"]
+			}, {
+				target: "error",
+				actions: ["incrementAttempts", "setError"]
+			}]
+		} },
+		success: { after: { [SUCCESS_DISPLAY_MS]: "processing" } },
+		processing: {
+			entry: "stopStream",
+			after: { [PROCESSING_DISPLAY_MS]: "verified" }
+		},
+		verified: { after: { [PROCESSING_DISPLAY_MS]: "finished" } },
+		error: { after: { [ERROR_DISPLAY_MS]: "scanning" } },
+		finished: {
+			type: "final",
+			entry: "stopStream"
+		}
+	}
+});
+
+//#endregion
+//#region src/modules/fiscal-qr/fiscalQrActor.ts
+/**
+* Creates and starts a Fiscal QR actor.
+* The actor begins in 'idle' state, ready to receive events.
+*/
+function createFiscalQrActor(options) {
+	return createActor(fiscalQrMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/fiscal-qr/fiscalQrManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { stream, error, attempts } = typedSnapshot.context;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("initCamera") || typedSnapshot.matches("scanning")) return {
+		status: "scanning",
+		stream,
+		error
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "capturing",
+		stream
+	};
+	if (typedSnapshot.matches("success")) return {
+		status: "success",
+		stream
+	};
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("verified")) return { status: "verified" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error,
+		attempts,
+		stream
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+function createFiscalQrManager(options) {
+	return createManager({
+		actor: createFiscalQrActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.fiscalQr)
+	});
+}
+
+//#endregion
+export { createFiscalQrManager, fiscalQrMachine };

package/dist/flow-events.d.ts

@@ -1,6 +1,7 @@
-import "./camera-DBSxa6ML.js";
-import "./types-CFV9G_7j.js";
-import "./types-BP1m8VRw.js";
-import "./flowCompletionService-DhkT4SRY.js";
-import { a as FlowEventListener, c as FlowModuleStartedEvent, i as FlowEvent, l as FlowReadyEvent, n as FlowCompletedEvent, o as FlowEventSubscribable, r as FlowErrorEvent, s as FlowModuleCompletedEvent, t as FlowClosedEvent, u as FlowStartedEvent } from "./index-BcRG8rtJ.js";
+import "./camera-SRBpPq2X.js";
+import "./types-Bj9hdFjU.js";
+import "./types-DvGZI7BF.js";
+import "./types-DOUhndhT.js";
+import "./flowCompletionService-BdR2cGgB.js";
+import { a as FlowEventListener, c as FlowModuleStartedEvent, i as FlowEvent, l as FlowReadyEvent, n as FlowCompletedEvent, o as FlowEventSubscribable, r as FlowErrorEvent, s as FlowModuleCompletedEvent, t as FlowClosedEvent, u as FlowStartedEvent } from "./index-B5hPA0Bg.js";
 export { FlowClosedEvent, FlowCompletedEvent, FlowErrorEvent, FlowEvent, FlowEventListener, FlowEventSubscribable, FlowModuleCompletedEvent, FlowModuleStartedEvent, FlowReadyEvent, FlowStartedEvent };

package/dist/flow.d.ts

@@ -1,13 +1,14 @@
-import { n as WasmPipeline } from "./warmup-CEcppFiS.js";
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import { t as AnyStateMachine } from "./StateMachine-BCQrZJhf.js";
-import "./camera-DBSxa6ML.js";
-import "./types-CFV9G_7j.js";
-import { i as FlowModuleConfig, n as Flow, r as FlowModule } from "./types-BP1m8VRw.js";
-import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-DhkT4SRY.js";
-import { o as FlowEventSubscribable } from "./index-BcRG8rtJ.js";
-import { n as ModuleRegistry } from "./types-B06Ypu2F.js";
-import * as xstate651 from "xstate";
+import { n as WasmPipeline } from "./warmup-Dg8Lh-50.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as AnyStateMachine } from "./StateMachine-BC_nGvrc.js";
+import "./camera-SRBpPq2X.js";
+import "./types-Bj9hdFjU.js";
+import "./types-DvGZI7BF.js";
+import { i as FlowModuleConfig, n as Flow, r as FlowModule } from "./types-DOUhndhT.js";
+import { n as GetFinishStatusFn, t as FinishStatus } from "./flowCompletionService-BdR2cGgB.js";
+import { o as FlowEventSubscribable } from "./index-B5hPA0Bg.js";
+import { n as ModuleRegistry } from "./types-NuT8ftBV.js";
+import * as xstate715 from "xstate";
 
 //#region src/modules/flow/flowUtils.d.ts
 type NormalizeFlowModulesOptions = {
@@ -59,7 +60,7 @@ type GetFlow = (signal: AbortSignal, options?: GetFlowOptions) => Promise<Flow>;
 declare const getFlow: GetFlow;
 //#endregion
 //#region src/modules/flow/noOpFlowModuleMachine.d.ts
-declare const noOpFlowModuleMachine: xstate651.StateMachine<xstate651.MachineContext, xstate651.AnyEventObject, {}, never, never, never, never, "finished", string, xstate651.NonReducibleUnknown, xstate651.NonReducibleUnknown, xstate651.EventObject, xstate651.MetaObject, {
+declare const noOpFlowModuleMachine: xstate715.StateMachine<xstate715.MachineContext, xstate715.AnyEventObject, {}, never, never, never, never, "finished", string, xstate715.NonReducibleUnknown, xstate715.NonReducibleUnknown, xstate715.EventObject, xstate715.MetaObject, {
   readonly id: "noOpFlowModule";
   readonly initial: "finished";
   readonly states: {
@@ -277,6 +278,8 @@ type OrchestratedFlowFinishedState = {
     redirectionUrl: string;
     action: 'approved' | 'rejected' | 'none';
     scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+    endScreenTitle: string | null;
+    endScreenText: string | null;
   };
   homeScreen: OrchestratedFlowHomeScreen;
   presentation: OrchestratedFlowPresentation;
@@ -328,13 +331,18 @@ declare function createOrchestratedFlowManager(options: CreateOrchestratedFlowAc
    */
   completeFlow(): void;
   /**
-   * Signal that the current module encountered an error.
-   * Call this from your UI component's `onError` callback if you want
-   * the flow to transition to an error state.
+   * Signal that the current module encountered a terminal error, optionally
+   * with its machine-readable `moduleErrorCode`. The flow machine decides what
+   * to do: an advanceable terminal error (e.g. `NONEXISTENT_CUSTOMER`,
+   * `HINT_NOT_PROVIDED`) advances to the next step; any other error transitions
+   * to the terminal error state. Callers always forward the code and let core
+   * classify — no per-module branching in the UI.
    *
    * @param error - Error message describing what went wrong
+   * @param moduleErrorCode - Optional machine-readable error code (a
+   *   `FaceErrorCode`) used by the flow machine to decide advance vs terminate
    */
-  errorModule(error: string): void;
+  errorModule(error: string, moduleErrorCode?: string): void;
   /**
    * Send a raw event to the flow state machine.
    * Prefer using the typed methods (completeModule, errorModule) when possible.

package/dist/flow.esm.js

@@ -1,13 +1,19 @@
 import "./api-CESGtpbH.esm.js";
-import "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import "./session-CGtQJJzB.esm.js";
-import "./IpifyProvider-D7jx52AL.esm.js";
-import "./browserSimulation-gxD8cSpM.esm.js";
-import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
-import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-DG3IdWw6.esm.js";
-import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-CqqwqAkW.esm.js";
-import { t as getFinishStatus } from "./flowCompletionService-P54yzGvA.esm.js";
+import { h as addEvent } from "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./stats-BMNUG1AU.esm.js";
+import "./IpifyProvider-D4LWD15E.esm.js";
+import "./browserSimulation-B1dWiXp7.esm.js";
+import "./sessionInitializer-B8H5MsXM.esm.js";
+import "./platform-SKvEfCBh.esm.js";
+import "./getBrowser-C8DP7oTB.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import "./apiError-B-j-gyDx.esm.js";
+import "./types-DsnEVMhr.esm.js";
+import "./session-DoVb-OcB.esm.js";
+import { n as getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-BTuHLHVr.esm.js";
+import { n as isAdvanceableError, r as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-CuoHZ1cx.esm.js";
+import { t as getFinishStatus } from "./flowCompletionService-DdGojV9K.esm.js";
 
 //#region src/modules/flow/noOpFlowModuleMachine.ts
 const noOpFlowModuleMachine = setup({}).createMachine({
@@ -304,6 +310,13 @@ function getModuleConfig(module, flow) {
 		...config,
 		ageAssurance: config.ageAssurance ?? flow?.ageAssurance
 	};
+	if (module?.key === "FACE_MATCH") {
+		const hasAuthentication = flow?.flowModules?.some((m) => m.key === "AUTHENTICATION") ?? false;
+		return {
+			...config,
+			processFaceBeforeMatch: hasAuthentication
+		};
+	}
 	return config;
 }
 function createBaseContext(context, isHomeContinueLoading) {
@@ -311,6 +324,7 @@ function createBaseContext(context, isHomeContinueLoading) {
 		flow: void 0,
 		error: void 0,
 		errorCode: void 0,
+		moduleErrorCode: void 0,
 		steps: [],
 		currentStepIndex: -1,
 		currentStep: void 0,
@@ -419,9 +433,22 @@ const orchestratedFlowMachine = setup({
 		prefetchNextModule: ({ context }) => {
 			prefetchNextLazyModule(context);
 		},
-		setFinishStatus: assign(({ event }) => ({ finishStatus: event.output }))
+		setFinishStatus: assign(({ event }) => ({ finishStatus: event.output })),
+		setModuleErrorCode: assign(({ event }) => ({ moduleErrorCode: event.moduleErrorCode })),
+		trackAdvanceableModuleError: ({ context, event }) => {
+			addEvent({
+				code: "errorTriggered",
+				module: context.currentStep,
+				payload: {
+					errorCode: event.moduleErrorCode,
+					advanced: true
+				}
+			});
+		}
 	},
 	guards: {
+		isAdvanceableModuleError: ({ event }) => isAdvanceableError(event.moduleErrorCode),
+		isAdvanceableModuleErrorOnLastStep: ({ context, event }) => isAdvanceableError(event.moduleErrorCode) && context.currentStepIndex >= 0 && context.currentStepIndex === context.steps.length - 1,
 		isLastStep: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex === context.steps.length - 1,
 		canGoNext: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex < context.steps.length - 1,
 		shouldEnterHome: ({ context }) => shouldEnterHome(context),
@@ -557,10 +584,26 @@ const orchestratedFlowMachine = setup({
 					target: "resolvingModule",
 					actions: "incrementStep"
 				}],
-				MODULE_ERROR: {
-					target: "error",
-					actions: assign(({ event }) => ({ error: String(event.error) }))
-				},
+				MODULE_ERROR: [
+					{
+						guard: "isAdvanceableModuleErrorOnLastStep",
+						target: "completing",
+						actions: ["setModuleErrorCode", "trackAdvanceableModuleError"]
+					},
+					{
+						guard: "isAdvanceableModuleError",
+						target: "resolvingModule",
+						actions: [
+							"setModuleErrorCode",
+							"trackAdvanceableModuleError",
+							"incrementStep"
+						]
+					},
+					{
+						target: "error",
+						actions: assign(({ event }) => ({ error: String(event.error) }))
+					}
+				],
 				COMPLETE_FLOW: { target: "completing" },
 				RESET: {
 					target: "idle",
@@ -661,7 +704,9 @@ function mapOrchestratedFlowState(snapshot, uiOptions) {
 		finishStatus: context.finishStatus ?? {
 			redirectionUrl: "",
 			action: "none",
-			scoreStatus: "UNKNOWN"
+			scoreStatus: "UNKNOWN",
+			endScreenTitle: null,
+			endScreenText: null
 		},
 		homeScreen: uiModel.homeScreen,
 		presentation: uiModel.presentation
@@ -755,10 +800,11 @@ function createOrchestratedFlowApi({ actor, getSnapshot, trackElementClicked },
 			trackElementClicked?.("completeFlow");
 			actor.send({ type: "COMPLETE_FLOW" });
 		},
-		errorModule(error) {
+		errorModule(error, moduleErrorCode) {
 			actor.send({
 				type: "MODULE_ERROR",
-				error
+				error,
+				moduleErrorCode
 			});
 		},
 		send(event) {

package/dist/flowCompletionService-BdR2cGgB.d.ts

@@ -0,0 +1,19 @@
+//#region src/modules/flow/flowCompletionService.d.ts
+type FinishStatus = {
+  redirectionUrl: string;
+  action: 'approved' | 'rejected' | 'none';
+  scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+  /**
+   * Dashboard-configured completion-screen copy. Sourced from POST /omni/start
+   * (session creation), not /omni/finish-status — `getFinishStatus` itself
+   * always returns `null` here and the orchestrated flow overlays the real
+   * values captured at session creation. `null` when the dashboard has no
+   * end-screen configured. Raw values only; hosts apply their own i18n fallback.
+   */
+  endScreenTitle: string | null;
+  endScreenText: string | null;
+};
+type GetFinishStatusFn = (flowId: string | undefined | null, signal?: AbortSignal) => Promise<FinishStatus>;
+declare const getFinishStatus: GetFinishStatusFn;
+//#endregion
+export { GetFinishStatusFn as n, getFinishStatus as r, FinishStatus as t };

package/dist/flowCompletionService-DdGojV9K.esm.js

@@ -0,0 +1,20 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { n as toIncodeApiError } from "./apiError-B-j-gyDx.esm.js";
+
+//#region src/modules/flow/flowCompletionService.ts
+const getFinishStatus = async (flowId, signal) => {
+	const url = `${endpoints.finishStatus}${flowId ? `?flowId=${flowId}` : ""}`;
+	try {
+		return {
+			...(await api.get(url, { signal })).data,
+			endScreenTitle: null,
+			endScreenText: null
+		};
+	} catch (error) {
+		toIncodeApiError(endpoints.finishStatus, error);
+	}
+};
+
+//#endregion
+export { getFinishStatus as t };

package/dist/{flowServices-DG3IdWw6.esm.js → flowServices-BTuHLHVr.esm.js}

@@ -1,6 +1,7 @@
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { n as getSessionFingerprintResult, r as initializeSession } from "./session-CGtQJJzB.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { n as getSessionFingerprintResult, r as initializeSession } from "./sessionInitializer-B8H5MsXM.esm.js";
+import { n as toIncodeApiError } from "./apiError-B-j-gyDx.esm.js";
 
 //#region src/modules/flow/flowUtils.ts
 const WASM_MODULE_PIPELINES = {
@@ -168,9 +169,13 @@ function prependMandatoryConsent(flow) {
 }
 const getFlow = async (signal, options = {}) => {
 	const sessionPromise = initializeSession({ signal }).catch(() => void 0);
-	const res = await api.get(endpoints.flow, { signal });
-	if (!res.ok) throw new Error(`GET /flow failed: ${res.status} ${res.statusText}`);
-	const data = res.data;
+	const flowResponsePromise = api.get(endpoints.flow, { signal });
+	let data;
+	try {
+		data = (await flowResponsePromise).data;
+	} catch (error) {
+		toIncodeApiError(endpoints.flow, error);
+	}
 	if (data.mandatoryConsentCheck !== false) await sessionPromise;
 	const flow = prependMandatoryConsent(data);
 	const normalizedModules = normalizeFlowModules(flow, options);

package/dist/geolocation.d.ts

@@ -1,5 +1,5 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
 
 //#region ../infra/src/capabilities/IGeolocationCapability.d.ts
 type GeolocationCoords = {
@@ -56,11 +56,11 @@ type GeolocationSubmittingState = {
 };
 /**
  * Location successfully acquired — call `continue()` to proceed
- * @property location - Location name returned from backend, or 'Unknown'
+ * @property location - Location name returned from backend, or null
  */
 type GeolocationAcquiredState = {
   status: 'locationAcquired';
-  location: string;
+  location: string | null;
 };
 /**
  * User denied geolocation permission — shows device-specific instructions