@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/flow.esm.js

@@ -1,825 +0,0 @@
-import "./api-CESGtpbH.esm.js";
-import "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import "./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 getRequiredWasmPipelines, r as normalizeFlowModules, t as getFlow } from "./flowServices-DTsm-Vf1.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 };