@incodetech/core 0.0.0-dev-20260909-14ef44cf → 0.0.0-dev-20260911-3c28f170

package/dist/flow.d.ts

@@ -16,6 +16,192 @@ import { t as RedirectToMobileConfig } from "./types-DPIDuhut.js";
 import { a as TotalScore, c as getTotalScoreStatus, n as FinishStatus, o as classifyScoreStatus, r as GetFinishStatusFn, t as FinishScreenVariant } from "./flowCompletionService-BlAHsKyv.js";
 import { o as FlowEventSubscribable } from "./index-1PoJuUJ-.js";
 import { n as ModuleRegistry } from "./types-BfgmV7s7.js";
+//#region src/modules/flow/orchestratedFlowStateMachine.d.ts
+type GetFlowFn = (signal: AbortSignal) => Promise<Flow>;
+type LazyModuleRegistry = {
+  [key: string]: (() => Promise<AnyStateMachine | {
+    default: AnyStateMachine;
+  }>) | undefined;
+};
+type OrchestratedFlowInput = {
+  getFlow: GetFlowFn;
+  modules?: ModuleRegistry;
+  lazyModules?: LazyModuleRegistry;
+  getFinishStatus?: GetFinishStatusFn;
+  enableHome?: boolean;
+  /**
+   * The flow was fetched with `getFlow(..., { deferActivation: true })`: the
+   * machine completes activation itself (feature-management flow id, then
+   * MANDATORY_CONSENT from the device fingerprint) right before the first
+   * module runs — on the Start tap when there is a home screen — so neither
+   * the flow fetch nor the home screen waits for feature-config, Statsig or
+   * the fingerprint.
+   */
+  deferActivation?: boolean;
+};
+type OrchestratedFlowEvent = {
+  type: 'LOAD';
+} | {
+  type: 'CANCEL';
+} | {
+  type: 'RESET';
+} | {
+  type: 'MODULE_COMPLETE';
+  output?: unknown;
+} | {
+  type: 'COMPLETE_FLOW';
+} | {
+  type: 'FINISH_FLOW';
+} | {
+  type: 'HOME_CONTINUE';
+} | {
+  type: '*';
+  [key: string]: unknown;
+} | {
+  type: string;
+  [key: string]: unknown;
+};
+//#endregion
+//#region src/modules/flow/orchestratedFlowManager.d.ts
+type OrchestratedFlowHomeScreen = {
+  visible: boolean;
+  isContinueLoading: boolean;
+};
+type OrchestratedFlowPresentation = {
+  isAwaitingReady: boolean;
+  lazyModuleKey: string | undefined;
+  shouldPrefetchHome: boolean;
+};
+type OrchestratedFlowIdleState = {
+  status: 'idle';
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowLoadingState = {
+  status: 'loading';
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowCompletingState = {
+  status: 'completing';
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowReadyState = {
+  status: 'ready';
+  flow: Flow;
+  steps: string[];
+  currentStepIndex: number;
+  currentStep: string | undefined;
+  config: unknown;
+  moduleState: unknown;
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowFinishedState = {
+  status: 'finished';
+  flow: Flow;
+  finishStatus: {
+    redirectionUrl: string;
+    action: 'approved' | 'rejected' | 'none';
+    scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
+    endScreenTitle: string | null;
+    endScreenText: string | null;
+  };
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowErrorState = {
+  status: 'error';
+  error?: string;
+  errorCode?: number;
+  moduleErrorCode?: string;
+  homeScreen: OrchestratedFlowHomeScreen;
+  presentation: OrchestratedFlowPresentation;
+};
+type OrchestratedFlowState = OrchestratedFlowIdleState | OrchestratedFlowLoadingState | OrchestratedFlowCompletingState | OrchestratedFlowReadyState | OrchestratedFlowFinishedState | OrchestratedFlowErrorState;
+type CreateOrchestratedFlowActorOptions = {
+  getFlow?: GetFlowFn;
+  modules?: ModuleRegistry;
+  lazyModules?: LazyModuleRegistry;
+  getFinishStatus?: OrchestratedFlowInput['getFinishStatus'];
+  enableHome?: boolean;
+  deferActivation?: OrchestratedFlowInput['deferActivation'];
+};
+declare function createOrchestratedFlowManager(options: CreateOrchestratedFlowActorOptions): Manager<OrchestratedFlowState> & {
+  /**
+   * Start loading the flow configuration from the backend.
+   */
+  load(): void;
+  /**
+   * Cancel an in-progress flow load.
+   */
+  cancel(): void;
+  /**
+   * Reset the flow to its initial idle state.
+   */
+  reset(): void;
+  /**
+   * Signal that the current module has completed successfully.
+   * Call this from your UI component's `onFinish` callback.
+   *
+   * @example
+   * ```tsx
+   * <Phone
+   *   config={config}
+   *   onFinish={() => flowManager.completeModule()}
+   * />
+   * ```
+   */
+  completeModule(output?: unknown): void;
+  /**
+   * Skip all remaining modules and complete the flow now, notifying the
+   * backend (getFinishStatus) on the way to the completion step.
+   */
+  completeFlow(): void;
+  /**
+   * Finish the flow because the onboarding was already completed externally —
+   * e.g. the REDIRECT_TO_MOBILE handoff finished end-to-end on mobile. Lands
+   * on the completion screen WITHOUT calling getFinishStatus: mobile already
+   * notified the backend, and the desktop never reached its own finish.
+   * Use this (not `completeFlow`) from REDIRECT_TO_MOBILE's `onFinish`.
+   */
+  finishFlow(): void;
+  /**
+   * Signal that the current module encountered a terminal error, optionally
+   * with its machine-readable `moduleErrorCode`. The flow machine decides what
+   * to do: an advanceable terminal error (e.g. `NONEXISTENT_CUSTOMER`,
+   * `HINT_NOT_PROVIDED`) advances to the next step; any other error transitions
+   * to the terminal error state. Callers always forward the code and let core
+   * classify — no per-module branching in the UI.
+   *
+   * @param error - Error message describing what went wrong. Omit it to let
+   *   the UI fall back to its own generic error copy (e.g. TerminalErrorPage's
+   *   `common.unexpectedError`) instead of surfacing a raw/technical string.
+   * @param moduleErrorCode - Optional machine-readable error code (a
+   *   `FaceErrorCode`) used by the flow machine to decide advance vs terminate
+   */
+  errorModule(error?: string, moduleErrorCode?: string): void;
+  /**
+   * Send a raw event to the flow state machine.
+   * Prefer using the typed methods (completeModule, errorModule) when possible.
+   */
+  send(event: OrchestratedFlowEvent): void;
+  readonly canNext: boolean;
+  getModuleConfig: <T = unknown>(moduleKey: string) => T | undefined;
+  isModuleEnabled: (moduleKey: string) => boolean;
+  isAwaitingOrchestratorReady(): boolean;
+  /**
+   * Resolve once the orchestrator has finished loading the flow and the first
+   * module is ready to render. Useful for gating an initialization spinner
+   * alongside other parallel async work (e.g. theme fetching).
+   */
+  waitForReady(): Promise<void>;
+  getLazyModuleKey(): string | undefined;
+  shouldRenderHomeScreen(): boolean;
+  continueFromHome(): Promise<void>;
+} & FlowEventSubscribable;
+//#endregion
 //#region src/modules/flow/flowUtils.d.ts
 type NormalizeFlowModulesOptions = {
   isDesktop?: boolean;
@@ -45,6 +231,12 @@ declare function enrichFlowModuleConfig(module: FlowModule, flow: Flow): Record<
  * ```
  */
 declare function getRequiredWasmPipelines(flow: Flow): WasmPipeline[];
+/**
+ * The current capture requirement, then one capture ahead once it is ready.
+ * Home never looks past its first capture, and redirects stop lookahead.
+ * @internal Used by the shared flow shell after rendering.
+ */
+declare function getNextRequiredWasmPipelines(state: Pick<OrchestratedFlowReadyState, 'flow' | 'currentStepIndex' | 'homeScreen'>, loadedPipelines?: readonly WasmPipeline[]): WasmPipeline[];
 /**
  * Normalizes flow modules by expanding TUTORIAL_ID into ID + SECOND_ID
  * based on configuration flags. Matches legacy flowService behavior.
@@ -68,6 +260,15 @@ type GetFlowOptions = {
   authHint?: string;
   lang?: string;
   useCPF?: boolean;
+  /**
+   * Return the flow as soon as it is fetched and normalized, without waiting
+   * for session activation: the Statsig `flow_id` update and the
+   * mandatory-consent injection (which rides on the device fingerprint) are
+   * left to `completeDeferredActivation`, which the caller must run before the
+   * first module starts — the orchestrated flow machine does this on the Start
+   * tap when there is a home screen, right after loading otherwise.
+   */
+  deferActivation?: boolean;
 };
 type GetFlow = (signal: AbortSignal, options?: GetFlowOptions) => Promise<Flow>;
 type DashboardResolvedModuleConfigMap = {
@@ -245,180 +446,4 @@ interface ModuleLoader {
 }
 declare function createModuleLoader(registry: ModuleLoaderRegistry): ModuleLoader;
 //#endregion
-//#region src/modules/flow/orchestratedFlowStateMachine.d.ts
-type GetFlowFn = (signal: AbortSignal) => Promise<Flow>;
-type LazyModuleRegistry = {
-  [key: string]: (() => Promise<AnyStateMachine | {
-    default: AnyStateMachine;
-  }>) | undefined;
-};
-type OrchestratedFlowInput = {
-  getFlow: GetFlowFn;
-  modules?: ModuleRegistry;
-  lazyModules?: LazyModuleRegistry;
-  getFinishStatus?: GetFinishStatusFn;
-  enableHome?: boolean;
-};
-type OrchestratedFlowEvent = {
-  type: 'LOAD';
-} | {
-  type: 'CANCEL';
-} | {
-  type: 'RESET';
-} | {
-  type: 'MODULE_COMPLETE';
-  output?: unknown;
-} | {
-  type: 'COMPLETE_FLOW';
-} | {
-  type: 'FINISH_FLOW';
-} | {
-  type: 'HOME_CONTINUE';
-} | {
-  type: '*';
-  [key: string]: unknown;
-} | {
-  type: string;
-  [key: string]: unknown;
-};
-//#endregion
-//#region src/modules/flow/orchestratedFlowManager.d.ts
-type OrchestratedFlowHomeScreen = {
-  visible: boolean;
-  isContinueLoading: boolean;
-};
-type OrchestratedFlowPresentation = {
-  isAwaitingReady: boolean;
-  lazyModuleKey: string | undefined;
-  shouldPrefetchHome: boolean;
-};
-type OrchestratedFlowIdleState = {
-  status: 'idle';
-  homeScreen: OrchestratedFlowHomeScreen;
-  presentation: OrchestratedFlowPresentation;
-};
-type OrchestratedFlowLoadingState = {
-  status: 'loading';
-  homeScreen: OrchestratedFlowHomeScreen;
-  presentation: OrchestratedFlowPresentation;
-};
-type OrchestratedFlowCompletingState = {
-  status: 'completing';
-  homeScreen: OrchestratedFlowHomeScreen;
-  presentation: OrchestratedFlowPresentation;
-};
-type OrchestratedFlowReadyState = {
-  status: 'ready';
-  flow: Flow;
-  steps: string[];
-  currentStepIndex: number;
-  currentStep: string | undefined;
-  config: unknown;
-  moduleState: unknown;
-  homeScreen: OrchestratedFlowHomeScreen;
-  presentation: OrchestratedFlowPresentation;
-};
-type OrchestratedFlowFinishedState = {
-  status: 'finished';
-  flow: Flow;
-  finishStatus: {
-    redirectionUrl: string;
-    action: 'approved' | 'rejected' | 'none';
-    scoreStatus: 'OK' | 'WARN' | 'MANUAL_OK' | 'FAIL' | 'UNKNOWN' | 'MANUAL_FAIL';
-    endScreenTitle: string | null;
-    endScreenText: string | null;
-  };
-  homeScreen: OrchestratedFlowHomeScreen;
-  presentation: OrchestratedFlowPresentation;
-};
-type OrchestratedFlowErrorState = {
-  status: 'error';
-  error?: string;
-  errorCode?: number;
-  moduleErrorCode?: string;
-  homeScreen: OrchestratedFlowHomeScreen;
-  presentation: OrchestratedFlowPresentation;
-};
-type OrchestratedFlowState = OrchestratedFlowIdleState | OrchestratedFlowLoadingState | OrchestratedFlowCompletingState | OrchestratedFlowReadyState | OrchestratedFlowFinishedState | OrchestratedFlowErrorState;
-type CreateOrchestratedFlowActorOptions = {
-  getFlow?: GetFlowFn;
-  modules?: ModuleRegistry;
-  lazyModules?: LazyModuleRegistry;
-  getFinishStatus?: OrchestratedFlowInput['getFinishStatus'];
-  enableHome?: boolean;
-};
-declare function createOrchestratedFlowManager(options: CreateOrchestratedFlowActorOptions): Manager<OrchestratedFlowState> & {
-  /**
-   * Start loading the flow configuration from the backend.
-   */
-  load(): void;
-  /**
-   * Cancel an in-progress flow load.
-   */
-  cancel(): void;
-  /**
-   * Reset the flow to its initial idle state.
-   */
-  reset(): void;
-  /**
-   * Signal that the current module has completed successfully.
-   * Call this from your UI component's `onFinish` callback.
-   *
-   * @example
-   * ```tsx
-   * <Phone
-   *   config={config}
-   *   onFinish={() => flowManager.completeModule()}
-   * />
-   * ```
-   */
-  completeModule(output?: unknown): void;
-  /**
-   * Skip all remaining modules and complete the flow now, notifying the
-   * backend (getFinishStatus) on the way to the completion step.
-   */
-  completeFlow(): void;
-  /**
-   * Finish the flow because the onboarding was already completed externally —
-   * e.g. the REDIRECT_TO_MOBILE handoff finished end-to-end on mobile. Lands
-   * on the completion screen WITHOUT calling getFinishStatus: mobile already
-   * notified the backend, and the desktop never reached its own finish.
-   * Use this (not `completeFlow`) from REDIRECT_TO_MOBILE's `onFinish`.
-   */
-  finishFlow(): void;
-  /**
-   * Signal that the current module encountered a terminal error, optionally
-   * with its machine-readable `moduleErrorCode`. The flow machine decides what
-   * to do: an advanceable terminal error (e.g. `NONEXISTENT_CUSTOMER`,
-   * `HINT_NOT_PROVIDED`) advances to the next step; any other error transitions
-   * to the terminal error state. Callers always forward the code and let core
-   * classify — no per-module branching in the UI.
-   *
-   * @param error - Error message describing what went wrong. Omit it to let
-   *   the UI fall back to its own generic error copy (e.g. TerminalErrorPage's
-   *   `common.unexpectedError`) instead of surfacing a raw/technical string.
-   * @param moduleErrorCode - Optional machine-readable error code (a
-   *   `FaceErrorCode`) used by the flow machine to decide advance vs terminate
-   */
-  errorModule(error?: string, moduleErrorCode?: string): void;
-  /**
-   * Send a raw event to the flow state machine.
-   * Prefer using the typed methods (completeModule, errorModule) when possible.
-   */
-  send(event: OrchestratedFlowEvent): void;
-  readonly canNext: boolean;
-  getModuleConfig: <T = unknown>(moduleKey: string) => T | undefined;
-  isModuleEnabled: (moduleKey: string) => boolean;
-  isAwaitingOrchestratorReady(): boolean;
-  /**
-   * Resolve once the orchestrator has finished loading the flow and the first
-   * module is ready to render. Useful for gating an initialization spinner
-   * alongside other parallel async work (e.g. theme fetching).
-   */
-  waitForReady(): Promise<void>;
-  getLazyModuleKey(): string | undefined;
-  shouldRenderHomeScreen(): boolean;
-  continueFromHome(): Promise<void>;
-} & FlowEventSubscribable;
-//#endregion
-export { type DeepPartial, type FinishScreenVariant, type FinishStatus, type Flow, type FlowModule, type FlowModuleConfig, type FlowReadyState, type FlowState, type LazyModule, type LazyModuleRegistry, type ModuleLoader, type ModuleLoaderRegistry, type ModuleRegistry, type OrchestratedFlowCompletingState, type OrchestratedFlowFinishedState, type OrchestratedFlowHomeScreen, type OrchestratedFlowInput, type OrchestratedFlowPresentation, type OrchestratedFlowReadyState, type OrchestratedFlowState, type ResolveDashboardModuleConfigOptions, type ResolvedDashboardModuleConfig, type TotalScore, classifyScoreStatus, createFlowManager, createModuleLoader, createOrchestratedFlowManager, enrichFlowModuleConfig, getFlow, getRequiredWasmPipelines, getTotalScoreStatus, mergeDashboardConfig, noOpFlowModuleMachine, normalizeFlowModules, preloadDashboardFlow, resolveDashboardModuleConfig };
+export { type DeepPartial, type FinishScreenVariant, type FinishStatus, type Flow, type FlowModule, type FlowModuleConfig, type FlowReadyState, type FlowState, type LazyModule, type LazyModuleRegistry, type ModuleLoader, type ModuleLoaderRegistry, type ModuleRegistry, type OrchestratedFlowCompletingState, type OrchestratedFlowFinishedState, type OrchestratedFlowHomeScreen, type OrchestratedFlowInput, type OrchestratedFlowPresentation, type OrchestratedFlowReadyState, type OrchestratedFlowState, type ResolveDashboardModuleConfigOptions, type ResolvedDashboardModuleConfig, type TotalScore, classifyScoreStatus, createFlowManager, createModuleLoader, createOrchestratedFlowManager, enrichFlowModuleConfig, getFlow, getNextRequiredWasmPipelines, getRequiredWasmPipelines, getTotalScoreStatus, mergeDashboardConfig, noOpFlowModuleMachine, normalizeFlowModules, preloadDashboardFlow, resolveDashboardModuleConfig };

package/dist/flow.esm.js

@@ -1,9 +1,9 @@
 import { v as addEvent } from "./events-ijlbX_Wx.esm.js";
-import { a as enrichFlowModuleConfig, c as resolveFlowModuleConfig, i as resolveDashboardModuleConfig, k as mergeDashboardConfig, n as preloadDashboardFlow, o as getRequiredWasmPipelines, s as normalizeFlowModules, t as getFlow } from "./flowServices-C2pUbFWe.esm.js";
+import { a as resolveDashboardModuleConfig, c as getRequiredWasmPipelines, j as mergeDashboardConfig, l as normalizeFlowModules, n as getFlow, o as enrichFlowModuleConfig, r as preloadDashboardFlow, s as getNextRequiredWasmPipelines, t as completeDeferredActivation, u as resolveFlowModuleConfig } from "./flowServices-CzgZ-VRv.esm.js";
 import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { n as getFinishStatus, r as getTotalScoreStatus, t as classifyScoreStatus } from "./flowCompletionService-1HFgv9BU.esm.js";
-import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-Bq791c2t.esm.js";
+import { n as getFinishStatus, r as getTotalScoreStatus, t as classifyScoreStatus } from "./flowCompletionService-cuWgokHI.esm.js";
+import { n as attachFlowEventEmitter, t as runChildModule } from "./runChildModule-6P8ofHxL.esm.js";
 import { n as isAdvanceableError } from "./advanceableErrors-CpF2cBy6.esm.js";
 //#region src/modules/flow/noOpFlowModuleMachine.ts
 const noOpFlowModuleMachine = setup({}).createMachine({
@@ -363,6 +363,8 @@ function createBaseContext(context, isHomeContinueLoading) {
 		enableHome: context.enableHome,
 		finishStatus: void 0,
 		isHomeContinueLoading,
+		deferActivation: context.deferActivation,
+		activationResolved: false,
 		skipFaceMatch: false
 	};
 }
@@ -372,13 +374,21 @@ function createInitialContext(input) {
 		registeredModules: input.modules ?? {},
 		lazyRegisteredModules: input.lazyModules ?? {},
 		getFinishStatus: input.getFinishStatus ?? getFinishStatus,
-		enableHome: input.enableHome === true
+		enableHome: input.enableHome === true,
+		deferActivation: input.deferActivation === true
 	}, false);
 }
+/**
+* Whether this flow shows a home screen at all. Shared by `shouldEnterHome`
+* (step-position aware) and the `activatesBeforeFirstModule` guard (which runs
+* before `setFlowData`, so it reads the freshly fetched flow instead of
+* `context.flow`) — keep the home-screen conditions in this one place.
+*/
+function homeScreenEnabled(context, flow) {
+	return context.enableHome === true && flow?.disableLaunchScreen !== true && context.isHomeContinueLoading !== true;
+}
 function shouldEnterHome(context) {
-	if (context.enableHome !== true) return false;
-	if (context.flow?.disableLaunchScreen === true) return false;
-	if (context.isHomeContinueLoading === true) return false;
+	if (!homeScreenEnabled(context, context.flow)) return false;
 	const firstRealIndex = context.steps[0] === "REDIRECT_TO_MOBILE" ? 1 : 0;
 	return context.currentStepIndex === firstRealIndex;
 }
@@ -408,6 +418,10 @@ const orchestratedFlowMachine = setup({
 			return await input.getFinishStatus(input.flowId, signal);
 		}),
 		runChildModule,
+		resolveActivation: fromPromise(async ({ input, signal }) => {
+			if (!input.flow) throw new Error("No flow loaded");
+			return completeDeferredActivation(input.flow, signal);
+		}),
 		resolveCurrentModuleMachine: fromPromise(async ({ input }) => {
 			if (!input.moduleKey) return;
 			const eagerMachine = input.modules[input.moduleKey];
@@ -438,6 +452,25 @@ const orchestratedFlowMachine = setup({
 				currentModuleMachine: void 0
 			};
 		}),
+		setActivatedFlow: assign(({ context, event }) => {
+			const flow = event.output;
+			const flowModules = flow.flowModules ?? [];
+			const steps = flowModules.map((m) => m.key);
+			let insertedAt = steps.findIndex((key, i) => key !== context.steps[i]);
+			if (insertedAt === -1) insertedAt = steps.length;
+			const currentStepIndex = steps.length === context.steps.length ? context.currentStepIndex : Math.min(context.currentStepIndex, insertedAt);
+			const module = flowModules[currentStepIndex];
+			return {
+				flow,
+				steps,
+				currentStepIndex,
+				currentStep: module?.key,
+				config: getModuleConfig(module, flow),
+				currentModuleMachine: void 0,
+				activationResolved: true
+			};
+		}),
+		markActivationResolved: assign({ activationResolved: true }),
 		setError: assign(({ event }) => {
 			const err = event.error;
 			return {
@@ -492,6 +525,16 @@ const orchestratedFlowMachine = setup({
 		canGoNext: ({ context }) => context.currentStepIndex >= 0 && context.currentStepIndex < context.steps.length - 1,
 		isOnboardingFinishedSignal: ({ event }) => event.output?.action === "onboardingFinished",
 		shouldEnterHome: ({ context }) => shouldEnterHome(context),
+		needsActivation: ({ context }) => context.deferActivation && !context.activationResolved && context.currentStep !== "REDIRECT_TO_MOBILE",
+		activatesBeforeFirstModule: ({ context, event }) => {
+			if (!("output" in event)) return false;
+			if (!context.deferActivation || context.activationResolved) return false;
+			const flow = event.output;
+			const firstModuleKey = flow.flowModules?.[0]?.key;
+			if (!firstModuleKey || firstModuleKey === "REDIRECT_TO_MOBILE") return false;
+			if (!(context.registeredModules[firstModuleKey] != null || context.lazyRegisteredModules[firstModuleKey] != null)) return false;
+			return !homeScreenEnabled(context, flow);
+		},
 		hasModule: ({ context, event }) => {
 			if (!("output" in event)) return false;
 			const firstModuleKey = event.output.flowModules?.[0]?.key;
@@ -520,17 +563,25 @@ const orchestratedFlowMachine = setup({
 				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";
-					} })
-				}],
+				onDone: [
+					{
+						target: "resolvingActivation",
+						guard: "activatesBeforeFirstModule",
+						actions: "setFlowData"
+					},
+					{
+						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"
@@ -559,6 +610,11 @@ const orchestratedFlowMachine = setup({
 						guard: "shouldEnterHome",
 						actions: ["setCurrentModuleMachine"]
 					},
+					{
+						target: "resolvingActivation",
+						guard: "needsActivation",
+						actions: ["setCurrentModuleMachine"]
+					},
 					{
 						target: "runningModule",
 						guard: "hasCurrentModuleMachine",
@@ -583,15 +639,41 @@ const orchestratedFlowMachine = setup({
 			}
 		},
 		home: { on: {
-			HOME_CONTINUE: {
+			HOME_CONTINUE: [{
+				target: "resolvingActivation",
+				guard: "needsActivation",
+				actions: "setHomeContinueLoading"
+			}, {
 				target: "runningModule",
 				actions: ["clearHomeContinueLoading", "prefetchNextModule"]
-			},
+			}],
 			RESET: {
 				target: "idle",
 				actions: "resetContext"
 			}
 		} },
+		resolvingActivation: {
+			invoke: {
+				id: "resolveActivation",
+				src: "resolveActivation",
+				input: ({ context }) => ({ flow: context.flow }),
+				onDone: {
+					target: "resolvingModule",
+					actions: "setActivatedFlow"
+				},
+				onError: {
+					target: "resolvingModule",
+					actions: "markActivationResolved"
+				}
+			},
+			on: {
+				RESET: {
+					target: "idle",
+					actions: "resetContext"
+				},
+				...homeContinueOn
+			}
+		},
 		runningModule: {
 			entry: "clearHomeContinueLoading",
 			invoke: {
@@ -705,7 +787,7 @@ function deriveUiModel(snapshot, mappedStatus, isHomePhase, options) {
 	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 isResolvingHomeAnchor = (snapshot.value === "resolvingModule" || snapshot.value === "resolvingActivation") && effectiveEnableHome && isAtFirstRealModule;
 	const isHomeBoundPhase = isHomePhase || isResolvingHomeAnchor;
 	const canShowHome = isTerminal === false && effectiveEnableHome && isCompletingPhase === false;
 	const visible = canShowHome ? isHomeBoundPhase : false;
@@ -727,7 +809,7 @@ function getMappedStatus(snapshot) {
 	const { value } = snapshot;
 	if (value === "idle") return "idle";
 	if (value === "completing") return "completing";
-	if (value === "loading" || value === "resolvingModule" || typeof value === "object") return "loading";
+	if (value === "loading" || value === "resolvingModule" || value === "resolvingActivation" || typeof value === "object") return "loading";
 	if (value === "finished") return "finished";
 	if (value === "error") return "error";
 	return "ready";
@@ -969,7 +1051,8 @@ function createOrchestratedFlowActor(options) {
 		modules: options.modules,
 		lazyModules: options.lazyModules,
 		getFinishStatus: options.getFinishStatus,
-		enableHome: options.enableHome
+		enableHome: options.enableHome,
+		deferActivation: options.deferActivation
 	} }).start();
 }
 function createOrchestratedFlowManager(options) {
@@ -983,4 +1066,4 @@ function createOrchestratedFlowManager(options) {
 	}));
 }
 //#endregion
-export { classifyScoreStatus, createFlowManager, createModuleLoader, createOrchestratedFlowManager, enrichFlowModuleConfig, getFlow, getRequiredWasmPipelines, getTotalScoreStatus, mergeDashboardConfig, noOpFlowModuleMachine, normalizeFlowModules, preloadDashboardFlow, resolveDashboardModuleConfig };
+export { classifyScoreStatus, createFlowManager, createModuleLoader, createOrchestratedFlowManager, enrichFlowModuleConfig, getFlow, getNextRequiredWasmPipelines, getRequiredWasmPipelines, getTotalScoreStatus, mergeDashboardConfig, noOpFlowModuleMachine, normalizeFlowModules, preloadDashboardFlow, resolveDashboardModuleConfig };

package/dist/{flowCompletionService-1HFgv9BU.esm.js → flowCompletionService-cuWgokHI.esm.js}

@@ -1,6 +1,6 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
 import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
-import { i as toIncodeApiError } from "./apiError-CE5YD5T0.esm.js";
+import { i as toIncodeApiError } from "./apiError-CY6lWIaQ.esm.js";
 //#region src/modules/flow/flowCompletionService.ts
 const getFinishStatus = async (flowId, signal) => {
 	const url = `${endpoints.finishStatus}${flowId ? `?flowId=${flowId}` : ""}`;