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

package/dist/flow.esm.js

@@ -1,48 +1,20 @@
-import { g as createManager, n as api, t as endpoints } from "./endpoints-BSTFaHYo.esm.js";
-import { a as createActor, i as fromPromise, n as assign, r as fromCallback, t as setup } from "./xstate.esm-B_rda9yU.esm.js";
+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/flowAnalyzer.ts
-const WASM_MODULE_PIPELINES = {
-	SELFIE: "selfie",
-	AUTHENTICATION: "selfie",
-	FACE_MATCH: "selfie",
-	VIDEO_ONBOARDING: "selfie",
-	ID: "idCapture",
-	TUTORIAL_ID: "idCapture",
-	SECOND_ID: "idCapture",
-	THIRD_ID: "idCapture"
-};
-/**
-* Analyzes a flow configuration and returns the WASM pipelines needed.
-* Use this to conditionally warmup WASM only when required by the flow.
-*
-* @param flow - The flow configuration from /omni/onboarding/flow
-* @returns Array of WASM pipelines needed (e.g., ['selfie', 'idCapture'])
-*
-* @example
-* ```typescript
-* const pipelines = getRequiredWasmPipelines(flow);
-* if (pipelines.length > 0) {
-*   warmupWasm({ ...wasmConfig, pipelines });
-* }
-* ```
-*/
-function getRequiredWasmPipelines(flow) {
-	const pipelines = /* @__PURE__ */ new Set();
-	for (const module of flow.flowModules) {
-		const pipeline = WASM_MODULE_PIPELINES[module.key];
-		if (pipeline) pipelines.add(pipeline);
-	}
-	return [...pipelines];
-}
-
-//#endregion
-//#region src/modules/flow/flowServices.ts
-const getFlow = async (signal) => {
-	const res = await api.get(endpoints.flow, { signal });
-	if (!res.ok) throw new Error(`GET /flow failed: ${res.status} ${res.statusText}`);
-	return res.data;
-};
+//#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
@@ -174,7 +146,7 @@ function createFlowActor(options) {
 
 //#endregion
 //#region src/modules/flow/flowManager.ts
-function mapState$1(snapshot) {
+function mapState(snapshot) {
 	const { value, context } = snapshot;
 	switch (value) {
 		case "idle": return { status: "idle" };
@@ -198,7 +170,7 @@ function mapState$1(snapshot) {
 		default: return { status: "idle" };
 	}
 }
-function createApi$1({ actor, getSnapshot }) {
+function createApi({ actor, getSnapshot, trackElementClicked }) {
 	function getCanNext() {
 		const snapshot = getSnapshot();
 		const { currentStepIndex, steps } = snapshot.context;
@@ -208,7 +180,7 @@ function createApi$1({ actor, getSnapshot }) {
 		const snapshot = getSnapshot();
 		return snapshot.matches("ready") && snapshot.context.currentStepIndex > 0;
 	}
-	function getModuleConfig(moduleKey) {
+	function getModuleConfig$1(moduleKey) {
 		const snapshot = getSnapshot();
 		if (!snapshot.matches("ready")) return;
 		return (snapshot.context.flow?.flowModules.find((m) => m.key === moduleKey))?.configuration;
@@ -223,15 +195,18 @@ function createApi$1({ actor, getSnapshot }) {
 			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() {
@@ -240,7 +215,7 @@ function createApi$1({ actor, getSnapshot }) {
 		get canPrev() {
 			return getCanPrev();
 		},
-		getModuleConfig,
+		getModuleConfig: getModuleConfig$1,
 		isModuleEnabled
 	};
 }
@@ -271,11 +246,11 @@ function createApi$1({ actor, getSnapshot }) {
 * ```
 */
 function createFlowManager(options) {
-	return createManager({
+	return attachFlowEventEmitter(createManager({
 		actor: createFlowActor(options),
-		mapState: mapState$1,
-		createApi: createApi$1
-	});
+		mapState,
+		createApi
+	}));
 }
 
 //#endregion
@@ -318,17 +293,66 @@ function createModuleLoader(registry) {
 	return new ModuleLoaderImpl(registry);
 }
 
-//#endregion
-//#region src/modules/flow/flowCompletionService.ts
-const getFinishStatus = async (flowId, signal) => {
-	const url = `/omni/finish-status${flowId ? `?flowId=${flowId}` : ""}`;
-	const res = await api.get(url, { signal });
-	if (!res.ok) throw new Error(`GET ${url} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-};
-
 //#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: {},
@@ -342,125 +366,174 @@ const orchestratedFlowMachine = setup({
 		notifyBackend: fromPromise(async ({ input, signal }) => {
 			return await input.getFinishStatus(input.flowId, signal);
 		}),
-		runChildModule: fromCallback(({ sendBack, input }) => {
-			const { machine, config } = input;
-			const actor = createActor(machine, { input: { config } });
-			const subscription = actor.subscribe({
-				complete: () => {
-					sendBack({ type: "MODULE_COMPLETE" });
-				},
-				error: (err) => {
-					sendBack({
-						type: "MODULE_ERROR",
-						error: err
-					});
-				}
-			});
-			actor.start();
-			return () => {
-				subscription.unsubscribe();
-				actor.stop();
-			};
+		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 }) => ({
-			flow: void 0,
-			error: void 0,
-			steps: [],
-			currentStepIndex: -1,
-			currentStep: void 0,
-			config: void 0,
-			getFlow: context.getFlow,
-			registeredModules: context.registeredModules,
-			getFinishStatus: context.getFinishStatus,
-			finishStatus: void 0
-		})),
+		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: (flow.flowModules ?? []).map((m) => m.key),
-				currentStepIndex: (flow.flowModules ?? []).length > 0 ? 0 : -1,
-				currentStep: flow.flowModules?.[0]?.key,
-				config: flow.flowModules?.[0]?.configuration
+				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
 			};
 		}),
-		setError: assign(({ event }) => ({ error: String(event.error) })),
 		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: module?.configuration
+				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;
+			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 }) => ({
-		flow: void 0,
-		error: void 0,
-		steps: [],
-		currentStepIndex: -1,
-		currentStep: void 0,
-		config: void 0,
-		getFlow: input.getFlow,
-		registeredModules: input.modules,
-		getFinishStatus: input.getFinishStatus ?? getFinishStatus,
-		finishStatus: void 0
-	}),
+	context: ({ input }) => createInitialContext(input),
 	states: {
-		idle: { on: { LOAD: {
-			target: "loading",
-			actions: "resetContext"
-		} } },
+		idle: { on: {
+			LOAD: {
+				target: "loading",
+				actions: "resetContextForLoad"
+			},
+			...homeContinueOn
+		} },
 		loading: {
 			invoke: {
 				id: "fetchFlow",
 				src: "fetchFlow",
 				input: ({ context }) => ({ getFlow: context.getFlow }),
 				onDone: [{
-					target: "runningModule",
+					target: "resolvingModule",
 					guard: "hasModule",
 					actions: "setFlowData"
 				}, {
 					target: "error",
-					actions: assign({ error: () => "No registered module found for flow" })
+					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: {
+			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");
-					const machine = context.registeredModules[context.currentStep];
-					if (!machine) throw new Error(`Module ${context.currentStep} not registered`);
 					return {
-						machine,
+						machine: context.currentModuleMachine,
 						config: context.config
 					};
 				},
@@ -468,9 +541,8 @@ const orchestratedFlowMachine = setup({
 					target: "completing",
 					guard: "isLastStep"
 				}, {
-					target: "runningModule",
-					actions: "incrementStep",
-					reenter: true
+					target: "resolvingModule",
+					actions: "incrementStep"
 				}],
 				onError: {
 					target: "error",
@@ -482,14 +554,14 @@ const orchestratedFlowMachine = setup({
 					target: "completing",
 					guard: "isLastStep"
 				}, {
-					target: "runningModule",
-					actions: "incrementStep",
-					reenter: true
+					target: "resolvingModule",
+					actions: "incrementStep"
 				}],
 				MODULE_ERROR: {
 					target: "error",
 					actions: assign(({ event }) => ({ error: String(event.error) }))
 				},
+				COMPLETE_FLOW: { target: "completing" },
 				RESET: {
 					target: "idle",
 					actions: "resetContext"
@@ -522,55 +594,139 @@ const orchestratedFlowMachine = setup({
 			target: "idle",
 			actions: "resetContext"
 		} } },
-		error: { on: { RESET: {
-			target: "idle",
-			actions: "resetContext"
-		} } }
+		error: {
+			entry: "clearHomeContinueLoading",
+			on: { RESET: {
+				target: "idle",
+				actions: "resetContext"
+			} }
+		}
 	}
 });
 
 //#endregion
 //#region src/modules/flow/orchestratedFlowManager.ts
-function mapState(snapshot) {
+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;
-	switch (value) {
-		case "idle": return { status: "idle" };
-		case "loading": return { status: "loading" };
-		case "runningModule": {
-			const childSnapshot = snapshot.children.currentModule?.getSnapshot();
-			return {
-				status: "ready",
-				flow: context.flow ?? {},
-				steps: context.steps,
-				currentStepIndex: context.currentStepIndex,
-				currentStep: context.currentStep,
-				config: context.config,
-				moduleState: childSnapshot ?? null
-			};
+	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;
 		}
-		case "finished": return {
-			status: "finished",
-			flow: context.flow ?? {},
-			finishStatus: context.finishStatus ?? {
-				redirectionUrl: "",
-				action: "none",
-				scoreStatus: "UNKNOWN"
+		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"));
 			}
-		};
-		case "error": return {
-			status: "error",
-			error: context.error ?? "Unknown error"
-		};
-		default: return { status: "idle" };
-	}
+		});
+	});
 }
-function createApi({ actor, getSnapshot }) {
+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(moduleKey) {
+	function getModuleConfig$1(moduleKey) {
 		const snapshot = getSnapshot();
 		if (snapshot.value !== "runningModule") return;
 		return (snapshot.context.flow?.flowModules.find((m) => m.key === moduleKey))?.configuration;
@@ -585,14 +741,20 @@ function createApi({ actor, getSnapshot }) {
 			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",
@@ -605,24 +767,59 @@ function createApi({ actor, getSnapshot }) {
 		get canNext() {
 			return getCanNext();
 		},
-		getModuleConfig,
-		isModuleEnabled
+		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,
-		getFinishStatus: options.getFinishStatus
+		lazyModules: options.lazyModules,
+		getFinishStatus: options.getFinishStatus,
+		enableHome: options.enableHome
 	} }).start();
 }
 function createOrchestratedFlowManager(options) {
-	return createManager({
-		actor: createOrchestratedFlowActor(options),
-		mapState,
-		createApi
-	});
+	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, getRequiredWasmPipelines };
+export { createFlowManager, createModuleLoader, createOrchestratedFlowManager, getFlow, getRequiredWasmPipelines, noOpFlowModuleMachine, normalizeFlowModules };