@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/workflow.esm.js

@@ -0,0 +1,702 @@
+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 };