struct Onboarding {
    enum Screen {
        case login
        case register
    }

    struct State: Equatable {
        var modalNavigation = ModalNavigation<Screen>.State()
        ...
    }

    enum Action: Equatable {
        case modalNavigation(ModalNavigation.Action)
        ...
    }

    private static let privateReducer = Reducer<State, Action, Environment> { state, action, environment in
        switch action {
        case .loginButtonPressed:
            return Effect(value: .modalNavigation(.presentFullScreen(.login)))
        case .anotherAction:
            return Effect(value: .modalNavigation(.dismiss))
        }
        return .none
    }

    static let reducer: Reducer = Reducer.combine([
        ModalNavigation<Screen>.reducer()
            .pullback(
                state: \.modalNavigation,
                action: /Action.modalNavigation,
                environment: { _ in () }
            ),
        privateReducer
    ])
}

struct Register {
    enum Screen {
        case email
        case firstName
        case lastName
    }

    struct State: Equatable {
        var stackNavigation = StackNavigation<Screen>.State(items: [.email])
        ...
    }

    enum Action: Equatable {
        case stackNavigation(StackNavigation.Action)
        ...
    }

    private static let privateReducer = Reducer<State, Action, Environment> { state, action, environment in
        switch action {
        case .emailEntered:
            return Effect(value: .stackNavigation(.pushItem(.firstName)))
        case .firstNameEntered:
            return Effect(value: .stackNavigation(.pushItem(.lastName)))
        ...
        }
        return .none
    }

    static let reducer: Reducer = Reducer.combine([
        StackNavigation<Screen>.reducer()
            .pullback(
                state: \.stackNavigation,
                action: /Action.stackNavigation,
                environment: { _ in () }
            ),
        privateReducer
    ])
}

struct Root {
    enum Screen: CaseIterable {
        case home
        case list
        case settings
    }

    struct State: Equatable {
        var tabNavigation = TabNavigation<Screen>.State(
            items: Screen.allCases,
            activeItem: .home
        )
        ...
    }

    enum Action: Equatable {
        case tabNavigation(TabNavigation.Action)
        ...
    }

    private static let privateReducer = Reducer<State, Action, Environment> { state, action, environment in
        switch action {
        case .goToSettings:
            return Effect(value: .tabNavigation(.setActiveItem(.settings)))
        ...
        }
        return .none
    }

    static let reducer: Reducer = Reducer.combine([
        TabNavigation<Screen>.reducer()
            .pullback(
                state: \.tabNavigation,
                action: /Action.tabNavigation,
                environment: { _ in () }
            ),
        privateReducer
    ])
}

struct ViewProvider: ViewProviding {
    let store: Store
    
    func makePresentable(for navigationItem: Screen) -> Presentable {
        switch navigationItem {
        case .a:
            return ViewA(store: store.scope( ... ))
        case .b:
            return ViewB(store: store.scope( ... ))
        }
    }
}

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
	var window: UIWindow?

    lazy var store: Store = ...

	func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
		guard let windowScene = scene as? UIWindowScene else {
			return
		}
		
		let controller = TabNavigationController(
			store: store.scope(
				state: \.tabNavigation,
				action: App.Action.tabNavigation
			),
			viewProvider: App.ViewProvider(store: store)
		)

		let window = UIWindow(windowScene: windowScene)
		window.rootViewController = controller
		self.window = window
		window.makeKeyAndVisible()
	}

    ...
}

...
// 👉 Choose showcase 👈
let showcase: Showcase = .advanced
...