@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/workflow.esm.js

@@ -1,702 +0,0 @@
-import "./BaseWasmProvider-C_DLEI40.esm.js";
-import "./BrowserTimerProvider-DhNc_x02.esm.js";
-import { t as api } from "./api-CESGtpbH.esm.js";
-import { o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { n as getSessionFingerprintResult, r as initializeSession } from "./session-BS-d_vuE.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 electronicSignatureMachine } from "./electronicSignatureManager-D9OHzTpG.esm.js";
-import "./ae-signature-DDDZmWXj.esm.js";
-import { t as antifraudMachine } from "./antifraudStateMachine-O0TMf6yc.esm.js";
-import "./faceCaptureSetup-B3faSpYA.esm.js";
-import "./ITimerCapability-C67ZRskg.esm.js";
-import "./camera-PA2Ljri3.esm.js";
-import "./deepsightService-O74l4Y__.esm.js";
-import "./recordingService-Ig2UgbLv.esm.js";
-import "./platform-CfrjKhmi.esm.js";
-import "./backCameraStream-DMdMeGk2.esm.js";
-import "./getBrowser-BSXUTWXw.esm.js";
-import "./stats-CIfiPzb1.esm.js";
-import "./getDeviceClass-BSntT9_j.esm.js";
-import "./MotionSensorProvider-4v7xkqAp.esm.js";
-import "./permissionServices-D_i6nzEw.esm.js";
-import { t as authenticationMachine } from "./authenticationStateMachine-BMZqatiF.esm.js";
-import { t as consentMachine } from "./consentStateMachine-CCT-B60O.esm.js";
-import "./cpf-PPz2Njto.esm.js";
-import { t as curpValidationMachine } from "./curpValidationStateMachine-CitWLr2c.esm.js";
-import { t as documentCaptureMachine } from "./documentCaptureStateMachine-BqzTDy9k.esm.js";
-import { r as toEkybConfig, t as ekybMachine } from "./ekybStateMachine-B59rQjgj.esm.js";
-import "./addressSearch-BpTbTWCa.esm.js";
-import "./flowServices-DTsm-Vf1.esm.js";
-import { r as toEkycConfig, t as ekycMachine } from "./ekycStateMachine-oeO0Iekd.esm.js";
-import { t as emailMachine } from "./emailStateMachine-DOf4j58N.esm.js";
-import { t as selfieMachine } from "./selfieStateMachine-D76whWEf.esm.js";
-import { t as idCaptureMachine } from "./idCaptureStateMachine-Bq0fVZXl.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-CuPARRaT.esm.js";
-import { t as faceMatchMachine } from "./faceMatchStateMachine-DNFrxTFS.esm.js";
-import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-CqqwqAkW.esm.js";
-import { t as getFinishStatus } from "./flowCompletionService-P54yzGvA.esm.js";
-import { t as geolocationMachine } from "./geolocationStateMachine-asasuHY2.esm.js";
-import { t as governmentValidationMachine } from "./governmentValidationStateMachine-BDDYrJTo.esm.js";
-import { t as idOcrStateMachine } from "./idOcrStateMachine-YbjjC_Gg.esm.js";
-import { t as idVerificationMachine } from "./idVerificationStateMachine-xbw9HP1Z.esm.js";
-import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-Cnco1jvn.esm.js";
-import "./qe-signature-DFo_Cc-I.esm.js";
-import { t as redirectToMobileMachine } from "./redirectToMobileStateMachine-BOEqe46A.esm.js";
-import { t as signatureMachine } from "./signatureStateMachine-B5-QVUve.esm.js";
-
-//#region src/internal/orchestration/defaultModules.ts
-/**
-* Shared default module registry — single source of truth for module key → machine mappings.
-* Used by Workflow (eager loading). Flow uses lazy imports instead (see flowInit.ts).
-*
-* When adding a new module to the SDK, add it here AND to Flow's getLazyCoreMachineLoader.
-*/
-/**
-* Base module registry with all known SDK modules.
-* Module keys match what the backend sends in flow/workflow configuration.
-*/
-const DEFAULT_MODULE_REGISTRY = {
-	PHONE: phoneMachine,
-	EMAIL: emailMachine,
-	SELFIE: selfieMachine,
-	AUTHENTICATION: authenticationMachine,
-	ID: idCaptureMachine,
-	TUTORIAL_ID: idCaptureMachine,
-	SECOND_ID: idCaptureMachine,
-	FACE_MATCH: faceMatchMachine,
-	CURP_VALIDATION: curpValidationMachine,
-	GOVT_VALIDATION_PROVISIONING: governmentValidationMachine,
-	GEOLOCATION: geolocationMachine,
-	EXTERNAL_VERIFICATION: ekycMachine,
-	EKYB: ekybMachine,
-	DOCUMENT_CAPTURE: documentCaptureMachine,
-	ADDRESS: documentCaptureMachine,
-	COMBINED_CONSENT: consentMachine,
-	MANDATORY_CONSENT: mandatoryConsentMachine,
-	SIGNATURE: signatureMachine,
-	ANTIFRAUD: antifraudMachine,
-	ID_OCR: idOcrStateMachine,
-	AE_SIGNATURE: electronicSignatureMachine,
-	QE_SIGNATURE: electronicSignatureMachine
-};
-/**
-* Per-module config mappers for orchestrators (workflow / flow).
-*
-* The backend's workflow-node `moduleConfiguration` shape is not always the
-* same as the module's `Config` type. Modules that need remapping register a
-* mapper here; everything else falls through with identity.
-*
-* Owned by core so that core-only orchestrator consumers (no `@incodetech/web`)
-* receive correctly shaped configs.
-*
-* When adding a new module whose workflow-node config differs from its
-* manager's `Config` type, add a mapper entry below.
-*/
-const DEFAULT_MODULE_CONFIG_MAPPERS = {
-	EXTERNAL_VERIFICATION: (raw) => toEkycConfig(raw),
-	EKYB: (raw) => toEkybConfig(raw)
-};
-/**
-* Applies the module-specific config mapper (if registered) to the raw node
-* config. Used by the workflow manager (`mapState`, `getModuleConfig`) and
-* the workflow state machine (`runningModule.invoke.input`) so all surfaces
-* agree on the shape consumers see.
-*
-* Mappers always return an object shape; the cast back to
-* `Record<string, unknown>` preserves the surrounding API contract.
-*/
-function applyConfigMapper(moduleKey, raw, mappers) {
-	const mapper = moduleKey ? mappers[moduleKey] : void 0;
-	return mapper ? mapper(raw) : raw;
-}
-
-//#endregion
-//#region src/modules/workflow/workflowServices.ts
-function assertWorkflowNode(data, endpoint) {
-	const obj = data;
-	if (!obj || typeof obj.nodeType !== "string") throw new Error(`Invalid response from ${endpoint}: missing nodeType`);
-}
-function assertWorkflowConfig(data, endpoint) {
-	const obj = data;
-	if (!obj || typeof obj.id !== "string") throw new Error(`Invalid response from ${endpoint}: missing id`);
-}
-async function getCurrentNode(signal) {
-	const res = await api.get(endpoints.workflowCurrentNode, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.workflowCurrentNode} failed: ${res.status} ${res.statusText}`);
-	assertWorkflowNode(res.data, endpoints.workflowCurrentNode);
-	return res.data;
-}
-async function processNode(signal) {
-	const res = await api.post(endpoints.workflowProcessNode, {}, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.workflowProcessNode} failed: ${res.status} ${res.statusText}`);
-	assertWorkflowNode(res.data, endpoints.workflowProcessNode);
-	return res.data;
-}
-async function getWorkflowConfig(signal) {
-	const res = await api.get(endpoints.workflowInfo, { signal });
-	if (!res.ok) throw new Error(`GET ${endpoints.workflowInfo} failed: ${res.status} ${res.statusText}`);
-	assertWorkflowConfig(res.data, endpoints.workflowInfo);
-	return res.data;
-}
-async function processCustomNode(data, signal) {
-	const res = await api.post(endpoints.customModuleExecution, data, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.customModuleExecution} failed: ${res.status} ${res.statusText}`);
-}
-
-//#endregion
-//#region src/modules/workflow/workflowActors.ts
-async function loadWorkflow(input, signal) {
-	await initializeSession({ signal }).catch(() => void 0);
-	const workflowConfig = await getWorkflowConfig(signal);
-	const realNode = await getCurrentNode(signal);
-	const fingerprintResult = getSessionFingerprintResult();
-	let currentNode = realNode;
-	let firstNode;
-	let isInjectedNode = false;
-	if (fingerprintResult?.showMandatoryConsent) {
-		firstNode = realNode;
-		isInjectedNode = true;
-		currentNode = {
-			id: "injected-mandatory-consent",
-			nodeType: "MODULE",
-			moduleKey: "MANDATORY_CONSENT",
-			moduleConfiguration: { consentType: fingerprintResult.regulationType ?? "Other" },
-			status: "INJECTED",
-			workflowId: workflowConfig.id
-		};
-	} else if (workflowConfig.redirectDesktopToMobile && input.isDesktop) {
-		firstNode = realNode;
-		isInjectedNode = true;
-		currentNode = {
-			id: "injected-redirect-to-mobile",
-			nodeType: "MODULE",
-			moduleKey: "REDIRECT_TO_MOBILE",
-			moduleConfiguration: {
-				disableSmsOption: workflowConfig.disableSmsOption ?? false,
-				addContinueToDesktop: workflowConfig.addContinueToDesktop ?? false,
-				qrPhishingResistance: workflowConfig.qrPhishingResistance ?? false
-			},
-			status: "INJECTED",
-			workflowId: workflowConfig.id
-		};
-	}
-	return {
-		workflowConfig,
-		currentNode,
-		firstNode,
-		isInjectedNode
-	};
-}
-async function processNextNode(input, signal) {
-	if (input.isInjectedNode && input.firstNode) {
-		if (input.currentNodeModuleKey === "MANDATORY_CONSENT" && input.workflowRedirectDesktopToMobile && input.isDesktop) return {
-			nextNode: {
-				id: "injected-redirect-to-mobile",
-				nodeType: "MODULE",
-				moduleKey: "REDIRECT_TO_MOBILE",
-				moduleConfiguration: {
-					disableSmsOption: input.workflowDisableSmsOption,
-					addContinueToDesktop: input.workflowAddContinueToDesktop,
-					qrPhishingResistance: input.workflowQrPhishingResistance
-				},
-				status: "INJECTED",
-				workflowId: input.workflowConfigId ?? ""
-			},
-			isInjectedNode: true
-		};
-		return {
-			nextNode: input.firstNode,
-			isInjectedNode: false
-		};
-	}
-	return {
-		nextNode: await processNode(signal),
-		isInjectedNode: false
-	};
-}
-async function handleCustomModule(input, signal) {
-	const { currentNode, interviewId, customModuleCallback } = input;
-	const callbackName = currentNode.moduleConfiguration?.callbackName ?? "";
-	const customData = {
-		interviewId,
-		status: "UNKNOWN",
-		message: null,
-		callbackName,
-		nodeId: currentNode.id
-	};
-	if (customModuleCallback) {
-		const result = await new Promise((resolve, reject) => {
-			const onAbort = () => reject(/* @__PURE__ */ new Error("Custom module aborted"));
-			signal.addEventListener("abort", onAbort);
-			customModuleCallback({
-				onSuccess: (message) => {
-					signal.removeEventListener("abort", onAbort);
-					resolve({
-						status: "OK",
-						message: message ?? null
-					});
-				},
-				onError: (message) => {
-					signal.removeEventListener("abort", onAbort);
-					resolve({
-						status: "FAIL",
-						message: message ?? null
-					});
-				},
-				interviewId,
-				nodeId: currentNode.id,
-				name: callbackName
-			});
-		});
-		customData.status = result.status;
-		customData.message = result.message;
-	}
-	await processCustomNode(customData, signal);
-	return await processNode(signal);
-}
-async function resolveModule(input) {
-	const entry = input.registeredModules[input.moduleKey];
-	if (!entry) throw new Error(`Unknown module type: ${input.moduleKey}. Ensure all workflow modules are registered.`);
-	if (typeof entry === "function") return entry();
-	return entry;
-}
-
-//#endregion
-//#region src/modules/workflow/workflowStateMachine.ts
-function extractErrorInfo(err) {
-	const error = err;
-	return {
-		message: error?.message ?? String(err),
-		code: error?.status
-	};
-}
-function extractNodeFromOutput(output) {
-	const obj = output;
-	if ("nextNode" in obj) return obj.nextNode;
-	if ("currentNode" in obj) return obj.currentNode;
-	if ("nodeType" in obj) return obj;
-	throw new Error("Unexpected actor output shape: cannot extract WorkflowNode");
-}
-const workflowMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		loadWorkflow: fromPromise(({ input, signal }) => loadWorkflow(input, signal)),
-		processNextNode: fromPromise(({ input, signal }) => processNextNode(input, signal)),
-		handleCustomModule: fromPromise(({ input, signal }) => handleCustomModule(input, signal)),
-		resolveModule: fromPromise(({ input }) => resolveModule(input)),
-		notifyBackend: fromPromise(async ({ input, signal }) => {
-			return input.getFinishStatus(input.workflowId, signal);
-		}),
-		runChildModule
-	},
-	actions: {
-		setLoadingResult: assign(({ event }) => {
-			const result = event.output;
-			return {
-				workflowConfig: result.workflowConfig,
-				currentNode: result.currentNode,
-				firstNode: result.firstNode,
-				isInjectedNode: result.isInjectedNode
-			};
-		}),
-		setNextNode: assign(({ event }) => {
-			const result = event.output;
-			return {
-				currentNode: result.nextNode,
-				isInjectedNode: result.isInjectedNode
-			};
-		}),
-		setCustomModuleResult: assign(({ event }) => {
-			return {
-				currentNode: event.output,
-				isInjectedNode: false
-			};
-		}),
-		setResolvedMachine: assign(({ event }) => ({ resolvedMachine: event.output })),
-		setFinishStatus: assign(({ event }) => ({ finishStatus: event.output })),
-		setError: assign(({ event }) => {
-			const { message, code } = extractErrorInfo(event.error);
-			return {
-				error: message,
-				errorCode: code
-			};
-		}),
-		setModuleError: assign(({ event }) => ({ error: String(event.error) })),
-		setHomeContinueLoading: assign({ isHomeContinueLoading: true }),
-		clearHomeContinueLoading: assign({ isHomeContinueLoading: false })
-	},
-	guards: {
-		isModuleNode: ({ event }) => {
-			const output = event.output;
-			return extractNodeFromOutput(output).nodeType === "MODULE";
-		},
-		isFinishNode: ({ event }) => {
-			const output = event.output;
-			return extractNodeFromOutput(output).nodeType === "FINISH";
-		},
-		isAsyncResolutionNode: ({ event }) => {
-			const output = event.output;
-			return extractNodeFromOutput(output).nodeType === "ASYNC_RESOLUTION";
-		},
-		isCustomModule: ({ context }) => {
-			return context.currentNode?.moduleKey === "CUSTOM_MODULE";
-		},
-		shouldEnterHome: ({ event }) => {
-			const result = event.output;
-			if (!result || result.currentNode.nodeType !== "MODULE") return false;
-			if (result.workflowConfig.disableLaunchScreen === true) return false;
-			if (result.currentNode.moduleKey === "REDIRECT_TO_MOBILE") return false;
-			return true;
-		}
-	}
-}).createMachine({
-	id: "workflow",
-	initial: "idle",
-	context: ({ input }) => ({
-		workflowConfig: void 0,
-		currentNode: void 0,
-		firstNode: void 0,
-		resolvedMachine: void 0,
-		error: void 0,
-		errorCode: void 0,
-		registeredModules: input.modules,
-		configMappers: input.configMappers ?? {},
-		finishStatus: void 0,
-		customModuleCallback: input.customModuleCallback,
-		interviewId: input.interviewId ?? "",
-		isDesktop: input.isDesktop ?? true,
-		isInjectedNode: false,
-		isHomeContinueLoading: false,
-		getFinishStatus: input.getFinishStatus ?? getFinishStatus
-	}),
-	states: {
-		idle: { on: { LOAD: "loading" } },
-		loading: { invoke: {
-			id: "loadWorkflow",
-			src: "loadWorkflow",
-			input: ({ context }) => ({ isDesktop: context.isDesktop }),
-			onDone: [
-				{
-					target: "home",
-					guard: "shouldEnterHome",
-					actions: "setLoadingResult"
-				},
-				{
-					target: "resolvingModule",
-					guard: "isModuleNode",
-					actions: "setLoadingResult"
-				},
-				{
-					target: "completing",
-					guard: "isFinishNode",
-					actions: "setLoadingResult"
-				},
-				{
-					target: "asyncResolution",
-					guard: "isAsyncResolutionNode",
-					actions: "setLoadingResult"
-				}
-			],
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		home: { on: { HOME_CONTINUE: {
-			target: "resolvingModule",
-			actions: "setHomeContinueLoading"
-		} } },
-		resolvingModule: {
-			always: [{
-				target: "handlingCustomModule",
-				guard: "isCustomModule"
-			}],
-			invoke: {
-				id: "resolveModule",
-				src: "resolveModule",
-				input: ({ context }) => ({
-					moduleKey: context.currentNode.moduleKey,
-					registeredModules: context.registeredModules
-				}),
-				onDone: {
-					target: "runningModule",
-					actions: "setResolvedMachine"
-				},
-				onError: {
-					target: "error",
-					actions: "setError"
-				}
-			}
-		},
-		runningModule: {
-			entry: "clearHomeContinueLoading",
-			invoke: {
-				id: "currentModule",
-				src: "runChildModule",
-				input: ({ context }) => {
-					const config = applyConfigMapper(context.currentNode?.moduleKey, {
-						...context.currentNode?.moduleConfiguration,
-						ds: context.workflowConfig?.ds
-					}, context.configMappers);
-					return {
-						machine: context.resolvedMachine,
-						config
-					};
-				}
-			},
-			on: {
-				MODULE_COMPLETE: "processingNode",
-				MODULE_ERROR: {
-					target: "error",
-					actions: "setModuleError"
-				},
-				COMPLETE_FLOW: "completing"
-			}
-		},
-		handlingCustomModule: { invoke: {
-			id: "customModule",
-			src: "handleCustomModule",
-			input: ({ context }) => ({
-				currentNode: context.currentNode,
-				interviewId: context.interviewId,
-				customModuleCallback: context.customModuleCallback
-			}),
-			onDone: [
-				{
-					target: "resolvingModule",
-					guard: "isModuleNode",
-					actions: "setCustomModuleResult"
-				},
-				{
-					target: "completing",
-					guard: "isFinishNode",
-					actions: "setCustomModuleResult"
-				},
-				{
-					target: "asyncResolution",
-					guard: "isAsyncResolutionNode",
-					actions: "setCustomModuleResult"
-				}
-			],
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		processingNode: { invoke: {
-			id: "processNext",
-			src: "processNextNode",
-			input: ({ context }) => ({
-				isInjectedNode: context.isInjectedNode,
-				firstNode: context.firstNode,
-				currentNodeModuleKey: context.currentNode?.moduleKey,
-				workflowConfigId: context.workflowConfig?.id,
-				workflowRedirectDesktopToMobile: context.workflowConfig?.redirectDesktopToMobile ?? false,
-				workflowDisableSmsOption: context.workflowConfig?.disableSmsOption ?? false,
-				workflowAddContinueToDesktop: context.workflowConfig?.addContinueToDesktop ?? false,
-				workflowQrPhishingResistance: context.workflowConfig?.qrPhishingResistance ?? false,
-				isDesktop: context.isDesktop
-			}),
-			onDone: [
-				{
-					target: "resolvingModule",
-					guard: "isModuleNode",
-					actions: "setNextNode",
-					reenter: true
-				},
-				{
-					target: "completing",
-					guard: "isFinishNode",
-					actions: "setNextNode"
-				},
-				{
-					target: "asyncResolution",
-					guard: "isAsyncResolutionNode",
-					actions: "setNextNode"
-				}
-			],
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		completing: { invoke: {
-			id: "notifyBackend",
-			src: "notifyBackend",
-			input: ({ context }) => ({
-				getFinishStatus: context.getFinishStatus,
-				workflowId: context.workflowConfig?.id
-			}),
-			onDone: {
-				target: "finished",
-				actions: "setFinishStatus"
-			},
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		finished: { type: "final" },
-		asyncResolution: { type: "final" },
-		closed: { type: "final" },
-		error: { type: "final" }
-	}
-});
-
-//#endregion
-//#region src/modules/workflow/workflowActor.ts
-function createWorkflowActor(options) {
-	return createActor(workflowMachine, { input: {
-		modules: options.modules,
-		configMappers: options.configMappers,
-		customModuleCallback: options.customModuleCallback,
-		interviewId: options.interviewId,
-		isDesktop: options.isDesktop
-	} }).start();
-}
-
-//#endregion
-//#region src/internal/orchestration/identity-search/identitySearchStateMachine.ts
-const identitySearchMachine = setup({ types: {
-	context: {},
-	input: {}
-} }).createMachine({
-	id: "identitySearch",
-	initial: "done",
-	context: {},
-	states: { done: { type: "final" } }
-});
-
-//#endregion
-//#region src/modules/workflow/workflowManager.ts
-const WORKFLOW_DEFAULT_MODULES = {
-	...DEFAULT_MODULE_REGISTRY,
-	IDENTITY_SEARCH: identitySearchMachine,
-	ID_CAPTURE: idCaptureMachine,
-	ID: idVerificationMachine,
-	REDIRECT_TO_MOBILE: redirectToMobileMachine
-};
-function deriveHomeScreen(snapshot) {
-	return {
-		visible: snapshot.matches("home"),
-		isContinueLoading: snapshot.context.isHomeContinueLoading
-	};
-}
-/**
-* Builds the current node's config and applies the module-specific config
-* mapper (if any). Single source of truth for the shape consumers see —
-* used by both `mapState` and `getModuleConfig`. The same `applyConfigMapper`
-* is invoked at the child-actor boundary in `workflowStateMachine` so all
-* surfaces agree.
-*/
-function resolveCurrentModuleConfig(moduleKey, moduleConfiguration, ds, mappers) {
-	return applyConfigMapper(moduleKey, {
-		...moduleConfiguration ?? {},
-		ds
-	}, mappers);
-}
-function mapState(snapshot) {
-	const { context } = snapshot;
-	const homeScreen = deriveHomeScreen(snapshot);
-	if (snapshot.matches("idle")) return {
-		status: "idle",
-		homeScreen
-	};
-	if (snapshot.matches("runningModule")) {
-		const childSnapshot = snapshot.children.currentModule?.getSnapshot();
-		return {
-			status: "ready",
-			workflowConfig: context.workflowConfig,
-			currentNode: context.currentNode,
-			config: resolveCurrentModuleConfig(context.currentNode?.moduleKey, context.currentNode?.moduleConfiguration, context.workflowConfig?.ds, context.configMappers),
-			moduleState: childSnapshot ?? null,
-			homeScreen
-		};
-	}
-	if (snapshot.matches("finished")) return {
-		status: "finished",
-		workflowConfig: context.workflowConfig,
-		finishStatus: context.finishStatus ?? {
-			redirectionUrl: "",
-			action: "none",
-			scoreStatus: "UNKNOWN"
-		}
-	};
-	if (snapshot.matches("asyncResolution")) return {
-		status: "asyncResolution",
-		workflowConfig: context.workflowConfig,
-		currentNode: context.currentNode
-	};
-	if (snapshot.matches("closed")) return { status: "closed" };
-	if (snapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "Unknown error",
-		errorCode: context.errorCode
-	};
-	return {
-		status: "loading",
-		homeScreen
-	};
-}
-function createApi({ actor, getSnapshot, trackElementClicked }) {
-	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		completeModule() {
-			trackElementClicked?.("completeModule");
-			actor.send({ type: "MODULE_COMPLETE" });
-		},
-		completeFlow() {
-			trackElementClicked?.("completeFlow");
-			actor.send({ type: "COMPLETE_FLOW" });
-		},
-		errorModule(error) {
-			actor.send({
-				type: "MODULE_ERROR",
-				error
-			});
-		},
-		continueFromHome() {
-			trackElementClicked?.("homeContinue");
-			actor.send({ type: "HOME_CONTINUE" });
-		},
-		getModuleConfig() {
-			const snapshot = getSnapshot();
-			if (snapshot.value !== "runningModule") return void 0;
-			return resolveCurrentModuleConfig(snapshot.context.currentNode?.moduleKey, snapshot.context.currentNode?.moduleConfiguration, snapshot.context.workflowConfig?.ds, snapshot.context.configMappers);
-		}
-	};
-}
-/**
-* Creates a workflow manager for server-driven onboarding flows.
-*
-* Only one orchestrator (Flow or Workflow) should be active per session.
-* Each session token maps to a single orchestrator run. To start a new
-* workflow, create a new session and call `setup()` with the new token
-* before creating a new manager.
-*/
-function createWorkflowManager(options = {}) {
-	return attachFlowEventEmitter(createManager({
-		actor: createWorkflowActor({
-			modules: WORKFLOW_DEFAULT_MODULES,
-			configMappers: DEFAULT_MODULE_CONFIG_MAPPERS,
-			customModuleCallback: options.customModuleCallback,
-			interviewId: options.interviewId,
-			isDesktop: options.isDesktop
-		}),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation("WORKFLOW")
-	}), { interviewId: options.interviewId });
-}
-
-//#endregion
-export { createWorkflowManager, workflowMachine };