@incodetech/core 2.0.0 → 2.0.1

package/dist/flow.esm.js

@@ -0,0 +1,825 @@
+import "./api-CESGtpbH.esm.js";
+import "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import "./session-CrkWAs-q.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-PiNsxLfK.esm.js";
+import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-CqqwqAkW.esm.js";
+import { t as getFinishStatus } from "./flowCompletionService-P54yzGvA.esm.js";
+
+//#region src/modules/flow/noOpFlowModuleMachine.ts
+const noOpFlowModuleMachine = setup({}).createMachine({
+	id: "noOpFlowModule",
+	initial: "finished",
+	states: { finished: { type: "final" } }
+});
+
+//#endregion
+//#region src/modules/flow/flowStateMachine.ts
+const flowMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: { fetchFlow: fromPromise(async ({ input, signal }) => {
+		return input.getFlow(signal);
+	}) },
+	actions: {
+		resetContext: assign(({ context }) => ({
+			flow: void 0,
+			error: void 0,
+			steps: [],
+			currentStepIndex: -1,
+			currentStep: void 0,
+			config: void 0,
+			getFlow: context.getFlow
+		})),
+		setFlowData: assign(({ event }) => {
+			const flow = event.output;
+			return {
+				flow,
+				steps: (flow.flowModules ?? []).map((m) => m.key),
+				currentStepIndex: (flow.flowModules ?? []).length > 0 ? 0 : -1,
+				currentStep: flow.flowModules?.[0]?.key,
+				config: flow.flowModules?.[0]?.configuration
+			};
+		}),
+		setError: assign(({ event }) => ({ error: String(event.error) })),
+		incrementStep: assign(({ context }) => {
+			const nextIndex = context.currentStepIndex + 1;
+			const module = context.flow?.flowModules?.[nextIndex];
+			return {
+				currentStepIndex: nextIndex,
+				currentStep: module?.key,
+				config: module?.configuration
+			};
+		}),
+		decrementStep: assign(({ context }) => {
+			const prevIndex = context.currentStepIndex - 1;
+			const module = context.flow?.flowModules?.[prevIndex];
+			return {
+				currentStepIndex: prevIndex,
+				currentStep: module?.key,
+				config: module?.configuration
+			};
+		})
+	},
+	guards: {
+		isLastStep: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex === context.steps.length - 1,
+		canGoNext: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex < context.steps.length - 1,
+		canGoPrev: ({ context }) => context.currentStepIndex > 0
+	}
+}).createMachine({
+	id: "flow",
+	initial: "idle",
+	context: ({ input }) => ({
+		flow: void 0,
+		error: void 0,
+		steps: [],
+		currentStepIndex: -1,
+		currentStep: void 0,
+		config: void 0,
+		getFlow: input.getFlow
+	}),
+	states: {
+		idle: { on: { LOAD: {
+			target: "loading",
+			actions: "resetContext"
+		} } },
+		loading: {
+			invoke: {
+				id: "fetchFlow",
+				src: "fetchFlow",
+				input: ({ context }) => ({ getFlow: context.getFlow }),
+				onDone: {
+					target: "ready",
+					actions: "setFlowData"
+				},
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: { CANCEL: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		ready: { on: {
+			NEXT_STEP: [{
+				target: "finished",
+				guard: "isLastStep"
+			}, {
+				target: "ready",
+				guard: "canGoNext",
+				actions: "incrementStep"
+			}],
+			PREV_STEP: {
+				target: "ready",
+				guard: "canGoPrev",
+				actions: "decrementStep"
+			},
+			RESET: {
+				target: "idle",
+				actions: "resetContext"
+			}
+		} },
+		finished: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } },
+		error: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } }
+	}
+});
+
+//#endregion
+//#region src/modules/flow/flowActor.ts
+function createFlowActor(options) {
+	return createActor(flowMachine, { input: { getFlow: options?.getFlow ?? getFlow } }).start();
+}
+
+//#endregion
+//#region src/modules/flow/flowManager.ts
+function mapState(snapshot) {
+	const { value, context } = snapshot;
+	switch (value) {
+		case "idle": return { status: "idle" };
+		case "loading": return { status: "loading" };
+		case "ready": return {
+			status: "ready",
+			flow: context.flow ?? {},
+			steps: context.steps,
+			currentStepIndex: context.currentStepIndex,
+			currentStep: context.currentStep,
+			config: context.config
+		};
+		case "finished": return {
+			status: "finished",
+			flow: context.flow ?? {}
+		};
+		case "error": return {
+			status: "error",
+			error: context.error ?? "Unknown error"
+		};
+		default: return { status: "idle" };
+	}
+}
+function createApi({ actor, getSnapshot, trackElementClicked }) {
+	function getCanNext() {
+		const snapshot = getSnapshot();
+		const { currentStepIndex, steps } = snapshot.context;
+		return snapshot.matches("ready") && currentStepIndex >= 0 && currentStepIndex < steps.length - 1;
+	}
+	function getCanPrev() {
+		const snapshot = getSnapshot();
+		return snapshot.matches("ready") && snapshot.context.currentStepIndex > 0;
+	}
+	function getModuleConfig$1(moduleKey) {
+		const snapshot = getSnapshot();
+		if (!snapshot.matches("ready")) return;
+		return (snapshot.context.flow?.flowModules.find((m) => m.key === moduleKey))?.configuration;
+	}
+	function isModuleEnabled(moduleKey) {
+		const snapshot = getSnapshot();
+		if (!snapshot.matches("ready")) return false;
+		return !!snapshot.context.flow?.flowModules.some((m) => m.key === moduleKey);
+	}
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		cancel() {
+			trackElementClicked?.("cancel");
+			actor.send({ type: "CANCEL" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		nextStep() {
+			trackElementClicked?.("nextStep");
+			actor.send({ type: "NEXT_STEP" });
+		},
+		prevStep() {
+			trackElementClicked?.("prevStep");
+			actor.send({ type: "PREV_STEP" });
+		},
+		get canNext() {
+			return getCanNext();
+		},
+		get canPrev() {
+			return getCanPrev();
+		},
+		getModuleConfig: getModuleConfig$1,
+		isModuleEnabled
+	};
+}
+/**
+* Creates a flow manager instance for managing onboarding flow state and navigation.
+*
+* The flow manager provides:
+* - State management with statuses: `idle`, `loading`, `ready`, `finished`, `error`
+* - Step navigation with `nextStep()` and `prevStep()`
+* - Current step info via `state.currentStep` and `state.config` when in `ready` state
+* - Module configuration lookup via `getModuleConfig()`
+*
+* @param options - Optional configuration for the flow actor
+* @param options.getFlow - Custom function to fetch flow data. Defaults to `getOnboardingFlow`
+* @returns A manager instance with state subscription, API methods, and lifecycle controls
+*
+* @example
+* ```ts
+* const flowManager = createFlowManager();
+*
+* flowManager.subscribe((state) => {
+*   if (state.status === 'ready') {
+*     console.log(state.currentStep, state.config);
+*   }
+* });
+*
+* flowManager.load({ token: 'session-token' });
+* ```
+*/
+function createFlowManager(options) {
+	return attachFlowEventEmitter(createManager({
+		actor: createFlowActor(options),
+		mapState,
+		createApi
+	}));
+}
+
+//#endregion
+//#region src/modules/flow/moduleLoader.ts
+var ModuleLoaderImpl = class {
+	constructor(registry) {
+		this.registry = registry;
+		this.loadedModules = /* @__PURE__ */ new Map();
+		this.prefetchedModules = /* @__PURE__ */ new Set();
+	}
+	async load(moduleKey) {
+		if (!this.registry[moduleKey]) throw new Error(`Module ${moduleKey} not found in registry`);
+		const cached = this.loadedModules.get(moduleKey);
+		if (cached) return await cached;
+		const loadPromise = this.registry[moduleKey]().then((module) => {
+			if (module && typeof module === "object" && "default" in module) return module.default;
+			return module;
+		});
+		this.loadedModules.set(moduleKey, loadPromise);
+		try {
+			return await loadPromise;
+		} catch (error) {
+			this.loadedModules.delete(moduleKey);
+			throw error;
+		}
+	}
+	prefetch(moduleKey) {
+		if (!this.registry[moduleKey]) return;
+		if (this.prefetchedModules.has(moduleKey) || this.loadedModules.has(moduleKey)) return;
+		this.prefetchedModules.add(moduleKey);
+		this.registry[moduleKey]().catch(() => {
+			this.prefetchedModules.delete(moduleKey);
+		});
+	}
+	isLoaded(moduleKey) {
+		return this.loadedModules.has(moduleKey);
+	}
+};
+function createModuleLoader(registry) {
+	return new ModuleLoaderImpl(registry);
+}
+
+//#endregion
+//#region src/modules/flow/orchestratedFlowStateMachine.ts
+function getModuleConfig(module, flow) {
+	const config = {
+		...module?.configuration,
+		ds: flow?.ds
+	};
+	if (module?.key === "ID" || module?.key === "TUTORIAL_ID" || module?.key === "SECOND_ID" || module?.key === "SELFIE") return {
+		...config,
+		ageAssurance: config.ageAssurance ?? flow?.ageAssurance
+	};
+	return config;
+}
+function createBaseContext(context, isHomeContinueLoading) {
+	return {
+		flow: void 0,
+		error: void 0,
+		errorCode: void 0,
+		steps: [],
+		currentStepIndex: -1,
+		currentStep: void 0,
+		config: void 0,
+		getFlow: context.getFlow,
+		registeredModules: context.registeredModules,
+		lazyRegisteredModules: context.lazyRegisteredModules,
+		currentModuleMachine: void 0,
+		getFinishStatus: context.getFinishStatus,
+		enableHome: context.enableHome,
+		finishStatus: void 0,
+		isHomeContinueLoading
+	};
+}
+function createInitialContext(input) {
+	return createBaseContext({
+		getFlow: input.getFlow,
+		registeredModules: input.modules ?? {},
+		lazyRegisteredModules: input.lazyModules ?? {},
+		getFinishStatus: input.getFinishStatus ?? getFinishStatus,
+		enableHome: input.enableHome === true
+	}, false);
+}
+function shouldEnterHome(context) {
+	if (context.enableHome !== true) return false;
+	if (context.flow?.disableLaunchScreen === true) return false;
+	if (context.isHomeContinueLoading === true) return false;
+	const firstRealIndex = context.steps[0] === "REDIRECT_TO_MOBILE" ? 1 : 0;
+	return context.currentStepIndex === firstRealIndex;
+}
+const prefetchedLazyModules = /* @__PURE__ */ new WeakSet();
+function prefetchNextLazyModule(context) {
+	const nextStep = context.steps[context.currentStepIndex + 1];
+	if (!nextStep) return;
+	const nextLazyModule = context.lazyRegisteredModules[nextStep];
+	if (!nextLazyModule || prefetchedLazyModules.has(nextLazyModule)) return;
+	prefetchedLazyModules.add(nextLazyModule);
+	nextLazyModule().catch(() => {
+		prefetchedLazyModules.delete(nextLazyModule);
+	});
+}
+const homeContinueOn = { HOME_CONTINUE: { actions: "setHomeContinueLoading" } };
+const orchestratedFlowMachine = setup({
+	types: {
+		context: {},
+		events: {},
+		input: {}
+	},
+	actors: {
+		fetchFlow: fromPromise(async ({ input, signal }) => {
+			return input.getFlow(signal);
+		}),
+		notifyBackend: fromPromise(async ({ input, signal }) => {
+			return await input.getFinishStatus(input.flowId, signal);
+		}),
+		runChildModule,
+		resolveCurrentModuleMachine: fromPromise(async ({ input }) => {
+			if (!input.moduleKey) return;
+			const eagerMachine = input.modules[input.moduleKey];
+			if (eagerMachine) return eagerMachine;
+			const lazyLoader = input.lazyModules[input.moduleKey];
+			if (!lazyLoader) return;
+			const loaded = await lazyLoader();
+			if (loaded && typeof loaded === "object" && "default" in loaded && loaded.default) return loaded.default;
+			return loaded;
+		})
+	},
+	actions: {
+		resetContext: assign(({ context }) => createBaseContext(context, false)),
+		resetContextForLoad: assign(({ context }) => createBaseContext(context, context.isHomeContinueLoading)),
+		setHomeContinueLoading: assign({ isHomeContinueLoading: true }),
+		clearHomeContinueLoading: assign({ isHomeContinueLoading: false }),
+		setFlowData: assign(({ event }) => {
+			const flow = event.output;
+			const flowModules = flow.flowModules ?? [];
+			const firstModule = flowModules[0];
+			const config = getModuleConfig(firstModule, flow);
+			return {
+				flow,
+				steps: flowModules.map((m) => m.key),
+				currentStepIndex: flowModules.length > 0 ? 0 : -1,
+				currentStep: firstModule?.key,
+				config,
+				currentModuleMachine: void 0
+			};
+		}),
+		setError: assign(({ event }) => {
+			const err = event.error;
+			return {
+				error: err?.message ?? String(err),
+				errorCode: err?.status
+			};
+		}),
+		incrementStep: assign(({ context }) => {
+			const nextIndex = context.currentStepIndex + 1;
+			const module = context.flow?.flowModules?.[nextIndex];
+			const config = getModuleConfig(module, context.flow);
+			return {
+				currentStepIndex: nextIndex,
+				currentStep: module?.key,
+				config,
+				currentModuleMachine: void 0
+			};
+		}),
+		setCurrentModuleMachine: assign(({ event }) => ({ currentModuleMachine: event.output })),
+		prefetchNextModule: ({ context }) => {
+			prefetchNextLazyModule(context);
+		},
+		setFinishStatus: assign(({ event }) => ({ finishStatus: event.output }))
+	},
+	guards: {
+		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),
+		hasModule: ({ context, event }) => {
+			if (!("output" in event)) return false;
+			const firstModuleKey = event.output.flowModules?.[0]?.key;
+			if (!firstModuleKey) return false;
+			return context.registeredModules[firstModuleKey] != null || context.lazyRegisteredModules[firstModuleKey] != null;
+		},
+		hasCurrentModuleMachine: ({ event }) => {
+			if (!("output" in event)) return false;
+			return event.output != null;
+		}
+	}
+}).createMachine({
+	id: "orchestratedFlow",
+	initial: "idle",
+	context: ({ input }) => createInitialContext(input),
+	states: {
+		idle: { on: {
+			LOAD: {
+				target: "loading",
+				actions: "resetContextForLoad"
+			},
+			...homeContinueOn
+		} },
+		loading: {
+			invoke: {
+				id: "fetchFlow",
+				src: "fetchFlow",
+				input: ({ context }) => ({ getFlow: context.getFlow }),
+				onDone: [{
+					target: "resolvingModule",
+					guard: "hasModule",
+					actions: "setFlowData"
+				}, {
+					target: "error",
+					actions: assign({ error: ({ event }) => {
+						const firstModuleKey = event.output.flowModules?.[0]?.key;
+						return firstModuleKey ? `No registered module found for: ${firstModuleKey}` : "No registered module found: flow has no modules";
+					} })
+				}],
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: {
+				CANCEL: {
+					target: "idle",
+					actions: "resetContext"
+				},
+				...homeContinueOn
+			}
+		},
+		resolvingModule: {
+			invoke: {
+				id: "resolveCurrentModuleMachine",
+				src: "resolveCurrentModuleMachine",
+				input: ({ context }) => ({
+					moduleKey: context.currentStep,
+					modules: context.registeredModules,
+					lazyModules: context.lazyRegisteredModules
+				}),
+				onDone: [
+					{
+						target: "home",
+						guard: "shouldEnterHome",
+						actions: ["setCurrentModuleMachine"]
+					},
+					{
+						target: "runningModule",
+						guard: "hasCurrentModuleMachine",
+						actions: ["setCurrentModuleMachine", "prefetchNextModule"]
+					},
+					{
+						target: "error",
+						actions: assign(({ context }) => ({ error: context.currentStep ? `No registered module found for: ${context.currentStep}` : "No registered module found: flow has no modules" }))
+					}
+				],
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: {
+				RESET: {
+					target: "idle",
+					actions: "resetContext"
+				},
+				...homeContinueOn
+			}
+		},
+		home: { on: {
+			HOME_CONTINUE: {
+				target: "runningModule",
+				actions: ["clearHomeContinueLoading", "prefetchNextModule"]
+			},
+			RESET: {
+				target: "idle",
+				actions: "resetContext"
+			}
+		} },
+		runningModule: {
+			entry: "clearHomeContinueLoading",
+			invoke: {
+				id: "currentModule",
+				src: "runChildModule",
+				input: ({ context }) => {
+					if (!context.currentStep) throw new Error("No current step");
+					return {
+						machine: context.currentModuleMachine,
+						config: context.config
+					};
+				},
+				onDone: [{
+					target: "completing",
+					guard: "isLastStep"
+				}, {
+					target: "resolvingModule",
+					actions: "incrementStep"
+				}],
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: {
+				MODULE_COMPLETE: [{
+					target: "completing",
+					guard: "isLastStep"
+				}, {
+					target: "resolvingModule",
+					actions: "incrementStep"
+				}],
+				MODULE_ERROR: {
+					target: "error",
+					actions: assign(({ event }) => ({ error: String(event.error) }))
+				},
+				COMPLETE_FLOW: { target: "completing" },
+				RESET: {
+					target: "idle",
+					actions: "resetContext"
+				}
+			}
+		},
+		completing: {
+			invoke: {
+				id: "notifyBackend",
+				src: "notifyBackend",
+				input: ({ context }) => ({
+					getFinishStatus: context.getFinishStatus,
+					flowId: context.flow?.flowId
+				}),
+				onDone: {
+					target: "finished",
+					actions: "setFinishStatus"
+				},
+				onError: {
+					target: "error",
+					actions: "setError"
+				}
+			},
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		},
+		finished: { on: { RESET: {
+			target: "idle",
+			actions: "resetContext"
+		} } },
+		error: {
+			entry: "clearHomeContinueLoading",
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		}
+	}
+});
+
+//#endregion
+//#region src/modules/flow/orchestratedFlowManager.ts
+function deriveUiModel(snapshot, mappedStatus, isHomePhase, options) {
+	const { enableHome } = options;
+	const serverDisablesLaunch = snapshot.context.flow?.disableLaunchScreen === true;
+	const effectiveEnableHome = enableHome === true && serverDisablesLaunch === false;
+	const isTerminal = mappedStatus === "finished" || mappedStatus === "error";
+	const awaitingOrchestrator = mappedStatus === "idle" || mappedStatus === "loading";
+	const isCompletingPhase = snapshot.value === "completing";
+	const firstRealIndex = snapshot.context.steps[0] === "REDIRECT_TO_MOBILE" ? 1 : 0;
+	const isAtFirstRealModule = snapshot.context.currentStepIndex === firstRealIndex;
+	const isResolvingHomeAnchor = snapshot.value === "resolvingModule" && effectiveEnableHome && isAtFirstRealModule;
+	const isHomeBoundPhase = isHomePhase || isResolvingHomeAnchor;
+	const canShowHome = isTerminal === false && effectiveEnableHome && isCompletingPhase === false;
+	const visible = canShowHome ? isHomeBoundPhase : false;
+	const lazyModuleKey = mappedStatus === "ready" && visible === false ? snapshot.context.currentStep : void 0;
+	const shouldPrefetchHome = canShowHome && snapshot.context.isHomeContinueLoading === false && isHomeBoundPhase;
+	return {
+		homeScreen: {
+			visible,
+			isContinueLoading: isTerminal ? false : snapshot.context.isHomeContinueLoading
+		},
+		presentation: {
+			isAwaitingReady: awaitingOrchestrator,
+			lazyModuleKey,
+			shouldPrefetchHome
+		}
+	};
+}
+function getMappedStatus(snapshot) {
+	const { value } = snapshot;
+	if (value === "idle") return "idle";
+	if (value === "loading" || value === "resolvingModule" || value === "completing" || typeof value === "object") return "loading";
+	if (value === "finished") return "finished";
+	if (value === "error") return "error";
+	return "ready";
+}
+function mapOrchestratedFlowState(snapshot, uiOptions) {
+	const { value, context } = snapshot;
+	const mappedStatus = getMappedStatus(snapshot);
+	const uiModel = deriveUiModel(snapshot, mappedStatus, value === "home", uiOptions);
+	if (mappedStatus === "idle") return {
+		status: "idle",
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	if (mappedStatus === "loading") return {
+		status: "loading",
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	if (mappedStatus === "finished") return {
+		status: "finished",
+		flow: context.flow ?? {},
+		finishStatus: context.finishStatus ?? {
+			redirectionUrl: "",
+			action: "none",
+			scoreStatus: "UNKNOWN"
+		},
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	if (mappedStatus === "error") return {
+		status: "error",
+		error: context.error ?? "Unknown error",
+		errorCode: context.errorCode,
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+	const childSnapshot = value === "runningModule" ? snapshot.children.currentModule?.getSnapshot() : null;
+	return {
+		status: "ready",
+		flow: context.flow ?? {},
+		steps: context.steps,
+		currentStepIndex: context.currentStepIndex,
+		currentStep: context.currentStep,
+		config: context.config,
+		moduleState: childSnapshot ?? null,
+		homeScreen: uiModel.homeScreen,
+		presentation: uiModel.presentation
+	};
+}
+function waitForOrchestratorReadyFromActor(actor, mapState$1, isResolved) {
+	return new Promise((resolve, reject) => {
+		const initial = mapState$1(actor.getSnapshot());
+		if (isResolved(initial)) {
+			resolve();
+			return;
+		}
+		if (initial.status === "error") {
+			reject(new Error(initial.error));
+			return;
+		}
+		if (initial.status === "finished") {
+			reject(/* @__PURE__ */ new Error("Flow finished"));
+			return;
+		}
+		const subscription = actor.subscribe(() => {
+			const next = mapState$1(actor.getSnapshot());
+			if (isResolved(next)) {
+				subscription.unsubscribe();
+				resolve();
+			} else if (next.status === "error") {
+				subscription.unsubscribe();
+				reject(new Error(next.error));
+			} else if (next.status === "finished") {
+				subscription.unsubscribe();
+				reject(/* @__PURE__ */ new Error("Flow finished"));
+			}
+		});
+	});
+}
+function createOrchestratedFlowApi({ actor, getSnapshot, trackElementClicked }, uiOptions) {
+	const { enableHome } = uiOptions;
+	function mapSnapshot() {
+		return mapOrchestratedFlowState(getSnapshot(), { enableHome });
+	}
+	function getCanNext() {
+		const snapshot = getSnapshot();
+		const { currentStepIndex, steps } = snapshot.context;
+		return snapshot.value === "runningModule" && currentStepIndex >= 0 && currentStepIndex < steps.length - 1;
+	}
+	function getModuleConfig$1(moduleKey) {
+		const snapshot = getSnapshot();
+		if (snapshot.value !== "runningModule") return;
+		return (snapshot.context.flow?.flowModules.find((m) => m.key === moduleKey))?.configuration;
+	}
+	function isModuleEnabled(moduleKey) {
+		const snapshot = getSnapshot();
+		if (snapshot.value !== "runningModule") return false;
+		return !!snapshot.context.flow?.flowModules.some((m) => m.key === moduleKey);
+	}
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		cancel() {
+			trackElementClicked?.("cancel");
+			actor.send({ type: "CANCEL" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		},
+		completeModule() {
+			trackElementClicked?.("completeModule");
+			actor.send({ type: "MODULE_COMPLETE" });
+		},
+		completeFlow() {
+			trackElementClicked?.("completeFlow");
+			actor.send({ type: "COMPLETE_FLOW" });
+		},
+		errorModule(error) {
+			actor.send({
+				type: "MODULE_ERROR",
+				error
+			});
+		},
+		send(event) {
+			actor.send(event);
+		},
+		get canNext() {
+			return getCanNext();
+		},
+		getModuleConfig: getModuleConfig$1,
+		isModuleEnabled,
+		isAwaitingOrchestratorReady() {
+			return mapSnapshot().presentation.isAwaitingReady;
+		},
+		async waitForReady() {
+			return waitForOrchestratorReadyFromActor(actor, (snap) => mapOrchestratedFlowState(snap, { enableHome }), (next) => next.status === "ready" && next.presentation.isAwaitingReady === false);
+		},
+		getLazyModuleKey() {
+			return mapSnapshot().presentation.lazyModuleKey;
+		},
+		shouldRenderHomeScreen() {
+			return mapSnapshot().homeScreen.visible;
+		},
+		async continueFromHome() {
+			const state = mapSnapshot();
+			if (!state.homeScreen.visible) return;
+			if (state.status === "ready") {
+				trackElementClicked?.("homeContinue");
+				actor.send({ type: "HOME_CONTINUE" });
+				return;
+			}
+			if (state.presentation.isAwaitingReady) {
+				trackElementClicked?.("homeContinue");
+				actor.send({ type: "HOME_CONTINUE" });
+				try {
+					await waitForOrchestratorReadyFromActor(actor, (snap) => mapOrchestratedFlowState(snap, { enableHome }), (next) => next.status === "ready" && next.homeScreen.visible === false);
+				} catch {
+					return;
+				}
+			}
+		}
+	};
+}
+function createOrchestratedFlowActor(options) {
+	return createActor(orchestratedFlowMachine, { input: {
+		getFlow: options.getFlow ?? getFlow,
+		modules: options.modules,
+		lazyModules: options.lazyModules,
+		getFinishStatus: options.getFinishStatus,
+		enableHome: options.enableHome
+	} }).start();
+}
+function createOrchestratedFlowManager(options) {
+	const actor = createOrchestratedFlowActor(options);
+	const enableHome = options.enableHome === true;
+	const uiOpts = { enableHome };
+	return attachFlowEventEmitter(createManager({
+		actor,
+		mapState: (snapshot) => mapOrchestratedFlowState(snapshot, uiOpts),
+		createApi: (apiOpts) => createOrchestratedFlowApi(apiOpts, { enableHome })
+	}));
+}
+
+//#endregion
+export { createFlowManager, createModuleLoader, createOrchestratedFlowManager, getFlow, getRequiredWasmPipelines, noOpFlowModuleMachine, normalizeFlowModules };