Build journeys. Not workarounds.

// navcore://orders/123
let order = OrdersRoutes.detailRoute(
    orderId: "123"
)

func parse(_ url: URL) -> NavigationPlan? {
    NavigationPlan(actions: [
        .selectTab("orders"),
        .replaceTabStack(
            tabId: "orders",
            routes: [order]
        )
    ])
}

navigator.apply(protectedOrderPlan)

// The configured auth route is presented.
// After successful authentication:
navigator.logInAndContinue()

// The original plan now resumes.

func restorationPolicy(
    for route: RouteDescriptor
) -> RouteRestorationPolicy {
    let isCheckout =
        route.routeId == OrdersRoutes.checkout

    guard isCheckout else {
        return .restore
    }

    let orderId =
        route.string("orderId") ?? "unknown"

    let detail = OrdersRoutes.detailRoute(
        orderId: orderId
    )
    return .replaceWith(detail)
}

let path = store.bindingForTabStack("orders")
let root = store.rootRoute(for: "orders")

NavigationStack(path: path) {
    destination(for: root)
        .navigationDestination(
            for: RouteDescriptor.self
        ) {
            destination(for: $0)
        }
}

let order = OrdersRoutes.detailRoute(
    orderId: "123"
)

let plan = NavigationPlan(actions: [
    .selectTab("orders"),
    .push(order)
])

await MainActor.run {
    navigator.apply(plan)
}

XCTAssertEqual(
    store.state.selectedTabId,
    "orders"
)

let registry = RouteRegistry()

registry.register(HomeRouteProvider())
registry.register(OrdersRouteProvider())

// Register the next migrated feature.
registry.register(SettingsRouteProvider())

struct OrdersRouteProvider:
    FeatureRouteProvider {
    let featureId = "orders"

    func canHandle(routeId: String) -> Bool {
        [
            OrdersRoutes.list,
            OrdersRoutes.detail,
            OrdersRoutes.checkout
        ].contains(routeId)
    }
}

let orderId =
    route.string("orderId") ?? "unknown"

let forbidden = OrdersRoutes.forbiddenRoute(
    orderId: orderId,
    reason: "Another account owns this order."
)

navigator.failCurrentRoute(with: forbidden)

let checkout = OrdersRoutes
    .attributedCheckoutRoute(
    orderId: "CAB-481",
    attribution: [
        "source": .string(
            "customersAlsoBought"
        ),
        "campaign": .string("summer_bundle")
    ]
    )

navigator.push(checkout)

let presentation: PresentationKind =
    variant == "d" ? .fullScreen : .sheet

let offer = RouteDescriptor(
    routeId: "offers.detail",
    featureId: "offers",
    metadata: ["experiment.offer": variant]
)

navigator.apply(NavigationPlan(actions: [
    .present(
        kind: presentation,
        rootRoute: offer,
        stack: []
    )
]))

let tabs = user.needsFocusedNavigation
    ? [home, orders, account, help]
    : [home, search, orders, account, settings]

let configuration = NavigationConfiguration(
    defaultSelectedTabId: tabs[0].tabId,
    defaultTabs: tabs,
    authenticationRoute: RouteDescriptor(
        routeId: AuthRoutes.login,
        featureId: AuthRoutes.featureId
    )
)

navigator.apply(NavigationPlan(
    actions: [
        .selectTab("catalog"),
        .replaceTabStack(
            tabId: "catalog",
            routes: [category, product]
        )
    ],
    layoutHint: .preferThreeColumnSplit
))