diff --git a/packages/example/src/FlowNavigatorExample.tsx b/packages/example/src/FlowNavigatorExample.tsx
index 06ae21e..4350f78 100644
--- a/packages/example/src/FlowNavigatorExample.tsx
+++ b/packages/example/src/FlowNavigatorExample.tsx
@@ -4,11 +4,12 @@ import {useQuery} from '@tanstack/react-query';
 import {getHasToPassStep4} from './queries/hasToPassStep4';
 import {ActivityIndicator, StyleSheet, View} from 'react-native';
 import {Step1Page} from './steps/Step1/Step1Page';
-import {Step2Navigator} from './steps/Step2/Step2Navigator';
 import {Step31Page} from './steps/Step3/Step3-1Page';
 import {Step32Page} from './steps/Step3/Step3-2Page';
 import {Step4Page} from './steps/Step4/Step4Page';
 import {Step5Page} from './steps/Step5/Step4Page';
+import {atom, useAtom} from 'jotai';
+import {Step22Page} from './steps/Step2/Step2-2Page';
 
 export type FlowStackParamList = {
   Step1: undefined;
@@ -21,7 +22,11 @@ export type FlowStackParamList = {
 
 const FlowNavigator = createFlowNavigator<FlowStackParamList>();
 
+export const show = atom(false);
+
 export const FlowNavigatorExample = () => {
+  const [isShow, _] = useAtom(show);
+
   const {data: hasToPassStep4, isLoading: isStep4Loading} = useQuery(
     ['hasToPassStep4'],
     getHasToPassStep4,
@@ -35,22 +40,17 @@ export const FlowNavigatorExample = () => {
     );
   }
 
-  const initialDisabledRoutes = [
-    'Step31',
-    ...(hasToPassStep4 ? [] : ['Step4']),
-  ];
-
   return (
-    <FlowNavigator.Navigator
-      screenOptions={{headerShown: false}}
-      initialDisabledRoutes={initialDisabledRoutes}>
+    <FlowNavigator.Navigator screenOptions={{headerShown: false}}>
       <FlowNavigator.Screen name="Step1" component={Step1Page} />
-      <FlowNavigator.Screen name="Step2" component={Step2Navigator} />
+      {isShow && <FlowNavigator.Screen name="Step2" component={Step22Page} />}
       <FlowNavigator.Group>
         <FlowNavigator.Screen name="Step31" component={Step31Page} />
         <FlowNavigator.Screen name="Step32" component={Step32Page} />
       </FlowNavigator.Group>
-      <FlowNavigator.Screen name="Step4" component={Step4Page} />
+      {hasToPassStep4 && (
+        <FlowNavigator.Screen name="Step4" component={Step4Page} />
+      )}
       <FlowNavigator.Screen name="Step5" component={Step5Page} />
     </FlowNavigator.Navigator>
   );
diff --git a/packages/example/src/steps/Step1/Step1Page.tsx b/packages/example/src/steps/Step1/Step1Page.tsx
index 464282b..c7868a3 100644
--- a/packages/example/src/steps/Step1/Step1Page.tsx
+++ b/packages/example/src/steps/Step1/Step1Page.tsx
@@ -3,17 +3,26 @@ import React from 'react';
 import {Button, StyleSheet, Text, View} from 'react-native';
 import {FlowInfos} from '../FlowInfos';
 import {ParamListBase, useNavigation} from '@react-navigation/native';
+import {useAtom} from 'jotai';
+import {show} from '../../FlowNavigatorExample';
 
 export const Step1Page = () => {
   const {goToNextStep, quitFlow} =
     useNavigation<FlowNavigationProp<ParamListBase>>();
+  const [_, setIsShow] = useAtom(show);
 
   return (
     <View style={styles.container}>
       <Text style={styles.pageTitle}>Current page: 1</Text>
       <FlowInfos />
       <Button title="quit flow" onPress={quitFlow} />
-      <Button title="next" onPress={() => goToNextStep()} />
+      <Button
+        title="next"
+        onPress={() => {
+          setIsShow(true);
+          goToNextStep();
+        }}
+      />
     </View>
   );
 };
diff --git a/packages/example/src/steps/Step2/Step2-2Page.tsx b/packages/example/src/steps/Step2/Step2-2Page.tsx
index 9e66352..94b9081 100644
--- a/packages/example/src/steps/Step2/Step2-2Page.tsx
+++ b/packages/example/src/steps/Step2/Step2-2Page.tsx
@@ -6,16 +6,15 @@ import {FlowInfos} from '../FlowInfos';
 import {FlowStackParamList} from '../../FlowNavigatorExample';
 
 export const Step22Page = () => {
-  const {goBack, goToNextStep, enableRoute} =
+  const {goToPreviousStep, goToNextStep, navigate} =
     useNavigation<FlowNavigationProp<FlowStackParamList>>();
 
   const onNextPress = async () => {
-    enableRoute('Step31');
     goToNextStep();
   };
 
   const onBackPress = () => {
-    goBack();
+    goToPreviousStep();
   };
 
   return (
@@ -24,6 +23,7 @@ export const Step22Page = () => {
       <FlowInfos />
       <Button title="next" onPress={onNextPress} />
       <Button title="back" onPress={onBackPress} />
+      <Button title="go to home" onPress={() => navigate('Home')} />
     </View>
   );
 };
diff --git a/packages/example/src/steps/Step3/Step3-2Page.tsx b/packages/example/src/steps/Step3/Step3-2Page.tsx
index ee31c7b..58102c8 100644
--- a/packages/example/src/steps/Step3/Step3-2Page.tsx
+++ b/packages/example/src/steps/Step3/Step3-2Page.tsx
@@ -5,12 +5,11 @@ import {FlowInfos} from '../FlowInfos';
 import {ParamListBase, useNavigation} from '@react-navigation/native';
 
 export const Step32Page = () => {
-  const {goToPreviousStep, goToNextStep, disableRoute} =
+  const {goToPreviousStep, goToNextStep} =
     useNavigation<FlowNavigationProp<ParamListBase>>();
 
   const onNextPress = () => {
     goToNextStep();
-    disableRoute('Step32');
   };
 
   return (
diff --git a/packages/example/src/steps/Step4/Step4Page.tsx b/packages/example/src/steps/Step4/Step4Page.tsx
index c1c1324..30df17f 100644
--- a/packages/example/src/steps/Step4/Step4Page.tsx
+++ b/packages/example/src/steps/Step4/Step4Page.tsx
@@ -7,7 +7,7 @@ import {useQueryClient, useMutation} from '@tanstack/react-query';
 import {postPassedStep4} from '../../queries/hasToPassStep4';
 
 export const Step4Page = () => {
-  const {goToPreviousStep, goToNextStep, disableRoute} =
+  const {goToPreviousStep, goToNextStep} =
     useNavigation<FlowNavigationProp<ParamListBase>>();
 
   const queryClient = useQueryClient();
@@ -18,7 +18,6 @@ export const Step4Page = () => {
       onSuccess: () => {
         queryClient.invalidateQueries(['hasToPassStep4']);
         goToNextStep();
-        disableRoute('Step4');
       },
     },
   );
diff --git a/packages/lib/src/navigators/createFlowNavigator.tsx b/packages/lib/src/navigators/createFlowNavigator.tsx
index 2f3daa2..61f5028 100644
--- a/packages/lib/src/navigators/createFlowNavigator.tsx
+++ b/packages/lib/src/navigators/createFlowNavigator.tsx
@@ -1,11 +1,15 @@
 import * as React from "react";
 import {
   createNavigatorFactory,
+  NavigationContext,
   ParamListBase,
   useNavigation,
   useNavigationBuilder,
 } from "@react-navigation/native";
-import { NativeStackNavigationEventMap, NativeStackView } from "@react-navigation/native-stack";
+import {
+  NativeStackNavigationEventMap,
+  NativeStackView,
+} from "@react-navigation/native-stack";
 import {
   FlowActionHelpers,
   FlowRouterOptions,
@@ -19,6 +23,8 @@ import {
   FlowStackNavigationOptions,
 } from "../types/types";
 import { FlowContext } from "./FlowContext";
+import { StaticContainer } from "./fork/descriptorRender";
+import { getRouteConfigsFromChildren } from "./fork/getRouteNames";
 
 function FlowNavigator({
   id,
@@ -26,7 +32,6 @@ function FlowNavigator({
   children,
   screenListeners,
   screenOptions,
-  initialDisabledRoutes,
   ...rest
 }: FlowNavigatorProps) {
   const parentNavigation = useNavigation();
@@ -42,7 +47,7 @@ function FlowNavigator({
       FlowActionHelpers<ParamListBase>,
       FlowNavigationOptions,
       FlowNavigationEventMap
-    >(buildFlowRouter(quitFlow, initialDisabledRoutes), {
+    >(buildFlowRouter(quitFlow), {
       id,
       initialRouteName,
       children,
@@ -50,34 +55,85 @@ function FlowNavigator({
       screenOptions,
     });
 
-  /**
-   * In each page, we add the flow context (Just like for useRoute, we have to create one context per route so that each page statically has their values. If we simply added a context above all the screens and deduced the flow values from useNavigation, the values would change before the navigation animation is completed.)
-   * We see two other ways this could be done without needing to mutate an object like that:
-   * - Add the context inside NativeStackView, just like NavigationRouteContext, but we didn't want to duplicate too much of the code of the stack navigator.
-   * - Calculate flow values from useNavigation and useRoute (state from useNavigation, current route index from useRoute). The code would be very straitfoward, but the progress indicator would be incorrect for subnavigators. Supporting subnavigators would lead to a code that didn't seem much better than those next few lines to us.
-   */
-  Object.entries(descriptors).forEach(([_, descriptor], index) => {
-    const render = descriptor.render;
+  const routeConfigs = getRouteConfigsFromChildren<
+    State,
+    ScreenOptions,
+    EventMap
+  >(children);
+
+  // routeNames are calculated twice
+  const screens = routeConfigs.reduce<
+    Record<string, ScreenConfigWithParent<State, ScreenOptions, EventMap>>
+  >((acc, config) => {
+    if (config.props.name in acc) {
+      throw new Error(
+        `A navigator cannot contain multiple 'Screen' components with the same name (found duplicate screen named '${config.props.name}')`
+      );
+    }
+
+    acc[config.props.name] = config;
+    return acc;
+  }, {});
+
+  const routes = state.routeNames
+    .slice(0, state.flowIndex + 1)
+    .map((route) => ({
+      key: `route${route}`,
+      name: route,
+    }));
+
+  // descriptors is calculated twice
+  const newDescriptors = routes.reduce((acc, route, i) => {
+    acc[route.key] = {
+      navigation,
+      route,
+      render: () => {
+        const config = screens[route.name];
+        const screen = config.props;
+
+        const ScreenComponent = screen.getComponent
+          ? screen.getComponent()
+          : screen.component;
+
+        // TODO: Make sure other components from original render are not useful
+        return (
+          <NavigationContext.Provider value={navigation}>
+            <FlowContext.Provider
+              value={{
+                navigationState: state,
+                currentStepIndex: i,
+              }}
+            >
+              <StaticContainer
+                name={screen.name}
+                render={ScreenComponent || screen.children}
+                navigation={navigation}
+                route={route}
+              >
+                {ScreenComponent !== undefined ? (
+                  <ScreenComponent navigation={navigation} route={route} />
+                ) : screen.children !== undefined ? (
+                  screen.children({ navigation, route })
+                ) : null}
+              </StaticContainer>
+            </FlowContext.Provider>
+          </NavigationContext.Provider>
+        );
+      },
+      options: {},
+    };
+    return acc;
+  }, {});
 
-    descriptor.render = () => (
-      <FlowContext.Provider
-        value={{
-          navigationState: state,
-          currentStepIndex: index,
-        }}
-      >
-        {render()}
-      </FlowContext.Provider>
-    );
-  });
+  const newState = { ...state, routes };
 
   return (
     <NavigationContent>
       <NativeStackView
         {...rest}
-        state={state}
+        state={newState}
         navigation={navigation}
-        descriptors={descriptors}
+        descriptors={newDescriptors}
       />
     </NavigationContent>
   );
diff --git a/packages/lib/src/navigators/fork/descriptorRender.ts b/packages/lib/src/navigators/fork/descriptorRender.ts
new file mode 100644
index 0000000..c0dcde3
--- /dev/null
+++ b/packages/lib/src/navigators/fork/descriptorRender.ts
@@ -0,0 +1,3 @@
+export function StaticContainer(props: any) {
+  return props.children;
+}
diff --git a/packages/lib/src/navigators/fork/getRouteNames.ts b/packages/lib/src/navigators/fork/getRouteNames.ts
new file mode 100644
index 0000000..1276b8f
--- /dev/null
+++ b/packages/lib/src/navigators/fork/getRouteNames.ts
@@ -0,0 +1,184 @@
+import { NavigationState, EventMapBase, RouteConfig, ParamListBase, RouteGroupConfig } from "@react-navigation/native";
+import { createNativeStackNavigator } from "@react-navigation/native-stack";
+import React from "react"
+import { isValidElementType } from 'react-is';
+// TODO: add react-is as dependency
+
+export const getRouteConfigsFromChildren = <
+  State extends NavigationState,
+  ScreenOptions extends {},
+  EventMap extends EventMapBase
+>(
+  children: React.ReactNode,
+  groupKey?: string,
+  groupOptions?: ScreenConfigWithParent<
+    State,
+    ScreenOptions,
+    EventMap
+  >["options"]
+) => {
+  const configs = React.Children.toArray(children).reduce<
+    ScreenConfigWithParent<State, ScreenOptions, EventMap>[]
+  >((acc, child) => {
+    if (React.isValidElement(child)) {
+      if (child.type === NativeStack.Screen) {
+        // We can only extract the config from `Screen` elements
+        // If something else was rendered, it's probably a bug
+
+        if (!isValidKey(child.props.navigationKey)) {
+          throw new Error(
+            `Got an invalid 'navigationKey' prop (${JSON.stringify(
+              child.props.navigationKey
+            )}) for the screen '${
+              child.props.name
+            }'. It must be a non-empty string or 'undefined'.`
+          );
+        }
+
+        acc.push({
+          keys: [groupKey, child.props.navigationKey],
+          options: groupOptions,
+          props: child.props as RouteConfig<
+            ParamListBase,
+            string,
+            State,
+            ScreenOptions,
+            EventMap
+          >,
+        });
+        return acc;
+      }
+
+      if (child.type === React.Fragment || child.type === NativeStack.Group) {
+        if (!isValidKey(child.props.navigationKey)) {
+          throw new Error(
+            `Got an invalid 'navigationKey' prop (${JSON.stringify(
+              child.props.navigationKey
+            )}) for the group. It must be a non-empty string or 'undefined'.`
+          );
+        }
+
+        // When we encounter a fragment or group, we need to dive into its children to extract the configs
+        // This is handy to conditionally define a group of screens
+        acc.push(
+          ...getRouteConfigsFromChildren<State, ScreenOptions, EventMap>(
+            child.props.children,
+            child.props.navigationKey,
+            child.type !== NativeStack.Group
+              ? groupOptions
+              : groupOptions != null
+              ? [...groupOptions, child.props.screenOptions]
+              : [child.props.screenOptions]
+          )
+        );
+        return acc;
+      }
+    }
+
+    throw new Error(
+      `A navigator can only contain 'Screen', 'Group' or 'React.Fragment' as its direct children (found ${
+        React.isValidElement(child)
+          ? `'${
+              typeof child.type === "string" ? child.type : child.type?.name
+            }'${
+              child.props != null &&
+              typeof child.props === "object" &&
+              "name" in child.props &&
+              child.props?.name
+                ? ` for the screen '${child.props.name}'`
+                : ""
+            }`
+          : typeof child === "object"
+          ? JSON.stringify(child)
+          : `'${String(child)}'`
+      }). To render this component in the navigator, pass it in the 'component' prop to 'Screen'.`
+    );
+  }, []);
+
+  if (process.env.NODE_ENV !== "production") {
+    configs.forEach((config) => {
+      const { name, children, component, getComponent } = config.props;
+
+      if (typeof name !== "string" || !name) {
+        throw new Error(
+          `Got an invalid name (${JSON.stringify(
+            name
+          )}) for the screen. It must be a non-empty string.`
+        );
+      }
+
+      if (
+        children != null ||
+        component !== undefined ||
+        getComponent !== undefined
+      ) {
+        if (children != null && component !== undefined) {
+          throw new Error(
+            `Got both 'component' and 'children' props for the screen '${name}'. You must pass only one of them.`
+          );
+        }
+
+        if (children != null && getComponent !== undefined) {
+          throw new Error(
+            `Got both 'getComponent' and 'children' props for the screen '${name}'. You must pass only one of them.`
+          );
+        }
+
+        if (component !== undefined && getComponent !== undefined) {
+          throw new Error(
+            `Got both 'component' and 'getComponent' props for the screen '${name}'. You must pass only one of them.`
+          );
+        }
+
+        if (children != null && typeof children !== "function") {
+          throw new Error(
+            `Got an invalid value for 'children' prop for the screen '${name}'. It must be a function returning a React Element.`
+          );
+        }
+
+        if (component !== undefined && !isValidElementType(component)) {
+          throw new Error(
+            `Got an invalid value for 'component' prop for the screen '${name}'. It must be a valid React Component.`
+          );
+        }
+
+        if (getComponent !== undefined && typeof getComponent !== "function") {
+          throw new Error(
+            `Got an invalid value for 'getComponent' prop for the screen '${name}'. It must be a function returning a React Component.`
+          );
+        }
+
+        if (typeof component === "function") {
+          if (component.name === "component") {
+            // Inline anonymous functions passed in the `component` prop will have the name of the prop
+            // It's relatively safe to assume that it's not a component since it should also have PascalCase name
+            // We won't catch all scenarios here, but this should catch a good chunk of incorrect use.
+            console.warn(
+              `Looks like you're passing an inline function for 'component' prop for the screen '${name}' (e.g. component={() => <SomeComponent />}). Passing an inline function will cause the component state to be lost on re-render and cause perf issues since it's re-created every render. You can pass the function as children to 'Screen' instead to achieve the desired behaviour.`
+            );
+          } else if (/^[a-z]/.test(component.name)) {
+            console.warn(
+              `Got a component with the name '${component.name}' for the screen '${name}'. React Components must start with an uppercase letter. If you're passing a regular function and not a component, pass it as children to 'Screen' instead. Otherwise capitalize your component's name.`
+            );
+          }
+        }
+      } else {
+        throw new Error(
+          `Couldn't find a 'component', 'getComponent' or 'children' prop for the screen '${name}'. This can happen if you passed 'undefined'. You likely forgot to export your component from the file it's defined in, or mixed up default import and named import when importing.`
+        );
+      }
+    });
+  }
+
+  return configs;
+};
+
+/**
+ * This code is copied from react-navigation, because we need to access it but is not exported
+ * The only thing changed is we compare Screen and Group via a native stack instance
+ */
+const NativeStack = createNativeStackNavigator();
+
+export const isValidKey = (key: unknown) =>
+  key === undefined || (typeof key === "string" && key !== "");
+
diff --git a/packages/lib/src/navigators/useFlow.ts b/packages/lib/src/navigators/useFlow.ts
index 792fba4..0d9550b 100644
--- a/packages/lib/src/navigators/useFlow.ts
+++ b/packages/lib/src/navigators/useFlow.ts
@@ -5,9 +5,9 @@ export const useFlowStatus = () => {
   const { navigationState, currentStepIndex } = useContext(FlowContext);
 
   return {
-    currentStep: navigationState.availableRoutes[currentStepIndex],
-    progress: currentStepIndex / navigationState.availableRoutes.length,
+    currentStep: navigationState.routeNames[currentStepIndex],
+    progress: currentStepIndex / navigationState.routeNames.length,
     canGoToPreviousStep: currentStepIndex !== 0,
-    canGoToNextStep: currentStepIndex !== navigationState.availableRoutes.length - 1,
+    canGoToNextStep: currentStepIndex !== navigationState.routeNames.length - 1,
   };
 };
diff --git a/packages/lib/src/routers/FlowRouter.ts b/packages/lib/src/routers/FlowRouter.ts
index 3c1b07c..fad4625 100644
--- a/packages/lib/src/routers/FlowRouter.ts
+++ b/packages/lib/src/routers/FlowRouter.ts
@@ -15,8 +15,6 @@ export type FlowActionHelpers<ParamList extends ParamListBase> = {
   goToNextStep(): void;
   goToPreviousStep(): void;
   quitFlow(): void;
-  enableRoute(routeName: Extract<keyof ParamList, string>): void;
-  disableRoute(routeName: Extract<keyof ParamList, string>): void;
 } & StackActionHelpers<ParamList>;
 
 export type FlowActionType =
@@ -33,20 +31,9 @@ export type FlowActionType =
       type: "QUIT_FLOW";
       source?: string;
     }
-  | {
-      type: "ENABLE_ROUTE";
-      source?: string;
-      payload: { routeName: Extract<keyof ParamListBase, string> };
-    }
-  | {
-      type: "DISABLE_ROUTE";
-      source?: string;
-      payload: { routeName: Extract<keyof ParamListBase, string> };
-    };
-
 
 export const buildFlowRouter =
-  (quitFlowHelper: () => void, initialDisabledRoutes: string[]) =>
+  (quitFlowHelper: () => void) =>
   (
     options: FlowRouterOptions
   ): Router<
@@ -62,53 +49,27 @@ export const buildFlowRouter =
       ...router,
 
       getInitialState(params) {
-        const { routeNames } = params;
-        const availableRoutes = routeNames.filter(
-          (routeName) =>
-            !initialDisabledRoutes.find((disabledRoute) => disabledRoute === routeName)
-        );
-
         return {
           ...router.getInitialState(params),
-          availableRoutes,
+          flowIndex: 0,
         };
       },
 
       getStateForAction(state, action, options) {
         switch (action.type) {
           case "NEXT_STEP":
-            const nextStepRouteName = state.availableRoutes[state.index + 1];
-
-            if (!nextStepRouteName) {
-              return null;
-            }
-
-            return router.getStateForAction(
-              state,
-              {
-                type: "NAVIGATE",
-                source: action.source,
-                payload: { name: nextStepRouteName },
-              },
-              options
-            );
+            // TODO: handle case can't go next
+            return {
+              ...state,
+              flowIndex: state.flowIndex + 1, // changing index didn't work, didn't search why
+            };
 
           case "BACK_STEP":
-            const previousRouteName = state.availableRoutes[state.index - 1];
-
-            if (!previousRouteName) {
-              return null;
-            }
-
-            return router.getStateForAction(
-              state,
-              {
-                type: "NAVIGATE",
-                source: action.source,
-                payload: { name: previousRouteName },
-              },
-              options
-            );
+            // TODO: handle case can't go previous
+            return {
+              ...state,
+              flowIndex: state.flowIndex - 1,
+            };
 
           case "QUIT_FLOW":
             /**
@@ -119,47 +80,33 @@ export const buildFlowRouter =
             quitFlowHelper();
 
             return state;
+          default:
+            return router.getStateForAction(state, action, options);
+        }
+      },
 
-          case "ENABLE_ROUTE":
-            const notOrdonnedAvailableRoutes = [
-              ...state.availableRoutes,
-              action.payload.routeName,
-            ];
-
-            const newAvailableRoutes = state.routeNames.filter((routeName: string) =>
-              notOrdonnedAvailableRoutes.find(
-                (newAvailableRoute) => routeName === newAvailableRoute
-              )
-            );
-
-            return {
-              ...state,
-              availableRoutes: newAvailableRoutes,
-            };
-
-          case "DISABLE_ROUTE":
-            // TODO: maybe use getStateForRouteNamesChange
-            const currentRouteName = state.routes[state.routes.length - 1];
+      getStateForRouteNamesChange(
+        state,
+        { routeNames }
+      ) {
+        // TODO: handle edge cases, like if there are no routes left
+        const builtRoutes = state.routeNames.slice(0, state.flowIndex)
 
-            const filteredRoutes = state.routes.filter(
-              (route) => route.name !== action.payload.routeName
-            );
+        const removedRoutes = state.routeNames.filter(routeName => !routeNames.includes(routeName) && builtRoutes.includes(routeName))
 
-            return {
-              ...state,
-              availableRoutes: state.availableRoutes.filter(
-                (routeName: string) => routeName !== action.payload.routeName
-              ),
-              routes: filteredRoutes,
-              index: filteredRoutes.findIndex(
-                (routeName) => routeName === currentRouteName
-              ),
-            };
-
-          default:
-            return router.getStateForAction(state, action, options);
+        let newFlowIndex = state.flowIndex;
+        
+        if(removedRoutes.length >0){
+          newFlowIndex = newFlowIndex - 1
         }
+
+        return {
+          ...state,
+          routeNames,
+          flowIndex: newFlowIndex,
+        };
       },
+      
       actionCreators: {
         ...router.actionCreators,
         goToNextStep: () => {
@@ -171,12 +118,6 @@ export const buildFlowRouter =
         quitFlow: () => {
           return { type: "QUIT_FLOW" };
         },
-        enableRoute: (routeName) => {
-          return { type: "ENABLE_ROUTE", payload: {routeName} };
-        },
-        disableRoute: (routeName) => {
-          return { type: "DISABLE_ROUTE", payload: {routeName} };
-        },
       },
     };
   };