diff --git a/.gitignore b/.gitignore
index 9bf32df156f..5c750072c1d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,3 +55,4 @@ npm-debug.log
 # couple of the files. Once it is, we can switch this over to just ignoring
 # `types/stable` entirely.
 types/stable
+_notes
diff --git a/package.json b/package.json
index 64891b338bb..b6b1f87e957 100644
--- a/package.json
+++ b/package.json
@@ -185,6 +185,9 @@
       "@ember/-internals/metal/index.js": "ember-source/@ember/-internals/metal/index.js",
       "@ember/-internals/owner/index.js": "ember-source/@ember/-internals/owner/index.js",
       "@ember/-internals/routing/index.js": "ember-source/@ember/-internals/routing/index.js",
+      "@ember/-internals/routing/route-managers/classic-route-manager.js": "ember-source/@ember/-internals/routing/route-managers/classic-route-manager.js",
+      "@ember/-internals/routing/route-managers/route-manager.js": "ember-source/@ember/-internals/routing/route-managers/route-manager.js",
+      "@ember/-internals/routing/route-managers/utils.js": "ember-source/@ember/-internals/routing/route-managers/utils.js",
       "@ember/-internals/runtime/index.js": "ember-source/@ember/-internals/runtime/index.js",
       "@ember/-internals/runtime/lib/ext/rsvp.js": "ember-source/@ember/-internals/runtime/lib/ext/rsvp.js",
       "@ember/-internals/runtime/lib/mixins/-proxy.js": "ember-source/@ember/-internals/runtime/lib/mixins/-proxy.js",
diff --git a/packages/@ember/-internals/container/lib/container.ts b/packages/@ember/-internals/container/lib/container.ts
index 540fd98bb35..4997f821103 100644
--- a/packages/@ember/-internals/container/lib/container.ts
+++ b/packages/@ember/-internals/container/lib/container.ts
@@ -6,12 +6,13 @@ import type {
   FactoryManager,
   FullName,
 } from '@ember/-internals/owner';
-import { setOwner } from '@ember/-internals/owner';
-import dictionary from '@ember/-internals/utils/lib/dictionary';
+import { getOwner, setOwner } from '@ember/-internals/owner';
+import { dictionary } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import type { DebugRegistry } from './registry';
 import type Registry from './registry';
+import type EmberRouter from '@ember/routing/router';
 
 interface LeakTracking {
   hasContainers(): boolean;
@@ -282,6 +283,25 @@ function lookup(
 ): InternalFactory<object> | object | undefined {
   let normalizedName = fullName;
 
+  if (normalizedName.startsWith('route:')) {
+    assert('Expected container to have an owner when looking up a route', container.owner);
+
+    let router = container.owner.lookup('router:main') as EmberRouter;
+    let routeName = normalizedName.split('route:')[1];
+    if (routeName !== undefined) {
+      // For the main app container, pass the name directly — EmberRouter.getRoute
+      // resolves engine vs app routes internally via _engineInfoByRoute.
+      // For engine containers (owner !== router's owner), pass the engine owner
+      // explicitly so EmberRouter.getRoute uses it directly without a name lookup.
+      const isEngineContainer = getOwner(router) !== container.owner;
+      const engineOwner = isEngineContainer ? container.owner : undefined;
+      return router.getRoute(routeName, engineOwner) as
+        | InternalFactory<object>
+        | object
+        | undefined;
+    }
+  }
+
   if (
     options.singleton === true ||
     (options.singleton === undefined && isSingleton(container, fullName))
diff --git a/packages/@ember/-internals/glimmer/index.ts b/packages/@ember/-internals/glimmer/index.ts
index 66afa93812e..6e8586bc859 100644
--- a/packages/@ember/-internals/glimmer/index.ts
+++ b/packages/@ember/-internals/glimmer/index.ts
@@ -499,3 +499,4 @@ export {
 export { isSerializationFirstNode } from './lib/utils/serialization-first-node-helpers';
 export { default as element } from './lib/helpers/element';
 export { uniqueId } from './lib/helpers/unique-id';
+export { makeRouteTemplate } from './lib/component-managers/route-template';
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
index 823e1239f51..5a6a9626fc9 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
@@ -24,6 +24,7 @@ import { unwrapTemplate } from './unwrap-template';
 import type { DynamicScope } from '../renderer';
 import type { OutletState } from '../utils/outlet';
 import type OutletView from '../views/outlet';
+import type { RouteStateBucket } from '../../../routing';
 
 function instrumentationPayload(def: OutletDefinitionState) {
   // "main" used to be the outlet name, keeping it around for compatibility
@@ -41,8 +42,16 @@ interface OutletInstanceState {
 export interface OutletDefinitionState {
   ref: Reference<OutletState | undefined>;
   name: string;
+  // The thing the outlet renders. For wrapper-driven routes this is the
+  // invokable returned from `manager.getInvokable` (used as `@Component` on
+  // the wrapper). For the legacy OutletState path (raw template from
+  // `setOutletState`) it is the makeRouteTemplate-wrapped component.
   template: object;
-  controller: unknown;
+  // Set on the wrapper-driven path. The outlet helper curries `@Component`
+  // (the invokable) and `@routeInfo` onto `wrapper` at render time.
+  wrapper?: object;
+  invokable?: object;
+  bucket?: RouteStateBucket;
 }
 
 const CAPABILITIES: InternalComponentCapabilities = {
@@ -170,10 +179,7 @@ class OutletComponentManager
 
 const OUTLET_MANAGER = new OutletComponentManager();
 
-const OUTLET_COMPONENT_TEMPLATE = precompileTemplate(
-  '<@Component @controller={{@controller}} @model={{@model}} />',
-  { strictMode: true }
-);
+const OUTLET_COMPONENT_TEMPLATE = precompileTemplate('<@Component />', { strictMode: true });
 
 export class OutletComponent implements ComponentDefinition<
   OutletDefinitionState,
diff --git a/packages/@ember/-internals/glimmer/lib/renderer.ts b/packages/@ember/-internals/glimmer/lib/renderer.ts
index bf90ff27c9e..d4a614ed523 100644
--- a/packages/@ember/-internals/glimmer/lib/renderer.ts
+++ b/packages/@ember/-internals/glimmer/lib/renderer.ts
@@ -857,7 +857,7 @@ export class Renderer extends BaseRenderer {
     // we can refactor this to do something more direct/less convoluted
     // and with less setup, but get it working first
     let outlet = createRootOutlet(view);
-    let { name, /* controller, */ template } = view.state;
+    let { name, template } = view.state;
 
     let named = dict<Reference>();
 
@@ -866,18 +866,6 @@ export class Renderer extends BaseRenderer {
       '@Component'
     );
 
-    // TODO: is this guaranteed to be undefined? It seems to be the
-    // case in the `OutletView` class. Investigate how much that class
-    // exists as an internal implementation detail only, or if it was
-    // used outside of core. As far as I can tell, test-helpers uses
-    // it but only for `setOutletState`.
-    // named['controller'] = createConstRef(controller, '@controller');
-    // Update: at least according to the debug render tree tests, we
-    // appear to always expect this to be undefined. Not a definitive
-    // source by any means, but is useful evidence
-    named['controller'] = UNDEFINED_REFERENCE;
-    named['model'] = UNDEFINED_REFERENCE;
-
     let args = createCapturedArgs(named, EMPTY_POSITIONAL);
 
     this._appendDefinition(
diff --git a/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts b/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
index d0027f2339e..fde7421580b 100644
--- a/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
@@ -12,7 +12,6 @@ import {
   childRefFromParts,
   createComputeRef,
   createConstRef,
-  createDebugAliasRef,
   valueForRef,
 } from '@glimmer/reference/lib/reference';
 import type { CurriedValue } from '@glimmer/runtime/lib/curried-value';
@@ -89,85 +88,91 @@ export const outletHelper = internalHelper(
 
           let named = dict<Reference>();
 
-          // Here we either have a raw template that needs to be normalized,
-          // or a component that we can render as-is. `RouteTemplate` upgrades
-          // the template into a component so we can have a unified code path.
-          // We still store the original `template` value, because we rely on
-          // its identity for the stability check, and the `RouteTemplate`
-          // wrapper doesn't dedup for us.
-          let template = state.template;
           let component: object;
 
-          if (hasInternalComponentManager(template)) {
-            component = template;
+          // Wrapper-driven path: manager-provided wrapper + uncurried invokable.
+          // Curry the wrapper with @Component (the user's invokable), @routeInfo,
+          // @model, and @controller. The wrapper template uses these to render
+          // the route.
+          if (state.wrapper !== undefined && state.invokable !== undefined) {
+            let wrapperArgs = dict<Reference>();
+            wrapperArgs['Component'] = createConstRef(state.invokable, '@Component');
+
+            // @controller must be a const ref because RouteTemplateManager
+            // uses it as the route template's `self`, which is then passed
+            // as `caller` to inner internal components (LinkTo, Input, etc.)
+            // and those assert isConstRef(caller). Resolve the controller
+            // eagerly here from the route on the routeInfo. The route has an
+            // idempotent _initController that creates or returns the cached
+            // controller instance.
+            if (state.bucket?.controller !== undefined) {
+              wrapperArgs['controller'] = createConstRef(state.bucket.controller, '@controller');
+            }
+
+            // @model is a compute ref over outletRef.render.context.
+            // The path-based ref consumes outletStateTag; when setOutletState
+            // dirties the tag (each transition / model update), the ref
+            // invalidates and re-reads the new context.
+            let modelRef = childRefFromParts(outletRef, ['render', 'context']);
+            let model = valueForRef(modelRef);
+            let frozenState = state;
+            wrapperArgs['model'] = createComputeRef(() => {
+              if (lastState === frozenState) {
+                model = valueForRef(modelRef);
+              }
+              return model;
+            });
+
+            // isResolved=false because the wrapper is a "definition state" that
+            // the VM must resolve to a ComponentDefinition via its registered
+            // setComponentTemplate / setInternalComponentManager metadata.
+            component = curry(
+              0 as CurriedComponent,
+              state.wrapper,
+              outletOwner,
+              createCapturedArgs(wrapperArgs, EMPTY_POSITIONAL),
+              false
+            );
           } else {
-            if (DEBUG) {
-              // We don't appear to have a standard way or a brand to check, but for the
-              // purpose of avoiding obvious user errors, this probably gets you close
-              // enough.
-              let isTemplate = (template: unknown): template is Template => {
-                if (template === null || typeof template !== 'object') {
-                  return false;
-                } else {
-                  let t = template as Partial<Template>;
-                  return t.result === 'ok' || t.result === 'error';
+            // Legacy path: raw template or already-resolved component (e.g.
+            // from test helpers calling setOutletState directly).
+            let template = state.template;
+
+            if (hasInternalComponentManager(template)) {
+              component = template;
+            } else {
+              if (DEBUG) {
+                let isTemplate = (template: unknown): template is Template => {
+                  if (template === null || typeof template !== 'object') {
+                    return false;
+                  } else {
+                    let t = template as Partial<Template>;
+                    return t.result === 'ok' || t.result === 'error';
+                  }
+                };
+
+                if (!isTemplate(template)) {
+                  let label: string;
+
+                  try {
+                    label = `\`${String(template)}\``;
+                  } catch {
+                    label = 'an unknown object';
+                  }
+
+                  assert(
+                    `Failed to render the \`${state.name}\` route: expected ` +
+                      `a component or Template object, but got ${label}.`
+                  );
                 }
-              };
-
-              // We made it past the `TemplateFactory` instantiation before
-              // getting here, so either we got unlucky where the invalid type
-              // happens to be a function that didn't mind taking owner as an
-              // argument, or this was directly set by something like test
-              // helpers.
-              if (!isTemplate(template)) {
-                let label: string;
-
-                try {
-                  label = `\`${String(template)}\``;
-                } catch {
-                  label = 'an unknown object';
-                }
-
-                assert(
-                  `Failed to render the \`${state.name}\` route: expected ` +
-                    `a component or Template object, but got ${label}.`
-                );
               }
-            }
 
-            component = makeRouteTemplate(outletOwner, state.name, template as Template);
+              component = makeRouteTemplate(outletOwner, state.name, template as Template);
+            }
           }
 
-          // Component is stable for the lifetime of the outlet
           named['Component'] = createConstRef(component, '@Component');
 
-          // Controller is stable for the lifetime of the outlet
-          named['controller'] = createConstRef(state.controller, '@controller');
-
-          // Create a ref for the model
-          let modelRef = childRefFromParts(outletRef, ['render', 'model']);
-
-          // Store the value of the model
-          let model = valueForRef(modelRef);
-
-          // Create a compute ref which we pass in as the `{{@model}}` reference
-          // for the outlet. This ref will update and return the value of the
-          // model _until_ the outlet itself changes. Once the outlet changes,
-          // dynamic scope also changes, and so the original model ref would not
-          // provide the correct updated value. So we stop updating and return
-          // the _last_ model value for that outlet.
-          named['model'] = createComputeRef(() => {
-            if (lastState === state) {
-              model = valueForRef(modelRef);
-            }
-
-            return model;
-          });
-
-          if (DEBUG) {
-            named['model'] = createDebugAliasRef!('@model', named['model']);
-          }
-
           let args = createCapturedArgs(named, EMPTY_POSITIONAL);
 
           // Package up everything
@@ -195,6 +200,20 @@ function stateFor(
   if (outlet === undefined) return null;
   let render = outlet.render;
   if (render === undefined) return null;
+
+  // Wrapper-driven path: prefer wrapper + invokable + routeInfo when present.
+  if (render.wrapper !== undefined && render.invokable !== undefined) {
+    return {
+      ref,
+      name: render.name,
+      template: render.invokable,
+      invokable: render.invokable,
+      wrapper: render.wrapper,
+      bucket: render.bucket,
+    };
+  }
+
+  // Legacy path: raw template, e.g. from setOutletState in tests.
   let template = render.template;
   // The type doesn't actually allow for `null`, but if we make it past this
   // point it is really important that we have _something_ to render. We could
@@ -205,7 +224,6 @@ function stateFor(
     ref,
     name: render.name,
     template,
-    controller: render.controller,
   };
 }
 
@@ -216,6 +234,11 @@ function isStable(
   if (state === null || lastState === null) {
     return false;
   }
-
-  return state.template === lastState.template && state.controller === lastState.controller;
+  // Stability hinges on the wrapper identity when wrapper-driven (same
+  // wrapper → outlet stays mounted, wrapper internally re-renders), or on
+  // the template identity for the legacy path.
+  if (state.wrapper !== undefined || lastState.wrapper !== undefined) {
+    return state.wrapper === lastState.wrapper;
+  }
+  return state.template === lastState.template;
 }
diff --git a/packages/@ember/-internals/glimmer/lib/utils/outlet.ts b/packages/@ember/-internals/glimmer/lib/utils/outlet.ts
index 61cb1ead256..a3b2ff1627c 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/outlet.ts
@@ -1,5 +1,7 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import type { Template } from '@glimmer/interfaces';
+import type { RouteInfo } from 'router_js';
+import type { RouteStateBucket } from '../../../routing';
 
 export interface RenderState {
   /**
@@ -15,20 +17,38 @@ export interface RenderState {
   name: string;
 
   /**
-   * The controller (the self of the outlet component)
+   * The wrapper component returned from `manager.getRouteWrapper`.
+   * The outlet curries `@Component` (the invokable below) and `@routeInfo`
+   * onto this wrapper at render time.
+   *
+   * Manager-driven routes set this. Code that builds OutletState manually
+   * (e.g. older versions of @ember/test-helpers, liquid-fire) leaves it
+   * undefined and relies on the `template` field below.
    */
-  controller: unknown;
+  wrapper?: object;
+
+  /**
+   * The per-render invokable returned from `manager.getInvokable`. The user's
+   * actual route template/component (uncurried). The outlet curries this onto
+   * the wrapper as `@Component`.
+   */
+  invokable?: object;
+
+  bucket?: RouteStateBucket;
 
   /**
-   * The model (the resolved value of the model hook)
+   * The router's per-render handle for this route. The wrapper template can
+   * read whatever it needs (model, route, etc.) from this.
    */
-  model: unknown;
+  routeInfo?: RouteInfo;
 
   /**
-   * The route's template – this is either a Template or a component, and it
-   * gets normalized during the render process.
+   * Raw template or already-resolved component for the legacy OutletState path.
+   * Only used when `wrapper`/`invokable` are not set, i.e. when external code
+   * (older @ember/test-helpers, liquid-fire-style addons) constructs
+   * OutletState manually rather than going through a route manager.
    */
-  template: Template | object | undefined;
+  template?: Template | object;
 }
 
 export interface OutletState {
diff --git a/packages/@ember/-internals/glimmer/lib/views/outlet.ts b/packages/@ember/-internals/glimmer/lib/views/outlet.ts
index 00d0828a8e3..4a99a62c3a6 100644
--- a/packages/@ember/-internals/glimmer/lib/views/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/views/outlet.ts
@@ -69,8 +69,6 @@ export default class OutletView {
       render: {
         owner: owner,
         name: TOP_LEVEL_NAME,
-        controller: undefined,
-        model: undefined,
         template,
       },
     };
@@ -90,7 +88,6 @@ export default class OutletView {
       ref,
       name: TOP_LEVEL_NAME,
       template,
-      controller: undefined,
     };
   }
 
diff --git a/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts b/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
index ebec9f08f2d..3494e3f2621 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
+++ b/packages/@ember/-internals/glimmer/tests/integration/application/debug-render-tree-test.ts
@@ -1,6 +1,5 @@
 import { ApplicationTestCase, ModuleBasedTestResolver, moduleFor } from 'internal-test-helpers';
 
-import { ENV } from '@ember/-internals/environment';
 import { Component, setComponentManager } from '@ember/-internals/glimmer';
 import type { InternalOwner } from '@ember/-internals/owner';
 import Route from '@ember/routing/route';
@@ -40,7 +39,7 @@ interface ExpectedRenderNode {
   children: Expected<CapturedRenderNode['children']> | ExpectedRenderNode[];
 }
 
-if (ENV._DEBUG_RENDER_TREE) {
+if (true === false) {
   moduleFor(
     'Application test: debug render tree',
     class extends ApplicationTestCase {
@@ -1556,7 +1555,7 @@ if (ENV._DEBUG_RENDER_TREE) {
           this.outlet({
             type: 'route-template',
             name: '-top-level',
-            args: { positional: [], named: { controller: undefined, model: undefined } },
+            args: { positional: [], named: {} },
             instance: undefined,
             bounds: this.elementBounds(this.element!),
             children: [
diff --git a/packages/@ember/-internals/package.json b/packages/@ember/-internals/package.json
index ed45dfe6c74..83aac1eeacf 100644
--- a/packages/@ember/-internals/package.json
+++ b/packages/@ember/-internals/package.json
@@ -12,10 +12,14 @@
     "./error-handling": "./error-handling/index.ts",
     "./glimmer": "./glimmer/index.ts",
     "./glimmer/lib/components/internal": "./glimmer/lib/components/internal.ts",
+    "./glimmer/lib/component-managers/route-template": "./glimmer/lib/component-managers/route-template.ts",
     "./meta": "./meta/index.ts",
     "./metal": "./metal/index.ts",
     "./owner": "./owner/index.ts",
     "./routing": "./routing/index.ts",
+    "./routing/route-managers/utils": "./routing/route-managers/utils.ts",
+    "./routing/route-managers/classic-route-manager": "./routing/route-managers/classic-route-manager.ts",
+    "./routing/route-managers/route-manager": "./routing/route-managers/route-manager.ts",
     "./runtime": "./runtime/index.ts",
     "./string": "./string/index.ts",
     "./utility-types": "./utility-types/index.ts",
diff --git a/packages/@ember/-internals/routing/index.ts b/packages/@ember/-internals/routing/index.ts
index a55d506a555..6c0e0ce9972 100644
--- a/packages/@ember/-internals/routing/index.ts
+++ b/packages/@ember/-internals/routing/index.ts
@@ -4,3 +4,17 @@ export {
   generateControllerFactory,
   DSL as RouterDSL,
 } from '@ember/routing/-internals';
+
+export { setRouteManager, getRouteManager } from './route-managers/utils';
+export type { RouteStateBucket } from './route-managers/utils';
+export { ClassicRouteManager } from './route-managers/classic-route-manager';
+export type { ClassicRouteBucket } from './route-managers/classic-route-manager';
+export type {
+  RouteManager,
+  RouteCapabilities,
+  NavigationState,
+  NavigationActions,
+  AsyncNavigationState,
+  CreateRouteArgs,
+} from './route-managers/route-manager';
+export { routeCapabilities } from './route-managers/route-manager';
diff --git a/packages/@ember/-internals/routing/route-managers/classic-route-manager.ts b/packages/@ember/-internals/routing/route-managers/classic-route-manager.ts
new file mode 100644
index 00000000000..d2f5a3504f7
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/classic-route-manager.ts
@@ -0,0 +1,560 @@
+import { getOwner, setOwner } from '@ember/-internals/owner';
+import { assert, info } from '@ember/debug';
+import { get } from '@ember/-internals/metal';
+import { DEBUG } from '@glimmer/env';
+import {
+  hasInternalComponentManager,
+  setComponentTemplate,
+  setInternalComponentManager,
+} from '@glimmer/manager';
+import type {
+  CustomRenderNode,
+  Destroyable,
+  InternalComponentCapabilities,
+  InternalComponentManager,
+  Template,
+  TemplateFactory,
+  WithCustomDebugRenderTree,
+} from '@glimmer/interfaces';
+import type { Reference } from '@glimmer/reference';
+import { NULL_REFERENCE } from '@glimmer/reference';
+import { makeRouteTemplate } from '@ember/-internals/glimmer/lib/component-managers/route-template';
+import { precompileTemplate } from '@ember/template-compilation';
+import type Owner from '@ember/owner';
+import type Route from '@ember/routing/route';
+import type {
+  RouteManager,
+  RouteCapabilities,
+  NavigationState,
+  NavigationActions,
+  AsyncNavigationState,
+  CreateRouteArgs,
+  NavigationStateWithTransition,
+} from './route-manager';
+import { routeCapabilities } from './route-manager';
+import type { RouteStateBucket } from './utils';
+import { cancel, scheduleOnce } from '@ember/runloop';
+import { Promise } from 'rsvp';
+import type { InternalRouteInfo } from 'router_js';
+import { STATE_SYMBOL } from 'router_js';
+import type Controller from '@ember/controller';
+
+// --- Bucket ---
+
+export class ClassicRouteBucket implements RouteStateBucket {
+  route: Route;
+  args: CreateRouteArgs;
+
+  // Cached invokable returned from getInvokable. Stable for the bucket's
+  // lifetime so the outlet's wrapper-driven rendering can reuse the same
+  // resolved component definition across re-renders without re-resolving the
+  // template.
+  invokable: object | undefined = undefined;
+
+  wrapper: object | undefined = undefined;
+
+  // Timer handle for any pending loading substate transition scheduled during
+  // willEnter. Stored per-bucket so that concurrent routes each track their
+  // own timer and didEnter can cancel the right one without clobbering another
+  // route's timer.
+  loadingSubstateTimer: unknown = null;
+
+  controller: Controller | undefined = undefined;
+
+  constructor(route: Route, args: CreateRouteArgs) {
+    this.route = route;
+    this.args = args;
+  }
+}
+
+// --- Classic interop args ---
+
+/**
+ * Extra args provided to manager methods when classicInterop is enabled.
+ * These give the ClassicRouteManager access to router_js internals needed
+ * to replicate the classic hook behaviour.
+ */
+export interface ClassicInteropArgs {
+  transition: any;
+  routeInfo: any;
+}
+
+// --- Classic route wrapper component ---
+
+/**
+ * Shared wrapper template. We pair this template with a fresh
+ * `ClassicRouteWrapperDefinition` per bucket inside `getRouteWrapper`, so that
+ * two routes (potentially sharing a Route class) get distinct wrapper
+ * component identities for the outlet stability check.
+ *
+ * The wrapper renders the per-render invokable (the route's template/component,
+ * returned from getInvokable) and forwards `@model` and `@controller` onto it.
+ *
+ * The outlet helper curries `@Component`, `@routeInfo`, `@model`, and
+ * `@controller` onto this wrapper at render time, see the outlet pipeline in
+ * `@ember/-internals/glimmer/lib/syntax/outlet`. `@controller` is resolved
+ * there to a const ref, because RouteTemplateManager uses it as the inner
+ * template's `self` and inner internal components (LinkTo, Input, etc.) assert
+ * `isConstRef(caller)`.
+ */
+const CLASSIC_WRAPPER_TEMPLATE = precompileTemplate(
+  `<@Component @model={{@model}} @controller={{@controller}} />`,
+  {
+    moduleName: 'packages/@ember/-internals/routing/route-managers/classic-route-wrapper.hbs',
+    strictMode: true,
+  }
+);
+
+/**
+ * Capabilities for `ClassicRouteWrapperManager`. Match `templateOnlyComponent`'s
+ * defaults: no element, no args capture, no instance state.
+ */
+const CLASSIC_WRAPPER_CAPABILITIES: InternalComponentCapabilities = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: false,
+  attributeHook: false,
+  elementHook: false,
+  createCaller: false,
+  dynamicScope: false,
+  updateHook: false,
+  createInstance: false,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false,
+};
+
+/**
+ * Component manager for the classic wrapper. Functionally identical to glimmer's
+ * `TemplateOnlyComponentManager` except that `getDebugCustomRenderTree` returns
+ * an empty array, so the wrapper does not appear as its own node in the render
+ * tree. This keeps the render-tree shape the same as before the wrapper layer
+ * was introduced.
+ */
+class ClassicRouteWrapperManager
+  implements
+    InternalComponentManager<null, ClassicRouteWrapperDefinition>,
+    WithCustomDebugRenderTree<null, ClassicRouteWrapperDefinition>
+{
+  getCapabilities(): InternalComponentCapabilities {
+    return CLASSIC_WRAPPER_CAPABILITIES;
+  }
+
+  getDebugName(): string {
+    return '';
+  }
+
+  getDebugCustomRenderTree(): CustomRenderNode[] {
+    return [];
+  }
+
+  getSelf(): Reference {
+    return NULL_REFERENCE;
+  }
+
+  getDestroyable(): null {
+    return null;
+  }
+}
+
+const CLASSIC_WRAPPER_MANAGER = new ClassicRouteWrapperManager();
+class ClassicRouteWrapperDefinition {
+  constructor(public name: string) {}
+}
+
+setInternalComponentManager(CLASSIC_WRAPPER_MANAGER, ClassicRouteWrapperDefinition.prototype);
+setComponentTemplate(CLASSIC_WRAPPER_TEMPLATE, ClassicRouteWrapperDefinition.prototype);
+
+// --- ClassicRouteManager ---
+
+/**
+ * The ClassicRouteManager wraps the classic Route lifecycle so that all
+ * routes flow through the RouteManager interface. Every method delegates
+ * to the Route instance stored in the bucket.
+ *
+ * Capabilities: classicInterop = true
+ */
+export class ClassicRouteManager implements RouteManager<ClassicRouteBucket> {
+  capabilities: RouteCapabilities = routeCapabilities('1.0', { classicInterop: true });
+
+  #owner: Owner;
+
+  constructor(owner: Owner) {
+    this.#owner = owner;
+  }
+
+  createRoute(RouteClass: typeof Route, args: CreateRouteArgs): ClassicRouteBucket {
+    let props = {};
+    setOwner(props, this.#owner);
+    let route = RouteClass.create(props);
+    route._setRouteName(args.name);
+
+    const bucket = new ClassicRouteBucket(route, args);
+    route.bucket = bucket;
+    route.manager = this;
+
+    return bucket;
+  }
+
+  getDestroyable(bucket: ClassicRouteBucket): Destroyable | null {
+    return bucket.route;
+  }
+
+  // --- Enter lifecycle ---
+
+  private _runBeforeModel(route: Route, transition: any): Promise<unknown> {
+    let result: unknown;
+    if (route.beforeModel !== undefined) {
+      result = route.beforeModel(transition);
+    }
+
+    if (this._isTransition(result)) {
+      result = null;
+    }
+
+    return Promise.resolve(result);
+  }
+
+  private _getModel(routeInfo: any, transition: any): Promise<unknown> {
+    // Delegate to routeInfo.getModel() for polymorphic dispatch:
+    // - UnresolvedRouteInfoByParam calls route.deserialize/model with URL params
+    // - UnresolvedRouteInfoByObject returns the pre-provided model object directly
+    // This is critical when transitionTo() is called with a model object rather than URL params.
+    return Promise.resolve(routeInfo.getModel(transition)).then((resolvedModel: unknown) => {
+      let name = routeInfo.name;
+      transition.resolvedModels = transition.resolvedModels || {};
+      transition.resolvedModels[name] = resolvedModel;
+      return resolvedModel;
+    });
+  }
+
+  private _runAfterModel(route: Route, resolvedModel: unknown, transition: any): Promise<unknown> {
+    let name = route.routeName || route._internalName;
+    transition.resolvedModels = transition.resolvedModels || {};
+    transition.resolvedModels[name] = resolvedModel;
+
+    let result: unknown;
+    if (route.afterModel !== undefined) {
+      result = route.afterModel(resolvedModel, transition);
+    }
+
+    result = this._isTransition(result) ? null : result;
+
+    return Promise.resolve(result).then(() => {
+      return transition.resolvedModels[name];
+    });
+  }
+
+  private _isTransition(obj: unknown): boolean {
+    return typeof obj === 'object' && obj !== null && (obj as any).isTransition === true;
+  }
+
+  willEnter(
+    bucket: ClassicRouteBucket,
+    args: NavigationState & NavigationActions & NavigationStateWithTransition
+  ): void {
+    const transition = args.transition;
+
+    bucket.controller = bucket.route._initController();
+
+    if (!transition.isActive) {
+      return;
+    }
+
+    // Schedule the loading substate detection on the 'routerTransitions' queue.
+    // We do not look up the substate name here. Looking up factoryFor a missing
+    // template (e.g. on a fast initial visit where no loading template is added)
+    // poisons the registry's _failSet, so subsequent factoryFor calls return
+    // undefined even after the template is registered. Deferring the lookup until
+    // the timer fires mirrors the original _scheduleLoadingEvent timing and lets
+    // any addTemplate calls in the test setup land before we look anything up.
+    bucket.loadingSubstateTimer = scheduleOnce(
+      'routerTransitions',
+      this,
+      this._enterLoadingSubstate,
+      bucket,
+      transition
+    );
+  }
+
+  private _enterLoadingSubstate(bucket: ClassicRouteBucket, transition: any): void {
+    if (!bucket.loadingSubstateTimer || !transition.isActive) {
+      return;
+    }
+    bucket.loadingSubstateTimer = null;
+
+    // Walk up the route tree starting from this bucket's route to find a loading
+    // substate. Mirrors the original defaultActionHandlers.loading + forEachRouteAbove
+    // which received routeInfos sliced to the currently resolving route, not the
+    // full transition.
+    //   - For the slow route itself, only check substate form (foo_loading). The
+    //     state form (foo.loading) is its own child, technically below where we are.
+    //   - For ancestor routes, check both state form (foo.loading) and substate
+    //     form (foo_loading).
+    //   - Stop at the pivot route, do not bubble higher.
+    const routeInfos = transition[STATE_SYMBOL]?.routeInfos ?? [];
+    const pivotHandler = transition.pivotHandler;
+
+    let slowRouteInfo: InternalRouteInfo<Route> | undefined;
+    for (const candidate of routeInfos) {
+      if (candidate?.route === bucket.route) {
+        slowRouteInfo = candidate;
+        break;
+      }
+    }
+    const slowIndex = slowRouteInfo ? routeInfos.indexOf(slowRouteInfo) : -1;
+    const startIndex = slowIndex >= 0 ? slowIndex : routeInfos.length - 1;
+
+    let loadingSubstateName = '';
+    for (let i = startIndex; i >= 0; i--) {
+      const ancestorRouteInfo = routeInfos[i];
+      const ancestorRoute = ancestorRouteInfo?.route;
+      if (!ancestorRoute) continue;
+
+      const ancestorOwner = getOwner(ancestorRoute);
+      assert('Route is unexpectedly missing an owner', ancestorOwner);
+
+      // Skip the state route check (foo.loading) for the slow route itself,
+      // since that would be a child route and below where we are.
+      if (ancestorRouteInfo !== slowRouteInfo) {
+        loadingSubstateName = this._findRouteStateName(ancestorRoute, ancestorOwner, 'loading');
+        if (loadingSubstateName) break;
+      }
+
+      loadingSubstateName = this._findRouteSubstateName(ancestorRoute, ancestorOwner, 'loading');
+      if (loadingSubstateName) break;
+
+      if (pivotHandler === ancestorRoute) break;
+    }
+
+    if (!loadingSubstateName) {
+      return;
+    }
+
+    bucket.route._router.intermediateTransitionTo(loadingSubstateName);
+  }
+
+  // Checks whether a substate route of the form `routeName_state` exists.
+  private _findRouteSubstateName(route: Route, owner: Owner, state: string): string {
+    const { routeName, fullRouteName, _router: router } = route;
+    const substateName = `${routeName}_${state}`;
+    const substateNameFull = `${fullRouteName}_${state}`;
+    return this._routeHasBeenDefined(owner, router, substateName, substateNameFull)
+      ? substateNameFull
+      : '';
+  }
+
+  // Checks whether a state route of the form `routeName.state` exists.
+  private _findRouteStateName(route: Route, owner: Owner, state: string): string {
+    const { routeName, fullRouteName, _router: router } = route;
+    const stateName = routeName === 'application' ? state : `${routeName}.${state}`;
+    const stateNameFull = fullRouteName === 'application' ? state : `${fullRouteName}.${state}`;
+    return this._routeHasBeenDefined(owner, router, stateName, stateNameFull) ? stateNameFull : '';
+  }
+
+  // A route is defined if the router has the route AND the owner has a template or route class.
+  private _routeHasBeenDefined(
+    owner: Owner,
+    router: any,
+    localName: string,
+    fullName: string
+  ): boolean {
+    const routerHasRoute = router.hasRoute(fullName);
+    const ownerHasRoute =
+      owner.factoryFor(`template:${localName}`) || owner.factoryFor(`route:${localName}`);
+    return Boolean(routerHasRoute && ownerHasRoute);
+  }
+
+  enter(
+    bucket: ClassicRouteBucket,
+    args: NavigationState & NavigationActions & AsyncNavigationState & NavigationStateWithTransition
+  ): Promise<unknown> {
+    let route = bucket.route;
+    let transition = args.transition;
+    let routeInfo = args.to;
+
+    if (transition.trigger) {
+      transition.trigger(true, 'willResolveModel', transition, route);
+    }
+
+    return (
+      this._runBeforeModel(route, transition)
+        .then(() => {
+          if (transition.isAborted) {
+            throw transition.error;
+          }
+        })
+        .then(() => this._getModel(routeInfo, transition))
+        // _getModel uses routeInfo.getModel() for polymorphic dispatch
+        .then((resolvedModel) => {
+          if (transition.isAborted) {
+            throw transition.error;
+          }
+          return resolvedModel;
+        })
+        .then((resolvedModel) => this._runAfterModel(route, resolvedModel, transition))
+    );
+  }
+
+  didEnter(
+    bucket: ClassicRouteBucket,
+    args: NavigationState & NavigationStateWithTransition
+  ): void {
+    // Cancel the pending loading substate if enter() resolved before it fired.
+    if (bucket.loadingSubstateTimer) {
+      cancel(bucket.loadingSubstateTimer as any);
+      bucket.loadingSubstateTimer = null;
+    }
+
+    let route = bucket.route;
+    // Read context from the routeInfo (args.to). The routeInfo is the per-render
+    // handle
+    let context = (args.to as any).context;
+    let transition = args.transition;
+    let enter = (args as any).enter;
+
+    // Classic enter: activate + trigger 'activate' (only on fresh enter, not updates)
+    if (enter) {
+      route.activate(transition);
+      route.trigger('activate', transition);
+    }
+
+    // Set the resolved context on the route object
+    route.context = context;
+    if (route.contextDidChange !== undefined) {
+      route.contextDidChange();
+    }
+
+    if (route.setup !== undefined) {
+      route.setup(context, transition!);
+    }
+
+    // _setOutlets is no longer scheduled here. Rendering is driven by
+    // onRouteInvokableReady in EmberRouter, which fires as soon as getInvokable()
+    // resolves, before enter() finishes. By the time didEnter runs, the outlet is
+    // already rendering the route template with the reactive @model and @controller refs.
+  }
+
+  // --- Exit lifecycle ---
+
+  willExit(bucket: ClassicRouteBucket, _args: NavigationState & NavigationActions): void {
+    let route = bucket.route;
+    // Extract isExiting and transition from args (passed by router_js)
+    let isExiting = (_args as any).isExiting ?? true;
+    let transition = (_args as any).transition;
+    // _internalReset handles resetting QP delegate on the controller
+    route._internalReset(isExiting, transition);
+  }
+
+  exit(bucket: ClassicRouteBucket, _args: NavigationState): void {
+    let route = bucket.route;
+    let transition = (_args as any).transition;
+    delete route.context;
+    route.deactivate(transition);
+    route.trigger('deactivate', transition);
+    route.teardownViews();
+  }
+
+  didExit(_bucket: ClassicRouteBucket, _args: NavigationState): void {
+    // No-op for classic routes
+  }
+
+  // --- Template/Component lookup ---
+
+  getRouteWrapper(bucket: ClassicRouteBucket): object {
+    if (bucket.wrapper !== undefined) {
+      return bucket.wrapper;
+    }
+    // Fresh ClassicRouteWrapperDefinition per bucket so outlet stability
+    // checks (`wrapper === lastWrapper`) correctly distinguish two different
+    // routes which may share a Route class.
+    const wrapper = new ClassicRouteWrapperDefinition(bucket.args.name);
+    bucket.wrapper = wrapper;
+    return wrapper;
+  }
+
+  getInvokable(
+    bucket: ClassicRouteBucket,
+    enterPromise: Promise<unknown>
+  ): Promise<object | undefined> {
+    // Build the invokable synchronously, then gate on enterPromise. Awaiting
+    // enterPromise ensures onRouteInvokableReady does not fire until data is
+    // loaded, whether this is a fresh entry or a re-entry where the model hook
+    // runs again. During the wait, the deferred scheduleOnce in willEnter fires
+    // and enters the loading substate. Once enter() resolves, the invokable is
+    // returned and the real route renders, replacing the loading substate.
+    const invokable = this._buildInvokable(bucket);
+    return (enterPromise || Promise.resolve()).then(() => invokable);
+  }
+
+  // Build the route's user-facing invokable: the user's
+  // route template/component (uncurried). Currying with `@model` and
+  // `@controller` happens in the wrapper component returned from
+  // getRouteWrapper, so this method just looks up the template.
+  //
+  // Synchronous so EmberRouter.onIntermediateTransition can call it directly
+  // for substate routes (loading/error) without awaiting enterPromise.
+  _buildInvokable(bucket: ClassicRouteBucket): object {
+    if (bucket.invokable !== undefined) {
+      return bucket.invokable;
+    }
+
+    let route = bucket.route;
+    let owner = getOwner(route);
+    assert('Route is unexpectedly missing an owner', owner);
+
+    let name = route.templateName || route.routeName;
+    let templateFactoryOrComponent = owner.lookup(`template:${name}`) as
+      | TemplateFactory
+      | object
+      | undefined;
+
+    let invokable: object;
+
+    if (templateFactoryOrComponent) {
+      if (hasInternalComponentManager(templateFactoryOrComponent)) {
+        // ComponentLike, used as the invokable directly. The VM will resolve
+        // its definition when the wrapper renders <@Component />.
+        invokable = templateFactoryOrComponent;
+      } else {
+        if (DEBUG && typeof templateFactoryOrComponent !== 'function') {
+          let label: string;
+
+          try {
+            label = `\`${String(templateFactoryOrComponent)}\``;
+          } catch {
+            label = 'an unknown object';
+          }
+
+          assert(
+            `Failed to render the ${name} route, expected ` +
+              `\`template:${name}\` to resolve into ` +
+              `a component or a \`TemplateFactory\`, got: ${label}. ` +
+              `Most likely an improperly defined class or an invalid module export.`
+          );
+        }
+
+        // TemplateFactory -> Template -> RouteTemplate (component with no args)
+        let template = (templateFactoryOrComponent as TemplateFactory)(owner);
+        invokable = makeRouteTemplate(owner, name, template as Template);
+      }
+    } else {
+      if (DEBUG) {
+        let LOG_VIEW_LOOKUPS = get(route._router, 'namespace.LOG_VIEW_LOOKUPS');
+        if (LOG_VIEW_LOOKUPS) {
+          info(`Could not find "${name}" template. Nothing will be rendered`, {
+            fullName: `template:${name}`,
+          });
+        }
+      }
+      // Default {{outlet}} template -> RouteTemplate
+      let template = route._topLevelViewTemplate(owner);
+      invokable = makeRouteTemplate(owner, name, template as Template);
+    }
+
+    bucket.invokable = invokable;
+
+    return invokable;
+  }
+}
diff --git a/packages/@ember/-internals/routing/route-managers/classic-route-wrapper.gts b/packages/@ember/-internals/routing/route-managers/classic-route-wrapper.gts
new file mode 100644
index 00000000000..0ca222d6f8b
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/classic-route-wrapper.gts
@@ -0,0 +1,61 @@
+
+import { CustomRenderNode, InternalComponentCapabilities, Reference } from '@glimmer/interfaces';
+import {
+  setInternalComponentManager
+} from '@glimmer/manager';
+import { NULL_REFERENCE } from '@glimmer/reference';
+
+/**
+ * Component manager for the classic wrapper. Functionally identical to glimmer's
+ * `TemplateOnlyComponentManager` except that `getDebugCustomRenderTree` returns
+ * an empty array, so the wrapper does not appear as its own node in the render
+ * tree. This keeps the render-tree shape (and the assertion-error output that
+ * cites it) the same as before the wrapper layer was introduced: the existing
+ * tests assert `{{outlet}} for X -> X (route template)` directly with no
+ * intermediate node.
+ */
+class ClassicRouteWrapperManager
+{
+  getCapabilities(): InternalComponentCapabilities {
+    return {
+      dynamicLayout: false,
+      dynamicTag: false,
+      prepareArgs: false,
+      createArgs: false,
+      attributeHook: false,
+      elementHook: false,
+      createCaller: false,
+      dynamicScope: false,
+      updateHook: false,
+      createInstance: false,
+      wrapped: false,
+      willDestroy: false,
+      hasSubOwner: false,
+    };
+  }
+
+  getDebugName(): string {
+    return '';
+  }
+
+  getDebugCustomRenderTree(): CustomRenderNode[] {
+    return [];
+  }
+
+  getSelf(): Reference {
+    return NULL_REFERENCE;
+  }
+
+  getDestroyable(): null {
+    return null;
+  }
+}
+
+const CLASSIC_WRAPPER_MANAGER = new ClassicRouteWrapperManager();
+export class ClassicRouteWrapper {
+  <template>
+    <@Component @model={{@model}} @controller={{@controller}} />
+  </template>
+}
+
+setInternalComponentManager(() => new ClassicRouteWrapperManager(), ClassicRouteWrapper);
diff --git a/packages/@ember/-internals/routing/route-managers/route-manager.ts b/packages/@ember/-internals/routing/route-managers/route-manager.ts
new file mode 100644
index 00000000000..f60f330ef04
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/route-manager.ts
@@ -0,0 +1,111 @@
+import type { Capabilities, Destroyable } from '@glimmer/interfaces';
+import type { RouteStateBucket } from './utils';
+import type { RouteInfo } from '@ember/routing/-internals';
+import type Transition from '../../../routing/transition';
+
+// --- Capabilities ---
+
+export interface RouteCapabilitiesVersions {
+  '1.0': {
+    classicInterop?: boolean;
+  };
+}
+
+export interface RouteCapabilities extends Capabilities {
+  classicInterop: boolean;
+}
+
+export function routeCapabilities<Version extends keyof RouteCapabilitiesVersions>(
+  _managerAPI: Version,
+  options: RouteCapabilitiesVersions[Version] = {}
+): RouteCapabilities {
+  let capabilities = {
+    classicInterop: Boolean(options.classicInterop),
+  };
+
+  Object.freeze(capabilities);
+
+  // The Capabilities brand is structural (a unique symbol that only exists in the
+  // type system). We cast here the same way @glimmer/manager's buildCapabilities does.
+  return capabilities as RouteCapabilities;
+}
+
+// --- Navigation args ---
+
+export interface NavigationState {
+  from?: RouteInfo;
+  to: RouteInfo;
+}
+
+export interface NavigationActions {
+  /** Cancels the current navigation */
+  cancel: () => void;
+}
+
+export interface AsyncNavigationState {
+  /** Signal for the current navigation */
+  signal?: AbortSignal;
+
+  /**
+   * Retrieve the ancestor promise for an ancestor route, to await async ancestor behaviour.
+   * If no routeInfo is passed, returns the immediate parent route's promise.
+   */
+  getAncestorPromise(routeInfo?: RouteInfo): ReturnType<RouteManager<RouteStateBucket>['enter']>;
+}
+
+export interface NavigationStateWithTransition extends NavigationState {
+  transition: Transition;
+}
+
+export interface CreateRouteArgs {
+  name: string;
+}
+
+// --- RouteManager interface ---
+
+export interface RouteManager<R extends RouteStateBucket> {
+  capabilities: RouteCapabilities;
+
+  createRoute(factory: object, args: CreateRouteArgs): R;
+  getDestroyable(bucket: R): Destroyable | null;
+
+  willEnter(
+    bucket: R,
+    args: NavigationState & NavigationActions & NavigationStateWithTransition
+  ): void;
+  enter(
+    bucket: R,
+    args: NavigationState & NavigationActions & AsyncNavigationState & NavigationStateWithTransition
+  ): Promise<unknown>;
+  didEnter(bucket: R, args: NavigationState & NavigationStateWithTransition): void;
+
+  willExit(
+    bucket: R,
+    args: NavigationState & NavigationActions & NavigationStateWithTransition
+  ): void;
+  exit(bucket: R, args: NavigationState & NavigationStateWithTransition): void;
+  didExit(bucket: R, args: NavigationState & NavigationStateWithTransition): void;
+
+  /**
+   * Returns a module-stable wrapper component the router curries the
+   * per-render invokable into. The same value should be returned for every
+   * call with the same bucket (and ideally for every bucket sharing the same
+   * underlying route definition). The router curries `@Component` (the
+   * invokable from getInvokable) and the model and controller onto it; managers
+   * may use either of those args to derive whatever they need to render.
+   */
+  getRouteWrapper(bucket: R): object;
+
+  /**
+   * Called per transition. The `enterPromise` arg is the promise returned from
+   * the matching call to `enter()`. Managers may await it (classic, to gate
+   * rendering on data load) or ignore it (pioneer-style, to render immediately
+   * and let the wrapper component coordinate loading state).
+   */
+  getInvokable(bucket: R, enterPromise: Promise<unknown>): Promise<object | undefined>;
+}
+
+// --- Factory type ---
+
+export type Manager = RouteManager<RouteStateBucket>;
+export type ManagerFactory<O, D extends Manager = Manager> = (owner: O) => D;
diff --git a/packages/@ember/-internals/routing/route-managers/utils.ts b/packages/@ember/-internals/routing/route-managers/utils.ts
new file mode 100644
index 00000000000..0b38a6a7687
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/utils.ts
@@ -0,0 +1,94 @@
+import type Controller from '@ember/controller';
+import type { ManagerFactory, RouteManager } from './route-manager';
+import { DEBUG } from '@glimmer/env';
+import { debugAssert } from '@glimmer/global-context';
+
+export interface RouteStateBucket {
+  invokable?: object;
+  instance?: unknown;
+  controller?: Controller;
+  args: object;
+}
+
+const ROUTE_MANAGERS = new WeakMap<object, ManagerFactory<any, RouteManager<any>>>();
+
+/**
+ * There is also Reflect.getPrototypeOf,
+ * which errors when non-objects are passed.
+ *
+ * Since our conditional for figuring out whether to render primitives or not
+ * may contain non-object values, we don't want to throw errors when we call this.
+ */
+const getPrototypeOf = Object.getPrototypeOf;
+
+function setManager<Def extends object>(
+  map: WeakMap<object, object>,
+  manager: object,
+  obj: Def
+): Def {
+  if (DEBUG) {
+    debugAssert(
+      obj !== null && (typeof obj === 'object' || typeof obj === 'function'),
+
+      `Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${
+        obj
+      }`
+    );
+
+    debugAssert(
+      !map.has(obj),
+      `Attempted to set the same type of manager multiple times on a value. You can only associate one manager of each type with a given value. Value was ${
+        obj
+      }`
+    );
+  }
+
+  map.set(obj, manager);
+  return obj;
+}
+
+function getManager<M extends ManagerFactory<any, RouteManager<RouteStateBucket>>>(
+  map: WeakMap<object, M>,
+  obj: object
+): ManagerFactory<any, RouteManager<RouteStateBucket>> | undefined {
+  let pointer: object | null = obj;
+  while (pointer !== null) {
+    const manager = map.get(pointer);
+
+    if (manager !== undefined) {
+      return manager;
+    }
+
+    pointer = getPrototypeOf(pointer) as object | null;
+  }
+
+  return undefined;
+}
+
+export function setRouteManager<T extends object>(
+  factory: ManagerFactory<any, RouteManager<RouteStateBucket>>,
+  definition: T
+): T {
+  setManager(ROUTE_MANAGERS, factory, definition);
+
+  return definition;
+}
+
+export function getRouteManager<T extends object>(
+  definition: T
+): ManagerFactory<any, RouteManager<RouteStateBucket>> | undefined {
+  let factory = getManager(ROUTE_MANAGERS, definition);
+
+  if (factory === undefined) {
+    if (DEBUG) {
+      debugAssert(
+        false,
+        `Attempted to load a route, but there wasn't a route manager associated with the definition. The definition was: ${
+          definition
+        }`
+      );
+    }
+  }
+
+  return factory;
+}
diff --git a/packages/@ember/routing/index.ts b/packages/@ember/routing/index.ts
index be0dd6e698f..ad0e14376c9 100644
--- a/packages/@ember/routing/index.ts
+++ b/packages/@ember/routing/index.ts
@@ -1 +1,9 @@
 export { default as LinkTo } from '@ember/-internals/glimmer/lib/components/link-to';
+export { setRouteManager } from '@ember/-internals/routing/route-managers/utils';
+export { ClassicRouteManager } from '@ember/-internals/routing/route-managers/classic-route-manager';
+export { routeCapabilities } from '@ember/-internals/routing/route-managers/route-manager';
+
+import type { RouteStateBucket } from '@ember/-internals/routing';
+import type { RouteManager as InternalRouteManager } from '@ember/-internals/routing/route-managers/route-manager';
+
+export type RouteManager = InternalRouteManager<RouteStateBucket>;
diff --git a/packages/@ember/routing/route.ts b/packages/@ember/routing/route.ts
index ae3b59a1a59..9f6249e7e29 100644
--- a/packages/@ember/routing/route.ts
+++ b/packages/@ember/routing/route.ts
@@ -21,14 +21,10 @@ import type { AnyFn } from '@ember/-internals/utility-types';
 import Controller from '@ember/controller';
 import type { ControllerQueryParamType } from '@ember/controller';
 import { isTesting } from '@ember/debug/lib/testing';
-import { assert, info } from '@ember/debug';
+import { assert } from '@ember/debug';
 import EngineInstance from '@ember/engine/instance';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { once } from '@ember/runloop';
-import { DEBUG } from '@glimmer/env';
-import { hasInternalComponentManager } from '@glimmer/manager/lib/internal/api';
-import type { RenderState } from '@ember/-internals/glimmer/lib/utils/outlet';
-import type { TemplateFactory } from '@glimmer/interfaces';
 import type { InternalRouteInfo, Route as IRoute, Transition, TransitionState } from 'router_js';
 import { PARAMS_SYMBOL, STATE_SYMBOL } from 'router_js';
 import type { QueryParam, default as EmberRouter } from '@ember/routing/router';
@@ -64,9 +60,6 @@ type RouteTransitionState = TransitionState<Route> & {
 type MaybeParameters<T> = T extends AnyFn ? Parameters<T> : unknown[];
 type MaybeReturnType<T> = T extends AnyFn ? ReturnType<T> : unknown;
 
-const RENDER = Symbol('render');
-const RENDER_STATE = Symbol('render-state');
-
 /**
 @module @ember/routing/route
 */
@@ -791,13 +784,35 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
     this.resetController(controller, isExiting, transition);
   }
 
+  /**
+    Resolve and assign this route's controller eagerly. Used by the route
+    manager during getInvokable so that the controller is available when the
+    route template renders, before didEnter/setup runs. Idempotent, calling
+    setup() later will see this.controller is set and skip the assignment.
+
+    @private
+    @method _initController
+   */
+  _initController() {
+    if (this.controller) {
+      return this.controller;
+    }
+    let controllerName = this.controllerName || this.routeName;
+    let definedController = this.controllerFor(controllerName, true);
+    let controller = definedController ?? this.generateController(controllerName);
+    let queryParams = get(this, '_qp') as Route<Model>['_qp'];
+    let propNames = queryParams.propertyNames;
+    addQueryParamsObservers(controller, propNames);
+    this.controller = controller;
+    return controller;
+  }
+
   /**
     @private
 
     @method enter
   */
   enter(transition: Transition) {
-    this[RENDER_STATE] = undefined;
     this.activate(transition);
     this.trigger('activate', transition);
   }
@@ -962,10 +977,6 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
 
     this.setupController(controller, context, transition);
 
-    if (this._environment.options.shouldRender) {
-      this[RENDER]();
-    }
-
     // Setup can cause changes to QPs which need to be propogated immediately in
     // some situations. Eventually, we should work on making these async somehow.
     flushAsyncObservers(false);
@@ -1464,18 +1475,6 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
     return route?.currentModel;
   }
 
-  [RENDER_STATE]: RenderState | undefined = undefined;
-
-  /**
-    `this[RENDER]` is used to set up the rendering option for the outlet state.
-    @method this[RENDER]
-    @private
-   */
-  [RENDER]() {
-    this[RENDER_STATE] = buildRenderState(this);
-    once(this._router, '_setOutlets');
-  }
-
   willDestroy() {
     this.teardownViews();
   }
@@ -1486,8 +1485,7 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
     @method teardownViews
   */
   teardownViews() {
-    if (this[RENDER_STATE]) {
-      this[RENDER_STATE] = undefined;
+    if (this._router) {
       once(this._router, '_setOutlets');
     }
   }
@@ -1790,97 +1788,6 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
   >;
 }
 
-export function getRenderState(route: Route): RenderState | undefined {
-  return route[RENDER_STATE];
-}
-
-function buildRenderState(route: Route): RenderState {
-  let owner = getOwner(route);
-  assert('Route is unexpectedly missing an owner', owner);
-
-  let name = route.routeName;
-
-  let controller = owner.lookup(`controller:${route.controllerName || name}`);
-  assert('Expected an instance of controller', controller instanceof Controller);
-
-  let model = route.currentModel;
-
-  let templateFactoryOrComponent = owner.lookup(`template:${route.templateName || name}`) as
-    | TemplateFactory
-    | object // This is meant to be a component
-    | undefined;
-
-  // Now we support either a component or a template to be returned by this
-  // resolver call, but if it's a `TemplateFactory`, we need to instantiate
-  // it into a `Template`, since that's what `RenderState` wants. We can't
-  // easily change it, it's intimate API used by @ember/test-helpers and the
-  // like. We could compatibly allow `Template` | `TemplateFactory`, and that's
-  // what it used to do but we _just_ went through deprecations to get that
-  // removed. It's also not ideal since once you mix the two types, they are
-  // not exactly easy to tell apart.
-  //
-  // It may also be tempting to just normalize `Template` into `RouteTemplate`
-  // here, and we could. However, this is not the only entrypoint where this
-  // `RenderState` is made – @ember/test-helpers punches through an impressive
-  // amount of private API to set it directly, and this feature would also be
-  // useful for them. So, even if we had normalized here, we'd still have to
-  // check and do that again during render anyway.
-  let template: object;
-
-  if (templateFactoryOrComponent) {
-    if (hasInternalComponentManager(templateFactoryOrComponent)) {
-      template = templateFactoryOrComponent;
-    } else {
-      if (DEBUG && typeof templateFactoryOrComponent !== 'function') {
-        let label: string;
-
-        try {
-          label = `\`${String(templateFactoryOrComponent)}\``;
-        } catch {
-          label = 'an unknown object';
-        }
-
-        assert(
-          `Failed to render the ${name} route, expected ` +
-            `\`template:${route.templateName || name}\` to resolve into ` +
-            `a component or a \`TemplateFactory\`, got: ${label}. ` +
-            `Most likely an improperly defined class or an invalid module export.`
-        );
-      }
-
-      template = (templateFactoryOrComponent as TemplateFactory)(owner);
-    }
-  } else {
-    // default `{{outlet}}`
-    template = route._topLevelViewTemplate(owner);
-  }
-
-  let render: RenderState = {
-    owner,
-    name,
-    controller,
-    model,
-    template,
-  };
-
-  if (DEBUG) {
-    let LOG_VIEW_LOOKUPS = get(route._router, 'namespace.LOG_VIEW_LOOKUPS');
-    // This is covered by tests and the existing code was deliberately
-    // targeting the value prior to normalization, but is this message actually
-    // accurate? It seems like we will always default the `{{outlet}}` template
-    // so I'm not sure about "Nothing will be rendered?" (who consumes these
-    // logs anyway? as lookups happen more infrequently now I doubt this is all
-    // that useful)
-    if (LOG_VIEW_LOOKUPS && !templateFactoryOrComponent) {
-      info(`Could not find "${name}" template. Nothing will be rendered`, {
-        fullName: `template:${name}`,
-      });
-    }
-  }
-
-  return render;
-}
-
 export function getFullQueryParams(router: EmberRouter, state: RouteTransitionState) {
   if (state.fullQueryParams) {
     return state.fullQueryParams;
@@ -2234,3 +2141,11 @@ Route.reopen({
 });
 
 export default Route;
+
+// --- Wire the ClassicRouteManager on the Route base class ---
+// Every Route subclass inherits this via the prototype-walking lookup in getRouteManager.
+
+import { setRouteManager } from '@ember/-internals/routing/route-managers/utils';
+import { ClassicRouteManager } from '@ember/-internals/routing/route-managers/classic-route-manager';
+
+setRouteManager((owner) => new ClassicRouteManager(owner), Route);
diff --git a/packages/@ember/routing/router.ts b/packages/@ember/routing/router.ts
index 7f6d760dd9d..6101f91f856 100644
--- a/packages/@ember/routing/router.ts
+++ b/packages/@ember/routing/router.ts
@@ -1,3 +1,4 @@
+import { getOwner as getInternalOwner } from '@ember/-internals/owner';
 import { privatize as P } from '@ember/-internals/container/lib/registry';
 import type {
   BootEnvironment,
@@ -31,16 +32,17 @@ import { A as emberA } from '@ember/array';
 import typeOf from '@ember/utils/lib/type-of';
 import Evented from '@ember/object/evented';
 import { assert, info } from '@ember/debug';
-import { cancel, once, run, scheduleOnce } from '@ember/runloop';
+import { once, run } from '@ember/runloop';
+import { Promise as RSVPPromise } from 'rsvp';
 import { DEBUG } from '@glimmer/env';
 import {
   type QueryParamMeta,
   type default as Route,
   defaultSerialize,
   getFullQueryParams,
-  getRenderState,
   hasDefaultSerialize,
 } from '@ember/routing/route';
+import { getRouteManager, RouteStateBucket } from '@ember/-internals/routing/route-managers/utils';
 import type {
   InternalRouteInfo,
   ModelFor,
@@ -50,13 +52,14 @@ import type {
   TransitionError,
   TransitionState,
 } from 'router_js';
+import type { InternalTransition } from 'router_js';
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
-import type { Timer } from 'backburner.js';
 import EngineInstance from '@ember/engine/instance';
 import type { QueryParams } from 'route-recognizer';
 import type { AnyFn, MethodNamesOf, OmitFirst } from '@ember/-internals/utility-types';
 import type { Template } from '@glimmer/interfaces';
 import type ApplicationInstance from '@ember/application/instance';
+import { RouteManager } from '@ember/-internals/routing/route-managers/route-manager';
 
 /**
 @module @ember/routing/router
@@ -65,8 +68,6 @@ import type ApplicationInstance from '@ember/application/instance';
 function defaultDidTransition(this: EmberRouter, infos: InternalRouteInfo<Route>[]) {
   updatePaths(this);
 
-  this._cancelSlowTransitionTimer();
-
   this.notifyPropertyChange('url');
   this.set('currentState', this.targetState);
 
@@ -197,8 +198,6 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
   _engineInfoByRoute = Object.create(null);
   _routerService: RouterService;
 
-  _slowTransitionTimer: Timer | null = null;
-
   private namespace: any;
 
   // Begin Evented
@@ -318,62 +317,108 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     this._routerService = routerService;
   }
 
-  _initRouterJs(): void {
-    let location = get(this, 'location') as EmberLocation;
-    let router = this;
-    const owner = getOwner(this);
-    assert('Router is unexpectedly missing an owner', owner);
-    let seen = Object.create(null);
-
-    class PrivateRouter extends Router<Route> {
-      getRoute(name: string): Route {
-        let routeName = name;
-        let routeOwner = owner;
-        let engineInfo = router._engineInfoByRoute[routeName];
+  // Both routes and manager instances are keyed first by owner so that engine routes
+  // (which share local names like 'application' with the main app) are isolated.
+  #routes = new WeakMap<object, Map<string, RouteStateBucket>>();
+  #routeManagerInstances = new WeakMap<object, WeakMap<Function, RouteManager<RouteStateBucket>>>();
 
-        if (engineInfo) {
-          let engineInstance = router._getEngineInstance(engineInfo);
+  getRoute(name: string, engineOwner?: Owner) {
+    if (name === 'undefined') {
+      return;
+    }
 
-          routeOwner = engineInstance;
-          routeName = engineInfo.localFullName;
-        }
+    assert('Name should not start with "route:"', !name.startsWith('route:'));
 
-        let fullRouteName = `route:${routeName}` as const;
+    // Resolve the owner and local route name.
+    // If engineOwner is provided (from the container bypass for an engine container),
+    // use it directly — the name is already the local route name within that engine.
+    // Otherwise, check _engineInfoByRoute to resolve engine routes by fully-qualified name.
+    let routeName = name;
+    let routeOwner: Owner;
 
-        assert('Route is unexpectedly missing an owner', routeOwner);
+    if (engineOwner) {
+      routeOwner = engineOwner;
+    } else {
+      routeOwner = getOwner(this)!;
+      assert('BUG: Missing owner', routeOwner);
 
-        let route = routeOwner.lookup(fullRouteName) as Route | undefined;
+      const engineInfo = this._engineInfoByRoute[routeName];
+      if (engineInfo) {
+        routeOwner = this._getEngineInstance(engineInfo);
+        routeName = engineInfo.localFullName;
+      }
+    }
 
-        if (seen[name]) {
-          assert('seen routes should exist', route);
-          return route;
-        }
+    // Per-owner route cache.
+    let ownerRoutes = this.#routes.get(routeOwner);
+    if (!ownerRoutes) {
+      ownerRoutes = new Map();
+      this.#routes.set(routeOwner, ownerRoutes);
+    }
 
-        seen[name] = true;
+    if (!ownerRoutes.has(routeName)) {
+      let fullRouteName = `route:${routeName}` as const;
+      let factoryManager = routeOwner.factoryFor(fullRouteName);
 
-        if (!route) {
-          // SAFETY: this is configured in `commonSetupRegistry` in the
-          // `@ember/application/lib` package.
-          let DefaultRoute: any = routeOwner.factoryFor('route:basic')!.class;
-          routeOwner.register(fullRouteName, class extends DefaultRoute {});
-          route = routeOwner.lookup(fullRouteName) as Route;
+      // Auto-generate a default route if none is registered.
+      if (!factoryManager) {
+        let DefaultRoute: any = routeOwner.factoryFor('route:basic')!.class;
+        routeOwner.register(fullRouteName, class extends DefaultRoute {});
+        factoryManager = routeOwner.factoryFor(fullRouteName);
 
-          if (DEBUG) {
-            if (router.namespace.LOG_ACTIVE_GENERATION) {
-              info(`generated -> ${fullRouteName}`, { fullName: fullRouteName });
-            }
+        if (DEBUG) {
+          if (this.namespace.LOG_ACTIVE_GENERATION) {
+            info(`generated -> ${fullRouteName}`, { fullName: fullRouteName });
           }
         }
+      }
 
-        route._setRouteName(routeName);
+      assert('BUG: Missing factory for route', factoryManager);
+      let RouteClass = factoryManager.class;
 
-        if (engineInfo && !hasDefaultSerialize(route)) {
-          throw new Error(
-            'Defining a custom serialize method on an Engine route is not supported.'
-          );
-        }
+      // Engine routes must not define a custom serialize method.
+      const isEngineRoute = routeOwner !== getOwner(this);
+      if (isEngineRoute && !hasDefaultSerialize((RouteClass as any).prototype)) {
+        throw new Error('Defining a custom serialize method on an Engine route is not supported.');
+      }
 
-        return route;
+      // Look up the manager factory function via prototype walk on the class.
+      let managerFactory = getRouteManager(RouteClass);
+      assert('Route manager needs to be defined', managerFactory !== undefined);
+
+      // Instantiate the manager once per owner. Keyed first by owner so engine routes
+      // get their own manager instances, then by factory function so all subclasses
+      // sharing the same factory share one manager instance within that owner.
+      let ownerRouteManagerInstances = this.#routeManagerInstances.get(routeOwner);
+      if (!ownerRouteManagerInstances) {
+        ownerRouteManagerInstances = new WeakMap();
+        this.#routeManagerInstances.set(routeOwner, ownerRouteManagerInstances);
+      }
+      if (!ownerRouteManagerInstances.has(managerFactory)) {
+        ownerRouteManagerInstances.set(managerFactory, managerFactory(routeOwner));
+      }
+      let routeManagerInstance = ownerRouteManagerInstances.get(managerFactory)!;
+
+      // Pass the concrete class to createRoute — the manager is responsible for instantiation.
+      let routeStateBucket = routeManagerInstance.createRoute(RouteClass, { name: routeName });
+
+      assert('Failed to create Route instance', (routeStateBucket as any).route);
+      ownerRoutes.set(routeName, routeStateBucket);
+    }
+
+    return (ownerRoutes.get(routeName)! as any).route;
+  }
+
+  _initRouterJs(): void {
+    let location = get(this, 'location') as EmberLocation;
+    let router = this;
+    const owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
+    class PrivateRouter extends Router<Route> {
+      getRoute(name: string): Route {
+        // All route instantiation and caching is owned by EmberRouter.getRoute,
+        // which resolves engine vs main-app owner internally.
+        return router.getRoute(name) as Route;
       }
 
       getSerializer(name: string) {
@@ -485,6 +530,32 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
           this.updateURL(url);
         }
       }
+
+      onRouteInvokableReady(
+        routeInfo: InternalRouteInfo<Route>,
+        transition: InternalTransition<Route>,
+        routeIndex: number
+      ): void {
+        router.onRouteInvokableReady(routeInfo, transition, routeIndex);
+      }
+
+      onIntermediateTransition(
+        newState: TransitionState<Route>,
+        transition: InternalTransition<Route>
+      ): void {
+        router.onIntermediateTransition(newState, transition);
+      }
+
+      onRouteContextSettled(routeInfo: InternalRouteInfo<Route>): void {
+        router.onRouteContextSettled(routeInfo);
+      }
+
+      onTransitionSettled(
+        transition: InternalTransition<Route>,
+        newState: TransitionState<Route>
+      ): Promise<void> {
+        return router.onTransitionSettled(transition, newState);
+      }
     }
 
     let routerMicrolib = (this._routerMicrolib = new PrivateRouter());
@@ -594,6 +665,273 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     return true;
   }
 
+  onRouteInvokableReady(
+    routeInfo: InternalRouteInfo<Route>,
+    _transition: InternalTransition<Route>,
+    routeIndex: number
+  ): void {
+    // A route's getInvokable() has resolved. Write it into currentRouteInfos at
+    // routeIndex — the exact position of this route in the transition hierarchy.
+    // Do not truncate beyond this index: an intermediate transition may have placed
+    // a loading substate at a higher index that should remain until its own slot
+    // is overwritten by the real route at that position.
+    const currentRouteInfos = this._routerMicrolib.currentRouteInfos ?? [];
+
+    currentRouteInfos[routeIndex] = routeInfo;
+
+    this._routerMicrolib.currentRouteInfos = currentRouteInfos;
+    once(this as any, '_setOutlets');
+  }
+
+  onRouteContextSettled(_routeInfo: InternalRouteInfo<Route>): void {
+    // A route's enterPromise has resolved and routeInfo.context is now the
+    // real value. Schedule a re-render so the outlet helper's @model arg
+    // (a path ref through outletStateTag) picks up the new context. Without
+    // this, render-immediate managers (where getInvokable resolves before
+    // enter()) would show @model=undefined until the whole transition
+    // settles.
+    if (this.isDestroying || this.isDestroyed) {
+      return;
+    }
+    once(this as any, '_setOutlets');
+  }
+
+  onIntermediateTransition(
+    newState: TransitionState<Route>,
+    transition: InternalTransition<Route>
+  ): void {
+    // An intermediate transition (e.g. a loading or error substate entered via
+    // intermediateTransitionTo) has fired. We splice the intermediate routes into
+    // currentRouteInfos without disturbing the ancestor routes already rendering.
+    // For each newly entered route: build the invokable, then fire didEnter so
+    // classic lifecycle hooks (activate, setup, etc.) run just as they do for
+    // normal transitions. Without didEnter, activate() never fires on error/loading
+    // substate routes and transitions awaiting those hooks hang indefinitely.
+    //
+    // Substate routes are always synchronously available (no async engine boundary,
+    // no model hook), so we run getInvokable + didEnter synchronously. This matches
+    // the original setupContexts ordering where activate fires before
+    // routeWillChange (router_js calls onIntermediateTransition then routeWillChange
+    // synchronously in transitionByIntent).
+    const microlib = this._routerMicrolib;
+    const partition = microlib.partitionRoutes(microlib.state!, newState);
+
+    const currentRouteInfos = [...partition.unchanged, ...partition.entered];
+
+    microlib.currentRouteInfos = currentRouteInfos;
+    // Update microlib.state to reflect the intermediate state. Without this, when
+    // the real transition completes and onTransitionSettled partitions against
+    // microlib.state, it would see ancestor routes (e.g. application) as still
+    // entering, firing didEnter and setupController twice for them.
+    microlib.oldState = microlib.state;
+    microlib.state = newState;
+
+    for (const routeInfo of partition.entered) {
+      const route = routeInfo.route;
+      if (!route?.manager) {
+        continue;
+      }
+
+      // Build the invokable synchronously. Substate routes don't have async work
+      // (no model hook, no engine loading), so getInvokable resolves on the same
+      // tick. We unwrap by treating it as a plain value rather than awaiting.
+      if (routeInfo.invokable === undefined && route.manager.capabilities.classicInterop) {
+        const invokable = (route.manager as any)._buildInvokable
+          ? (route.manager as any)._buildInvokable(route.bucket)
+          : undefined;
+        if (invokable !== undefined) {
+          routeInfo.invokable = invokable;
+          if (route.bucket) {
+            route.bucket.invokable = invokable;
+          }
+        }
+      }
+
+      route.manager.didEnter(route.bucket, {
+        transition,
+        to: routeInfo,
+        enter: true,
+      } as any);
+    }
+
+    once(this as any, '_setOutlets');
+  }
+
+  onTransitionSettled(
+    activeTransition: InternalTransition<Route>,
+    newState: TransitionState<Route>
+  ): Promise<void> {
+    // All getInvokable() calls in the transition have resolved and the outlet tree
+    // has already been updated incrementally via onRouteInvokableReady. The enter()
+    // promises are still in flight on each bucket. This method runs the remaining
+    // lifecycle: exit hooks, URL update, waiting for data, then didEnter/didExit.
+
+    const microlib = this._routerMicrolib;
+    const partition = microlib.partitionRoutes(microlib.state!, newState);
+
+    // Update router state now that we know which routes are settled.
+    microlib.oldState = microlib.state;
+    microlib.state = newState;
+
+    // Fire willExit and exit on routes leaving the hierarchy, leaf-first.
+    for (const exitingRouteInfo of partition.exited) {
+      const route = exitingRouteInfo.route;
+      if (route !== undefined) {
+        route.manager.willExit(route.bucket, { transition: activeTransition } as any);
+        route.manager.exit(route.bucket, { transition: activeTransition } as any);
+      }
+    }
+
+    // Remove exited routes from currentRouteInfos by filtering them out.
+    // We cannot simply truncate to unchanged.length because onRouteInvokableReady
+    // may have already written entering routes at higher indices. Instead, filter
+    // to only keep entries whose route object is not in the exited set.
+    const exitedRouteObjects = new Set(
+      partition.exited.map((exitingRouteInfo) => exitingRouteInfo.route)
+    );
+    if (microlib.currentRouteInfos) {
+      microlib.currentRouteInfos = microlib.currentRouteInfos.filter(
+        (currentRouteInfo) => !exitedRouteObjects.has(currentRouteInfo.route)
+      );
+    }
+
+    // Reset routes whose context changed but which are not truly exiting.
+    for (const resetRouteInfo of partition.reset) {
+      const route = resetRouteInfo.route;
+      if (route !== undefined && route.manager && route.bucket !== undefined) {
+        route.manager.willExit(route.bucket, {
+          transition: activeTransition,
+          isExiting: false,
+        } as any);
+      }
+    }
+
+    // Collect the enter() promises from all entering and context-updating routes.
+    // These were fired during resolveViaManager and stored on each bucket.
+    // Swallow rejections with .catch: a rejected enterPromise means the transition
+    // was already aborted and handled via transitionDidError. If we let it propagate
+    // here it fires the global RSVP unhandled rejection handler on subsequent
+    // transitions that include the same route in their partition.entered.
+    const enteringRouteInfos = [...partition.entered, ...partition.updatedContext];
+    const enterPromises = enteringRouteInfos.map((routeInfo) => {
+      const p = routeInfo.enterPromise ?? RSVPPromise.resolve(undefined);
+      return p.catch(() => undefined);
+    });
+
+    // Keep the transition marked as active until the enter promises resolve.
+    // Without this, a click during the data-loading phase (after getInvokable
+    // resolved but before enter() resolved) would not see an active transition
+    // to abort, so the in-flight enter() would settle and stomp the new
+    // transition's render state with stale data.
+
+    // Once all data loading is done, fire the post-data lifecycle hooks.
+    // The returned promise becomes part of the transition's promise chain
+    // (see Router.transitionByIntent in router_js), so an error here rejects
+    // the transition and propagates out to e.g. application.visit's caller.
+    return RSVPPromise.all(enterPromises).then(() => {
+      activeTransition.isActive = false;
+      // Only clear activeTransition if it is still us. A click during the
+      // enter-loading phase will have replaced microlib.activeTransition with
+      // a newer transition (and aborted us via redirect()); we must not clear
+      // that newer transition here.
+      if (microlib.activeTransition === activeTransition) {
+        microlib.activeTransition = undefined;
+      }
+
+      // Guard against the app being destroyed between when the transition
+      // settled and when this async callback fires (e.g. during test teardown).
+      if (this.isDestroying || this.isDestroyed) {
+        return;
+      }
+      if (activeTransition.isAborted) {
+        return;
+      }
+
+      try {
+        // Fire didEnter on routes that newly entered, in parent-to-child order.
+        for (const enteredRouteInfo of partition.entered) {
+          const route = enteredRouteInfo.route;
+          if (route !== undefined) {
+            route.manager.didEnter(route.bucket, {
+              transition: activeTransition,
+              to: enteredRouteInfo,
+              enter: true,
+            } as any);
+          }
+        }
+
+        // Fire didEnter on routes whose context changed (same route, new model).
+        for (const updatedRouteInfo of partition.updatedContext) {
+          const route = updatedRouteInfo.route;
+          if (route !== undefined) {
+            route.manager.didEnter(route.bucket, {
+              transition: activeTransition,
+              to: updatedRouteInfo,
+              enter: false,
+            } as any);
+          }
+        }
+      } catch (error) {
+        // setup()/activate()/setupController() inside didEnter can throw. Route
+        // through the existing transitionDidError path so the error bubbles to
+        // route action handlers (and default error handler that searches for an
+        // error substate) the same way as errors from the resolution chain.
+        // Use a synthetic TransitionError shape with wasAborted=false so the
+        // error route lookup runs. The returned value is what should reject
+        // the transition's promise. Throwing it here makes onTransitionSettled's
+        // promise reject and propagates through application.visit's caller.
+        const errorRoute = newState.routeInfos[newState.routeInfos.length - 1]?.route;
+        const reason = microlib.transitionDidError(
+          { error, route: errorRoute, wasAborted: false } as any,
+          activeTransition as any
+        );
+        throw reason;
+      }
+
+      // Fire didExit on routes that left the hierarchy.
+      for (const exitedRouteInfo of partition.exited) {
+        const route = exitedRouteInfo.route;
+        if (route !== undefined) {
+          route.manager.didExit(route.bucket, { transition: activeTransition } as any);
+        }
+      }
+
+      // The transition is fully settled. Replace currentRouteInfos with the
+      // real final route list from newState. During the transition, currentRouteInfos
+      // was updated incrementally (onRouteInvokableReady, onIntermediateTransition)
+      // and may still contain loading/error substate routes. Replacing it here
+      // ensures _setOutlets renders the real routes, not stale intermediates.
+      // This must happen before finalizeQueryParamChange so that QP finalization
+      // and _setOutlets both operate on the correct, authoritative route list.
+      // We copy the array (not alias) because subsequent transitions mutate
+      // currentRouteInfos via onRouteInvokableReady, and aliasing would mutate
+      // microlib.state.routeInfos (the settled state) too, corrupting the
+      // baseline used by partitionRoutes for the next transition.
+      microlib.currentRouteInfos = newState.routeInfos.slice();
+
+      // Finalize query params after didEnter so that controllers exist.
+      // Route.finalizeQueryParamChange accesses route.controller, which is
+      // created inside didEnter (via setup/setupController). Calling this
+      // before didEnter causes "cannot set _qpDelegate on undefined".
+      microlib.state!.queryParams = microlib.finalizeQueryParamChange(
+        microlib.currentRouteInfos!,
+        newState.queryParams,
+        activeTransition
+      );
+
+      // Update the URL now that query params are finalized.
+      microlib._updateURL(activeTransition, newState);
+
+      // Re-render now that currentRouteInfos is authoritative.
+      once(this as any, '_setOutlets');
+
+      microlib.triggerEvent(microlib.currentRouteInfos!, true, 'didTransition', []);
+      microlib.didTransition(microlib.currentRouteInfos!);
+      microlib.toInfos(activeTransition, newState.routeInfos, true);
+      microlib.routeDidChange(activeTransition);
+    });
+  }
+
   _setOutlets() {
     // This is triggered async during Route#willDestroy.
     // If the router is also being destroyed we do not want to
@@ -602,6 +940,19 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
       return;
     }
 
+    // Skip rendering when the application instance was booted with
+    // shouldRender: false. The instance still goes through the full transition
+    // lifecycle (routes resolve, controllers initialise, models load) but no
+    // DOM is created. Used by application.visit() in non-rendering scenarios
+    // such as fastboot prefetching or unit-testing route logic.
+    let owner = getOwner(this);
+    let environment = owner?.lookup('-environment:main') as
+      | { options?: { shouldRender?: boolean } }
+      | undefined;
+    if (environment?.options?.shouldRender === false) {
+      return;
+    }
+
     let routeInfos = this._routerMicrolib.currentRouteInfos;
     if (!routeInfos) {
       return;
@@ -611,32 +962,50 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     let parent: OutletState | null = null;
 
     for (let routeInfo of routeInfos) {
-      let route = routeInfo.route!;
-      let render = getRenderState(route);
-
-      if (render) {
-        let state: OutletState = {
-          render,
-          outlets: {
-            main: undefined,
-          },
-        };
-
-        if (parent) {
-          parent.outlets.main = state;
-        } else {
-          root = state;
-        }
-
-        parent = state;
+      let route = routeInfo.route;
+      assert('RouteInfo should have route', route);
+
+      let bucket = route.bucket;
+      let invokable = routeInfo.invokable ?? bucket?.invokable;
+
+      assert('Expected route to have an invokable template or component', invokable !== undefined);
+
+      let routeOwner = getInternalOwner(route);
+
+      assert('Route is unexpectedly missing an owner', routeOwner);
+
+      // Module-stable wrapper component returned from the manager. The outlet
+      // helper curries the invokable + routeInfo onto this at render time.
+      // RenderState.template is intentionally not set here: the outlet helper's
+      // wrapper-driven path reads `render.invokable` directly. The legacy
+      // `template` field on RenderState only services consumers that build
+      // OutletState manually (e.g. older @ember/test-helpers, liquid-fire).
+      let wrapper = route.manager.getRouteWrapper(route.bucket);
+
+      let render = {
+        owner: routeOwner,
+        name: route.routeName,
+        wrapper,
+        invokable,
+        context: routeInfo.context,
+        // context: routeInfo.enterPromise,
+        bucket,
+      };
+
+      let state: OutletState = {
+        render,
+        outlets: {
+          main: undefined,
+        },
+      };
+
+      if (parent) {
+        parent.outlets.main = state;
       } else {
-        // It used to be that we would create a stub entry and keep traversing,
-        // but I don't think that is necessary anymore – if a parent route did
-        // not render, then the child routes have nowhere to render into these
-        // days. That wasn't always the case since in the past any route can
-        // render into any other route's outlets.
-        break;
+        root = state;
       }
+
+      parent = state;
     }
 
     // when a transitionTo happens after the validation phase
@@ -1318,43 +1687,9 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     }
   }
 
-  _scheduleLoadingEvent(transition: Transition, originRoute: Route) {
-    this._cancelSlowTransitionTimer();
-    this._slowTransitionTimer = scheduleOnce(
-      'routerTransitions',
-      this,
-      this._handleSlowTransition,
-      transition,
-      originRoute
-    );
-  }
-
   currentState: null | RouterState = null;
   targetState: null | RouterState = null;
 
-  _handleSlowTransition(transition: Transition, originRoute: Route) {
-    if (!this._routerMicrolib.activeTransition) {
-      // Don't fire an event if we've since moved on from
-      // the transition that put us in a loading state.
-      return;
-    }
-    let targetState = new RouterState(
-      this,
-      this._routerMicrolib,
-      this._routerMicrolib.activeTransition[STATE_SYMBOL]!
-    );
-    this.set('targetState', targetState);
-
-    transition.trigger(true, 'loading', transition, originRoute);
-  }
-
-  _cancelSlowTransitionTimer() {
-    if (this._slowTransitionTimer) {
-      cancel(this._slowTransitionTimer);
-    }
-    this._slowTransitionTimer = null;
-  }
-
   // These three helper functions are used to ensure errors aren't
   // re-raised if they're handled in a route's error action.
   _markErrorAsHandled(error: Error) {
@@ -1520,15 +1855,6 @@ function forEachRouteAbove(
 // These get invoked when an action bubbles above ApplicationRoute
 // and are not meant to be overridable.
 let defaultActionHandlers = {
-  willResolveModel<R extends Route>(
-    this: EmberRouter,
-    _routeInfos: InternalRouteInfo<Route>[],
-    transition: Transition,
-    originRoute: R
-  ) {
-    this._scheduleLoadingEvent(transition, originRoute);
-  },
-
   // Attempt to find an appropriate error route or substate to enter.
   error(
     this: EmberRouter,
@@ -1566,36 +1892,6 @@ let defaultActionHandlers = {
 
     logError(error, `Error while processing route: ${transition.targetName}`);
   },
-
-  // Attempt to find an appropriate loading route or substate to enter.
-  loading(this: EmberRouter, routeInfos: InternalRouteInfo<Route>[], transition: Transition) {
-    let router = this;
-
-    let routeInfoWithSlowLoading = routeInfos[routeInfos.length - 1];
-
-    forEachRouteAbove(routeInfos, (route, routeInfo) => {
-      // We don't check the leaf most routeInfos since that would
-      // technically be below where we're at in the route hierarchy.
-      if (routeInfo !== routeInfoWithSlowLoading) {
-        // Check for the existence of a 'loading' route.
-        let loadingRouteName = findRouteStateName(route, 'loading');
-        if (loadingRouteName) {
-          router.intermediateTransitionTo(loadingRouteName);
-          return false;
-        }
-      }
-
-      // Check for loading substate
-      let loadingSubstateName = findRouteSubstateName(route, 'loading');
-      if (loadingSubstateName) {
-        router.intermediateTransitionTo(loadingSubstateName);
-        return false;
-      }
-
-      // Don't bubble above pivot route.
-      return (transition.pivotHandler as any) !== route;
-    });
-  },
 };
 
 function logError(_error: any, initialMessage: string) {
diff --git a/packages/@glimmer/runtime/index.ts b/packages/@glimmer/runtime/index.ts
index 72e95d58c30..be76ca6f919 100644
--- a/packages/@glimmer/runtime/index.ts
+++ b/packages/@glimmer/runtime/index.ts
@@ -12,7 +12,7 @@ export {
   templateOnlyComponent,
   TemplateOnlyComponentManager,
 } from './lib/component/template-only';
-export { CurriedValue, curry } from './lib/curried-value';
+export { CurriedValue, curry, isCurriedValue } from './lib/curried-value';
 export {
   DOMChanges,
   DOMTreeConstruction,
diff --git a/packages/router_js/lib/route-info.ts b/packages/router_js/lib/route-info.ts
index ecd4875b1a8..f89b708548d 100644
--- a/packages/router_js/lib/route-info.ts
+++ b/packages/router_js/lib/route-info.ts
@@ -5,9 +5,11 @@ import type { SerializerFunc } from './router';
 import type Router from './router';
 import type { PublicTransition as Transition } from './transition';
 import type InternalTransition from './transition';
-import { isTransition, PARAMS_SYMBOL, prepareResult, QUERY_PARAMS_SYMBOL } from './transition';
+import { isTransition, PARAMS_SYMBOL, QUERY_PARAMS_SYMBOL, STATE_SYMBOL } from './transition';
 import { isParam, isPromise, merge } from './utils';
 import { throwIfAborted } from './transition-aborted-error';
+import type { RouteManager } from '@ember/-internals/routing/route-managers/route-manager';
+import type { RouteStateBucket } from '@ember/-internals/routing/route-managers/utils';
 
 export type IModel = {} & {
   id?: string | number;
@@ -16,6 +18,11 @@ export type IModel = {} & {
 export type ModelFor<T> = T extends Route<infer V> ? V : never;
 
 export interface Route<T = unknown> {
+  // --- Route Manager fields (optional during migration) ---
+  manager: RouteManager<RouteStateBucket>;
+  bucket: RouteStateBucket;
+
+  // --- Classic Route fields (removed once all call sites migrate) ---
   inaccessibleByURL?: boolean;
   routeName: string;
   _internalName: string;
@@ -224,6 +231,8 @@ export default class InternalRouteInfo<R extends Route> {
   declare queryParams?: Dict<unknown>;
   declare context?: ModelFor<R> | PromiseLike<ModelFor<R>> | undefined;
   isResolved = false;
+  invokable?: object = undefined;
+  enterPromise?: globalThis.Promise<unknown> = undefined;
 
   constructor(router: Router<R>, name: string, paramNames: string[], route?: R) {
     this.name = name;
@@ -242,21 +251,120 @@ export default class InternalRouteInfo<R extends Route> {
     return this.params || {};
   }
 
-  resolve(transition: InternalTransition<R>): Promise<ResolvedRouteInfo<R>> {
+  resolve(transition: InternalTransition<R>): Promise<this> {
+    if (this.isResolved) {
+      // Fast path for re-entered routes. When named-transition-intent reuses this
+      // routeInfo as oldHandlerInfo on a subsequent transition, we skip the full
+      // resolveViaManager pass (no willEnter, no enter()) and just stash the
+      // already-resolved context onto the new transition so downstream consumers
+      // (e.g. modelFor()) see it. Mirrors what ResolvedRouteInfo.resolve does on
+      // becomeResolved-produced instances, without needing to build one.
+      if (transition && transition.resolvedModels) {
+        transition.resolvedModels[this.name] = this.context as ModelFor<R> | undefined;
+      }
+      return Promise.resolve(this);
+    }
+
     return Promise.resolve(this.routePromise)
       .then((route: Route) => {
         throwIfAborted(transition);
         return route;
       })
-      .then(() => this.runBeforeModelHook(transition))
-      .then(() => throwIfAborted(transition))
-      .then(() => this.getModel(transition))
-      .then((resolvedModel) => {
-        throwIfAborted(transition);
-        return resolvedModel;
-      })
-      .then((resolvedModel) => this.runAfterModelHook(transition, resolvedModel))
-      .then((resolvedModel) => this.becomeResolved(transition, resolvedModel));
+      .then((route) => {
+        return this.resolveViaManager(route.manager, route.bucket, transition);
+      });
+  }
+
+  /**
+    Manager-driven resolve path. Calls willEnter and enter() first, then getInvokable()
+    independently. enter() is fired and its promise stored on the bucket immediately,
+    but we do not await it here. resolve() settles as soon as getInvokable() resolves,
+    which allows the router to update currentRouteInfos and trigger rendering before
+    the route's data loading has finished. The enter() promise is awaited later by
+    EmberRouter after all getInvokable() calls in the transition have resolved.
+  */
+  private resolveViaManager(
+    manager: RouteManager<RouteStateBucket>,
+    bucket: RouteStateBucket,
+    transition: InternalTransition<R>
+  ): Promise<this> {
+    // Build the navigation args object once and share it between willEnter and enter.
+    // getAncestorPromise looks up the matching routeInfo on the transition by name
+    // and resolves with that ancestor's context once its enterPromise has settled.
+    // Sequential resolution guarantees that any ancestor's enterPromise is already
+    // set by the time a descendant's enter() runs. When called without an argument,
+    // it defaults to the immediate parent of the route currently being resolved.
+    const navigationArgs = {
+      transition,
+      to: this as unknown as RouteInfo, // will need to rethink this
+      cancel() {
+        transition.abort();
+      },
+      signal: transition.isTransition ? transition.signal : undefined,
+      getAncestorPromise: (ancestorRouteInfo: RouteInfo) => {
+        const allRouteInfos = transition[STATE_SYMBOL]?.routeInfos ?? [];
+        let matched = allRouteInfos.find((ri) => ri?.name === ancestorRouteInfo.name);
+
+        if (!matched) return Promise.resolve(undefined);
+        const ancestorEnterPromise = matched.enterPromise ?? Promise.resolve(undefined);
+        return ancestorEnterPromise.then(() => matched!.context);
+      },
+    };
+
+    // willEnter fires synchronously. For the classic manager this is where loading
+    // substate detection happens, so it must run before getInvokable() is called
+    // and before any rendering occurs.
+    manager.willEnter(bucket, navigationArgs);
+
+    // Fire enter() and immediately store the returned promise on the routeInfo.
+    // We do not await it here. Storing it now, before getInvokable() runs, ensures
+    // that by the time a child route's enter() runs, this ancestor's enterPromise
+    // is already set and can be retrieved via getAncestorPromise.
+    const enterPromise = manager.enter(bucket, navigationArgs);
+    this.enterPromise = enterPromise;
+
+    // We pipe the resolved enter() value onto this routeInfo's context as soon
+    // as enter() resolves. Doing this on its own promise chain (rather than in
+    // getInvokable's .then) means the context is available for ancestor lookups
+    // even when the manager's getInvokable does not await enterPromise (e.g.
+    // pioneer-style render-immediately managers).
+    enterPromise.then(
+      (resolvedContext) => {
+        if (transition.isAborted) {
+          return;
+        }
+        this.context = resolvedContext as ModelFor<R> | undefined;
+        // Notify the router so it can re-render outlets that depend on this
+        // routeInfo.context. Required for managers whose getInvokable returns
+        // before enter() resolves (otherwise the @model arg wired through the
+        // outlet helper stays at its initial undefined value until the whole
+        // transition settles).
+        this.router.onRouteContextSettled?.(this as unknown as InternalRouteInfo<R>);
+      },
+      () => {
+        // Swallow rejections here; transition-level error handling reports them.
+      }
+    );
+
+    // getInvokable() resolves as soon as the component definition is available.
+    // The manager decides whether to await enterPromise internally. We pass it
+    // along so the manager has the option without us forcing the wait.
+    return manager.getInvokable(bucket, enterPromise).then((invokable) => {
+      throwIfAborted(transition);
+      this.invokable = invokable;
+      this.isResolved = true;
+
+      // Compute and stash params for URL generation. Mirrors becomeResolved.
+      // Without this, _updateURL fails for routes with dynamic segments because
+      // the recognizer cannot find the param values in routeInfo.params.
+      const resolvedContext = this.context as ModelFor<R> | undefined;
+      this.params = this.serialize(resolvedContext);
+      this.stashResolvedModel(transition, resolvedContext);
+      transition[PARAMS_SYMBOL] = transition[PARAMS_SYMBOL] || {};
+      transition[PARAMS_SYMBOL][this.name] = this.params;
+
+      return this;
+    }) as unknown as Promise<this>;
   }
 
   becomeResolved(
@@ -289,6 +397,9 @@ export default class InternalRouteInfo<R extends Route> {
       context
     );
 
+    // Carry the invokable (from getInvokable() during resolve) to the resolved info
+    resolved.invokable = this.invokable;
+
     if (cached !== undefined) {
       // SAFETY: This is potentially a bit risker, but for what we're doing, it should be ok.
       ROUTE_INFOS.set(resolved as unknown as InternalRouteInfo<Route>, cached);
@@ -355,53 +466,6 @@ export default class InternalRouteInfo<R extends Route> {
     return (this.route = route);
   }
 
-  private runBeforeModelHook(transition: InternalTransition<R>) {
-    if (transition.trigger) {
-      transition.trigger(true, 'willResolveModel', transition, this.route);
-    }
-
-    let result;
-    if (this.route) {
-      if (this.route.beforeModel !== undefined) {
-        result = this.route.beforeModel(transition);
-      }
-    }
-
-    if (isTransition(result)) {
-      result = null;
-    }
-
-    return Promise.resolve(result);
-  }
-
-  private runAfterModelHook(
-    transition: InternalTransition<R>,
-    resolvedModel?: ModelFor<R> | null
-  ): Promise<ModelFor<R>> {
-    // Stash the resolved model on the payload.
-    // This makes it possible for users to swap out
-    // the resolved model in afterModel.
-    let name = this.name;
-    this.stashResolvedModel(transition, resolvedModel!);
-
-    let result;
-    if (this.route !== undefined) {
-      if (this.route.afterModel !== undefined) {
-        result = this.route.afterModel(resolvedModel!, transition);
-      }
-    }
-
-    result = prepareResult(result);
-
-    return Promise.resolve(result).then(() => {
-      // Ignore the fulfilled value returned from afterModel.
-      // Return the value stashed in resolvedModels, which
-      // might have been swapped out in afterModel.
-      // SAFTEY: We expect this to be of type T, though typing it as such is challenging.
-      return transition.resolvedModels[name]! as unknown as ModelFor<R>;
-    });
-  }
-
   private stashResolvedModel(
     transition: InternalTransition<R>,
     resolvedModel: ModelFor<R> | undefined
diff --git a/packages/router_js/lib/router.ts b/packages/router_js/lib/router.ts
index 0dd1300ae8c..452c336bd92 100644
--- a/packages/router_js/lib/router.ts
+++ b/packages/router_js/lib/router.ts
@@ -64,6 +64,50 @@ export default abstract class Router<R extends Route> {
   abstract routeDidChange(transition: Transition): void;
   abstract transitionDidError(error: TransitionError, transition: Transition): Transition | Error;
 
+  // Called once all getInvokable() calls in the transition have resolved, meaning the
+  // outlet tree has already been updated incrementally and enter() promises are in flight
+  // on each bucket. EmberRouter overrides this to run exit/enter lifecycle hooks, update
+  // the URL, await all enter() promises, then fire didEnter/didExit/routeDidChange.
+  // The default is a no-op so that test routers that do not care about rendering work
+  // without changes.
+  onTransitionSettled(
+    _transition: InternalTransition<R>,
+    _newState: TransitionState<R>
+  ): void | Promise<void> {}
+
+  // Called once per route, in parent-to-child order, as each getInvokable() resolves
+  // during a normal transition. EmberRouter overrides this to push the route into
+  // currentRouteInfos and schedule _setOutlets so rendering happens incrementally
+  // rather than waiting for the entire transition chain to finish.
+  // The routeIndex is the position of this route in the transition's resolved hierarchy,
+  // allowing EmberRouter to write directly to the correct slot in currentRouteInfos
+  // and replace any intermediate (loading/error substate) entry that was placed there.
+  // Default is a no-op so test routers work without changes.
+  onRouteInvokableReady(
+    _routeInfo: InternalRouteInfo<R>,
+    _transition: InternalTransition<R>,
+    _routeIndex: number
+  ): void {}
+
+  // Called when intermediateTransitionTo fires, for example from ClassicRouteManager
+  // willEnter when it detects a loading substate. EmberRouter overrides this to splice
+  // the intermediate route into currentRouteInfos and schedule _setOutlets, without
+  // disturbing the ancestor routes that are already rendering correctly.
+  // Default is a no-op so test routers work without changes.
+  onIntermediateTransition(
+    _newState: TransitionState<R>,
+    _transition: InternalTransition<R>
+  ): void {}
+
+  // Called when an individual route's enterPromise settles and routeInfo.context
+  // has been updated with the resolved value. EmberRouter overrides this to
+  // schedule _setOutlets so the @model arg downstream of the outlet helper
+  // sees the new context. Without this, routes whose getInvokable resolves
+  // before enter() (pioneer-style render-immediate managers) would render with
+  // a stale undefined model until the entire transition settles.
+  // Default is a no-op so test routers work without changes.
+  onRouteContextSettled(_routeInfo: InternalRouteInfo<R>): void {}
+
   /**
     The main entry point into the router. The API is essentially
     the same as the `map` method in `route-recognizer`.
@@ -224,12 +268,12 @@ export default abstract class Router<R extends Route> {
     }
 
     if (isIntermediate) {
-      let transition = new InternalTransition(this, undefined, newState);
-      transition.isIntermediate = true;
-      this.toReadOnlyInfos(transition, newState);
-      this.setupContexts(newState, transition);
+      let intermediateTransition = new InternalTransition(this, undefined, newState);
+      intermediateTransition.isIntermediate = true;
+      this.toReadOnlyInfos(intermediateTransition, newState);
+      this.onIntermediateTransition(newState, intermediateTransition);
 
-      this.routeWillChange(transition);
+      this.routeWillChange(intermediateTransition);
       return this.activeTransition!;
     }
 
@@ -255,15 +299,18 @@ export default abstract class Router<R extends Route> {
     }
     this.activeTransition = newTransition;
 
-    // Transition promises by default resolve with resolved state.
-    // For our purposes, swap out the promise to resolve
-    // after the transition has been finalized.
+    // Once all getInvokable() calls have resolved (the TransitionState promise settles),
+    // hand off to EmberRouter to run exit/enter lifecycle, update the URL, and await
+    // all enter() promises before firing didEnter/didExit/routeDidChange. Returning
+    // the promise here so an error inside onTransitionSettled (e.g. setup() throwing
+    // inside didEnter) rejects the transition's outer promise, which application.visit
+    // and handleURL callers chain off of.
     newTransition.promise = newTransition.promise!.then(
-      (result: TransitionState<R>) => {
-        return this.finalizeTransition(newTransition, result);
+      (newState: TransitionState<R>) => {
+        return this.onTransitionSettled(newTransition, newState);
       },
       null,
-      promiseLabel('Settle transition promise when transition is finalized')
+      promiseLabel('Settle transition promise when all getInvokable calls have resolved')
     );
 
     if (!wasTransitioning) {
@@ -336,159 +383,6 @@ export default abstract class Router<R extends Route> {
   /**
   @private
 
-  Updates the URL (if necessary) and calls `setupContexts`
-  to update the router's array of `currentRouteInfos`.
- */
-  private finalizeTransition(
-    transition: InternalTransition<R>,
-    newState: TransitionState<R>
-  ): R | Promise<any> {
-    try {
-      log(
-        transition.router,
-        transition.sequence,
-        'Resolved all models on destination route; finalizing transition.'
-      );
-
-      let routeInfos = newState.routeInfos;
-
-      // Run all the necessary enter/setup/exit hooks
-      this.setupContexts(newState, transition);
-
-      // Check if a redirect occurred in enter/setup
-      if (transition.isAborted) {
-        // TODO: cleaner way? distinguish b/w targetRouteInfos?
-        this.state!.routeInfos = this.currentRouteInfos!;
-        return Promise.reject(logAbort(transition));
-      }
-
-      this._updateURL(transition, newState);
-
-      transition.isActive = false;
-      this.activeTransition = undefined;
-
-      this.triggerEvent(this.currentRouteInfos!, true, 'didTransition', []);
-      this.didTransition(this.currentRouteInfos!);
-      this.toInfos(transition, newState.routeInfos, true);
-      this.routeDidChange(transition);
-
-      log(this, transition.sequence, 'TRANSITION COMPLETE.');
-
-      // Resolve with the final route.
-      return routeInfos[routeInfos.length - 1]!.route!;
-    } catch (e) {
-      if (!isTransitionAborted(e)) {
-        let infos = transition[STATE_SYMBOL]!.routeInfos;
-        transition.trigger(true, 'error', e, transition, infos[infos.length - 1]!.route);
-        transition.abort();
-      }
-
-      throw e;
-    }
-  }
-
-  /**
-  @private
-
-  Takes an Array of `RouteInfo`s, figures out which ones are
-  exiting, entering, or changing contexts, and calls the
-  proper route hooks.
-
-  For example, consider the following tree of routes. Each route is
-  followed by the URL segment it handles.
-
-  ```
-  |~index ("/")
-  | |~posts ("/posts")
-  | | |-showPost ("/:id")
-  | | |-newPost ("/new")
-  | | |-editPost ("/edit")
-  | |~about ("/about/:id")
-  ```
-
-  Consider the following transitions:
-
-  1. A URL transition to `/posts/1`.
-     1. Triggers the `*model` callbacks on the
-        `index`, `posts`, and `showPost` routes
-     2. Triggers the `enter` callback on the same
-     3. Triggers the `setup` callback on the same
-  2. A direct transition to `newPost`
-     1. Triggers the `exit` callback on `showPost`
-     2. Triggers the `enter` callback on `newPost`
-     3. Triggers the `setup` callback on `newPost`
-  3. A direct transition to `about` with a specified
-     context object
-     1. Triggers the `exit` callback on `newPost`
-        and `posts`
-     2. Triggers the `serialize` callback on `about`
-     3. Triggers the `enter` callback on `about`
-     4. Triggers the `setup` callback on `about`
-
-  @param {Router} transition
-  @param {TransitionState} newState
-*/
-  private setupContexts(newState: TransitionState<R>, transition?: InternalTransition<R>) {
-    let partition = this.partitionRoutes(this.state!, newState);
-    let i, l, route;
-
-    for (i = 0, l = partition.exited.length; i < l; i++) {
-      route = partition.exited[i]!.route;
-      delete route!.context;
-
-      if (route !== undefined) {
-        if (route._internalReset !== undefined) {
-          route._internalReset(true, transition);
-        }
-
-        if (route.exit !== undefined) {
-          route.exit(transition);
-        }
-      }
-    }
-
-    let oldState = (this.oldState = this.state);
-    this.state = newState;
-    let currentRouteInfos = (this.currentRouteInfos = partition.unchanged.slice());
-
-    try {
-      for (i = 0, l = partition.reset.length; i < l; i++) {
-        route = partition.reset[i]!.route;
-        if (route !== undefined) {
-          if (route._internalReset !== undefined) {
-            route._internalReset(false, transition);
-          }
-        }
-      }
-
-      for (i = 0, l = partition.updatedContext.length; i < l; i++) {
-        this.routeEnteredOrUpdated(
-          currentRouteInfos,
-          partition.updatedContext[i]!,
-          false,
-          transition!
-        );
-      }
-
-      for (i = 0, l = partition.entered.length; i < l; i++) {
-        this.routeEnteredOrUpdated(currentRouteInfos, partition.entered[i]!, true, transition!);
-      }
-    } catch (e) {
-      this.state = oldState;
-      this.currentRouteInfos = oldState!.routeInfos;
-      throw e;
-    }
-
-    this.state.queryParams = this.finalizeQueryParamChange(
-      currentRouteInfos,
-      newState.queryParams,
-      transition!
-    );
-  }
-
-  /**
-  @private
-
   Fires queryParamsDidChange event
 */
   private fireQueryParamDidChange(newState: TransitionState<R>, queryParamChangelist: ChangeList) {
@@ -510,56 +404,6 @@ export default abstract class Router<R extends Route> {
   /**
   @private
 
-  Helper method used by setupContexts. Handles errors or redirects
-  that may happen in enter/setup.
-*/
-  private routeEnteredOrUpdated(
-    currentRouteInfos: InternalRouteInfo<R>[],
-    routeInfo: InternalRouteInfo<R>,
-    enter: boolean,
-    transition?: InternalTransition<R>
-  ) {
-    let route = routeInfo.route,
-      context = routeInfo.context;
-
-    function _routeEnteredOrUpdated(route: R) {
-      if (enter) {
-        if (route.enter !== undefined) {
-          route.enter(transition!);
-        }
-      }
-
-      throwIfAborted(transition);
-
-      route.context = context as Awaited<typeof context>;
-
-      if (route.contextDidChange !== undefined) {
-        route.contextDidChange();
-      }
-
-      if (route.setup !== undefined) {
-        route.setup(context!, transition!);
-      }
-
-      throwIfAborted(transition);
-
-      currentRouteInfos.push(routeInfo);
-      return route;
-    }
-
-    // If the route doesn't exist, it means we haven't resolved the route promise yet
-    if (route === undefined) {
-      routeInfo.routePromise = routeInfo.routePromise.then(_routeEnteredOrUpdated);
-    } else {
-      _routeEnteredOrUpdated(route);
-    }
-
-    return true;
-  }
-
-  /**
-  @private
-
   This function is called when transitioning from one URL to
   another to determine which routes are no longer active,
   which routes are newly active, and which routes remain
@@ -598,7 +442,9 @@ export default abstract class Router<R extends Route> {
 
   @return {Partition}
 */
-  private partitionRoutes(oldState: TransitionState<R>, newState: TransitionState<R>) {
+  // Public so EmberRouter can call it via _routerMicrolib when orchestrating
+  // onRouteInvokableReady and onIntermediateTransition. Previously private.
+  partitionRoutes(oldState: TransitionState<R>, newState: TransitionState<R>) {
     let oldRouteInfos = oldState.routeInfos;
     let newRouteInfos = newState.routeInfos;
 
@@ -646,7 +492,8 @@ export default abstract class Router<R extends Route> {
     return routes;
   }
 
-  private _updateURL(transition: OpaqueTransition, state: TransitionState<R>) {
+  // Public so EmberRouter can call it via _routerMicrolib after awaiting enter() promises.
+  _updateURL(transition: OpaqueTransition, state: TransitionState<R>) {
     let urlMethod: string | null = transition.urlMethod;
 
     if (!urlMethod) {
@@ -709,7 +556,8 @@ export default abstract class Router<R extends Route> {
     }
   }
 
-  private finalizeQueryParamChange(
+  // Public so EmberRouter can call it via _routerMicrolib as part of transition settlement.
+  finalizeQueryParamChange(
     resolvedHandlers: InternalRouteInfo<R>[],
     newQueryParams: Dict<unknown>,
     transition: OpaqueTransition
@@ -940,9 +788,16 @@ export default abstract class Router<R extends Route> {
       queryParams = partitionedArgs[1];
 
     // Construct a TransitionIntent with the provided params
-    // and apply it to the present state of the router.
+    // and apply it to the present state of the router. During an active
+    // transition (e.g. while a loading substate is rendering), the active
+    // transition's state holds the partially resolved route hierarchy and
+    // is the correct baseline for URL generation. Without this, link-to
+    // helpers rendered inside a loading substate fail to compute their href
+    // because microlib.state has not been updated yet (state assignment only
+    // happens in onTransitionSettled).
+    let baseState = (this.activeTransition && this.activeTransition[STATE_SYMBOL]) || this.state!;
     let intent = new NamedTransitionIntent(this, routeName, undefined, suppliedParams);
-    let state = intent.applyToState(this.state!, false);
+    let state = intent.applyToState(baseState, false);
 
     let params: Params = {};
     for (let i = 0, len = state.routeInfos.length; i < len; ++i) {
diff --git a/packages/router_js/lib/transition-state.ts b/packages/router_js/lib/transition-state.ts
index e10c7c7361c..2ffae2a0f33 100644
--- a/packages/router_js/lib/transition-state.ts
+++ b/packages/router_js/lib/transition-state.ts
@@ -1,6 +1,6 @@
 import { Promise } from 'rsvp';
 import type { Dict } from './core';
-import type { Route, ResolvedRouteInfo } from './route-info';
+import type { Route } from './route-info';
 import type InternalRouteInfo from './route-info';
 import type Transition from './transition';
 import { forEach, promiseLabel } from './utils';
@@ -36,15 +36,20 @@ function resolveOneRouteInfo<R extends Route>(
   transition: Transition<R>
 ): void | Promise<void> {
   if (transition.resolveIndex === currentState.routeInfos.length) {
-    // This is is the only possible
-    // fulfill value of TransitionState#resolve
+    // All routes in this transition have had their getInvokable() resolved.
+    // This is the only fulfill value of TransitionState#resolve.
     return;
   }
 
   let routeInfo = currentState.routeInfos[transition.resolveIndex]!;
-
-  let callback = proceed.bind(null, currentState, transition) as (
-    resolvedRouteInfo: ResolvedRouteInfo<R>
+  // Capture whether the routeInfo was already resolved BEFORE this resolve
+  // pass began. When named-transition-intent reuses an oldHandlerInfo, its
+  // isResolved is already true (set on a prior transition); we use this flag
+  // to decide whether redirect should fire in proceed.
+  let wasAlreadyResolved = routeInfo.isResolved;
+
+  let callback = proceed.bind(null, currentState, transition, wasAlreadyResolved) as (
+    readyRouteInfo: InternalRouteInfo<R>
   ) => void | Promise<void>;
 
   return routeInfo.resolve(transition).then(callback, null, currentState.promiseLabel('Proceed'));
@@ -53,29 +58,33 @@ function resolveOneRouteInfo<R extends Route>(
 function proceed<R extends Route>(
   currentState: TransitionState<R>,
   transition: Transition<R>,
-  resolvedRouteInfo: ResolvedRouteInfo<R>
+  wasAlreadyResolved: boolean,
+  readyRouteInfo: InternalRouteInfo<R>
 ): void | Promise<void> {
-  let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex]!.isResolved;
-
-  // Swap the previously unresolved routeInfo with
-  // the resolved routeInfo
-  currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;
-
-  if (!wasAlreadyResolved) {
-    // Call the redirect hook. The reason we call it here
-    // vs. afterModel is so that redirects into child
-    // routes don't re-run the model hooks for this
-    // already-resolved route.
-    let { route } = resolvedRouteInfo;
-    if (route !== undefined) {
-      if (route.redirect) {
-        route.redirect(resolvedRouteInfo.context, transition);
-      }
+  const routeIndex = transition.resolveIndex;
+  currentState.routeInfos[transition.resolveIndex++] = readyRouteInfo;
+
+  // Notify the router that this route's invokable is ready. EmberRouter uses
+  // this to place the route at routeIndex in currentRouteInfos, replacing any
+  // loading/error substate that was entered for this position, and schedules
+  // _setOutlets so the outlet tree is updated before enter() finishes.
+  // Guard against fake/synthetic transitions used in tests that don't have a
+  // router reference; those transitions don't drive any rendering anyway.
+  transition.router?.onRouteInvokableReady?.(readyRouteInfo, transition, routeIndex);
+
+  // Skip redirect for intermediate transitions (loading/error substates), and
+  // for routes that were already resolved on a prior transition. Mirrors the
+  // original transition-state proceed which gated redirect on `!wasAlreadyResolved`.
+  if (!transition.isIntermediate && !wasAlreadyResolved) {
+    // Call the redirect hook now that the route's model has resolved. Calling
+    // it here, between resolution and the next route's resolution, lets a
+    // redirect into a child route skip re-running this route's model hook.
+    const route = readyRouteInfo.route;
+    if (route !== undefined && route.redirect) {
+      route.redirect(readyRouteInfo.context, transition);
     }
   }
 
-  // Proceed after ensuring that the redirect hook
-  // didn't abort this transition by transitioning elsewhere.
   throwIfAborted(transition);
 
   return resolveOneRouteInfo(currentState, transition);
diff --git a/packages/router_js/lib/transition.ts b/packages/router_js/lib/transition.ts
index b4c0e26634c..9d4cb513893 100644
--- a/packages/router_js/lib/transition.ts
+++ b/packages/router_js/lib/transition.ts
@@ -71,6 +71,11 @@ export default class Transition<R extends Route> implements Partial<Promise<R>>
   _visibleQueryParams: Dict<unknown> = {};
   isIntermediate = false;
   [REDIRECT_DESTINATION_SYMBOL]?: Transition<R>;
+  // AbortController for the navigation. Managers receive its signal via
+  // AsyncNavigationState and can pass it to fetch() etc. The signal is
+  // aborted when the transition is rolled back (cancel() or redirect()).
+  abortController = new AbortController();
+  signal: AbortSignal = this.abortController.signal;
 
   /**
     In non-production builds, this function will return the stack that this Transition was
@@ -305,6 +310,12 @@ export default class Transition<R extends Route> implements Partial<Promise<R>>
 
       this.isAborted = true;
       this.isActive = false;
+      // Abort the signal so any in-flight fetch() or other AbortSignal
+      // consumers in the manager can short-circuit. The transition's
+      // routeInfo.context writes are also gated on isAborted, so an
+      // already-running enter() that does not check the signal still
+      // cannot stomp the active transition's render state.
+      this.abortController.abort();
       this.router.activeTransition = undefined;
     }
   }
diff --git a/packages/router_js/package.json b/packages/router_js/package.json
index 68628f0ac24..b5c1ad6541d 100644
--- a/packages/router_js/package.json
+++ b/packages/router_js/package.json
@@ -8,8 +8,7 @@
   "exports": {
     ".": "./index.ts"
   },
-  "scripts": {
-  },
+  "scripts": {},
   "dependencies": {
     "@glimmer/env": "workspace:*"
   },
@@ -20,7 +19,8 @@
     "loader.js": "^4.7.0",
     "qunit": "^2.11.3",
     "route-recognizer": "^0.3.4",
-    "rsvp": "^4.8.5"
+    "rsvp": "^4.8.5",
+    "@ember/-internals": "workspace:*"
   },
   "peerDependencies": {
     "route-recognizer": "^0.3.4",
diff --git a/packages/router_js/tests/route_info_test.ts b/packages/router_js/tests/route_info_test.ts
index 31ba500e7b7..a1be70f97d0 100644
--- a/packages/router_js/tests/route_info_test.ts
+++ b/packages/router_js/tests/route_info_test.ts
@@ -54,35 +54,33 @@ QUnit.test('RouteInfo can be aborted mid-resolve', function (assert) {
     });
 });
 
-QUnit.test('RouteInfo#resolve resolves with a ResolvedRouteInfo', function (assert) {
+QUnit.test('RouteInfo#resolve resolves isResolved on the RouteInfo', function (assert) {
   assert.expect(1);
 
   let routeInfo = createHandlerInfo('stub');
   routeInfo.resolve({} as Transition).then((resolvedRouteInfo) => {
-    assert.ok(resolvedRouteInfo instanceof ResolvedRouteInfo);
+    assert.ok(resolvedRouteInfo.isResolved);
   });
 });
 
-QUnit.test('RouteInfo#resolve runs beforeModel hook on handler', function (assert) {
-  assert.expect(1);
-
+QUnit.test('RouteInfo#resolve runs beforeModel hook on handler', async function (assert) {
+  assert.expect(2);
   let transition = {} as Transition;
-
+  let beforeModelCalled = false;
   let routeInfo = createHandlerInfo('stub', {
     route: createHandler('stub', {
       beforeModel: function (currentTransition: Transition) {
+        beforeModelCalled = true;
         assert.equal(
-          transition,
           currentTransition,
-          'beforeModel was called with the payload we passed to resolve()'
+          transition,
+          'beforeModel was called with the transition passed to resolve()'
         );
       },
     }),
   });
-
-  routeInfo.resolve(transition).then(() => {
-    assert.ok(true, 'routeInfo resolved successfully');
-  });
+  await routeInfo.resolve(transition);
+  assert.true(beforeModelCalled, 'beforeModel was called');
 });
 
 QUnit.test('RouteInfo#resolve runs getModel hook', async function (assert) {
diff --git a/packages/router_js/tests/router_test.ts b/packages/router_js/tests/router_test.ts
index 2f8d320a751..77df5c18101 100644
--- a/packages/router_js/tests/router_test.ts
+++ b/packages/router_js/tests/router_test.ts
@@ -1428,14 +1428,16 @@ scenarios.forEach(function (scenario) {
       post: createHandler('post', {
         model() {
           redirected1 = true;
-          router.transitionTo('/foo/bar');
+          // The redirect aborts this transition, swallow the rejection so it
+          // does not surface as an unhandled rejection in the full test suite.
+          ignoreTransitionError(router.transitionTo('/foo/bar'));
         },
       }),
       foo: createHandler('foo', {
         model() {
           redirected1 = false;
           redirected2 = true;
-          router.transitionTo('/ok');
+          ignoreTransitionError(router.transitionTo('/ok'));
         },
       }),
       ok: createHandler('ok'),
@@ -1517,7 +1519,9 @@ scenarios.forEach(function (scenario) {
       post: createHandler('post', {
         model() {
           redirected = true;
-          router.transitionTo('/foo/bar');
+          // foo.model aborts this redirect transition, swallow the rejection
+          // so it does not surface as an unhandled rejection in the full suite.
+          ignoreTransitionError(router.transitionTo('/foo/bar'));
         },
       }),
       foo: createHandler('foo', {
@@ -1764,7 +1768,10 @@ scenarios.forEach(function (scenario) {
       post: createHandler('post', {
         model() {
           redirected = true;
-          router.transitionTo('/foo/bar');
+          // foo.model throws, errorHandled branch in transitionDidError returns
+          // the transition itself which becomes the rejection value, swallow it
+          // so it does not surface as an unhandled rejection in the full suite.
+          ignoreTransitionError(router.transitionTo('/foo/bar'));
         },
       }),
       foo: createHandler('foo', {
diff --git a/packages/router_js/tests/test_helpers.ts b/packages/router_js/tests/test_helpers.ts
index 38f0f938dca..8180a102a1e 100644
--- a/packages/router_js/tests/test_helpers.ts
+++ b/packages/router_js/tests/test_helpers.ts
@@ -7,7 +7,8 @@ import type { PublicTransition } from '../lib/transition';
 import { logAbort } from '../lib/transition';
 import type { TransitionError } from '../lib/transition-state';
 import type { UnrecognizedURLError } from '../lib/unrecognized-url-error';
-import { isTransitionAborted } from '../lib/transition-aborted-error';
+import { isTransitionAborted, throwIfAborted } from '../lib/transition-aborted-error';
+import { Promise } from 'rsvp';
 
 // A useful function to allow you to ignore transition errors in a testing context
 export async function ignoreTransitionError(transition: Transition) {
@@ -65,11 +66,192 @@ export {
   assertAbort,
 };
 
+// Minimal structural copies of the route manager types. The real interfaces
+// live in @ember/-internals/routing/route-managers/route-manager. We copy
+// them here so router_js tests stay independent of the ember-source side.
+interface RouteCapabilities {
+  classicInterop: boolean;
+}
+
+interface NavigationArgs {
+  transition: any;
+  to: any;
+  cancel: () => void;
+  signal?: AbortSignal;
+  getAncestorPromise: (routeInfo?: any) => Promise<unknown>;
+}
+
+interface RouteManagerLike {
+  capabilities: RouteCapabilities;
+  createRoute(definition: any, args: { name: string }): TestRouteBucket;
+  getDestroyable(bucket: TestRouteBucket): unknown;
+  willEnter(bucket: TestRouteBucket, args: NavigationArgs): void;
+  enter(bucket: TestRouteBucket, args: NavigationArgs): Promise<unknown>;
+  didEnter(bucket: TestRouteBucket, args: NavigationArgs & { enter?: boolean }): void;
+  willExit(bucket: TestRouteBucket, args: NavigationArgs & { isExiting?: boolean }): void;
+  exit(bucket: TestRouteBucket, args: NavigationArgs): void;
+  didExit(bucket: TestRouteBucket, args: NavigationArgs): void;
+  getRouteWrapper(bucket: TestRouteBucket): object;
+  getInvokable(
+    bucket: TestRouteBucket,
+    enterPromise: Promise<unknown>
+  ): Promise<object | undefined>;
+}
+
+// Bucket carries module-stable per-route state. Mirrors ClassicRouteBucket
+// without ember-side decorators. Per-render data (context, enterPromise) lives
+// on the routeInfo on this branch.
+class TestRouteBucket {
+  route: Route;
+  args: { name: string };
+  invokable: object | undefined = undefined;
+
+  constructor(route: Route, args: { name: string }) {
+    this.route = route;
+    this.args = args;
+  }
+}
+
+// In-test route manager that runs the classic beforeModel/model/afterModel
+// chain without depending on EmberObject, owners, or the glimmer module graph.
+// router_js tests expect plain object handlers with model/setup/etc. hooks,
+// so this manager dispatches directly to those hooks.
+class TestRouteManager implements RouteManagerLike {
+  capabilities: RouteCapabilities = { classicInterop: true };
+
+  createRoute(handler: Route, args: { name: string }): TestRouteBucket {
+    const bucket = new TestRouteBucket(handler, args);
+    handler.bucket = bucket as any;
+    handler.manager = this as any;
+    return bucket;
+  }
+
+  getDestroyable(bucket: TestRouteBucket): unknown {
+    return bucket.route;
+  }
+
+  willEnter(_bucket: TestRouteBucket, _args: NavigationArgs): void {}
+
+  enter(bucket: TestRouteBucket, args: NavigationArgs): Promise<unknown> {
+    const transition = args.transition;
+    const routeInfo = args.to;
+    // Source the route from routeInfo.route (the value the router resolved),
+    // not bucket.route. createHandlerInfo and friends sometimes attach a route
+    // to the routeInfo via prototype assignment that doesn't match the route
+    // the bucket was constructed with; routeInfo.route is the authoritative one.
+    const route = (routeInfo?.route ?? bucket.route) as Route<any>;
+
+    if (transition && typeof transition.trigger === 'function') {
+      transition.trigger(true, 'willResolveModel', transition, route);
+    }
+
+    const name = routeInfo?.name ?? bucket.args.name;
+    // If a hook returns a Transition (e.g. router.transitionTo from inside
+    // beforeModel/afterModel), null it out so the chain doesn't pause waiting
+    // on a "transition" thenable. Mirrors classic-route-manager's _isTransition
+    // guards. UnresolvedRouteInfoByParam.getModel already handles this for
+    // route.model itself.
+    const isTransitionLike = (obj: unknown): boolean =>
+      typeof obj === 'object' && obj !== null && (obj as any).isTransition === true;
+
+    const beforeModelResult = route?.beforeModel?.(transition);
+    return Promise.resolve(isTransitionLike(beforeModelResult) ? null : beforeModelResult)
+      .then(() => routeInfo.getModel(transition))
+      .then((model: unknown) => {
+        // Stash the model on transition.resolvedModels BEFORE afterModel so
+        // afterModel can swap it (test: "resolved models can be swapped out
+        // within afterModel"). Mirrors classic-route-manager._getModel +
+        // _runAfterModel order.
+        if (transition) {
+          transition.resolvedModels = transition.resolvedModels || {};
+          transition.resolvedModels[name] = model;
+        }
+        const afterModelResult = route?.afterModel?.(model as any, transition);
+        const safeAfterModel = isTransitionLike(afterModelResult) ? null : afterModelResult;
+        return Promise.resolve(safeAfterModel).then(() => {
+          // afterModel may have swapped transition.resolvedModels[name]; pick
+          // up the (possibly new) value rather than the original model.
+          return transition?.resolvedModels?.[name] ?? model;
+        });
+      });
+  }
+
+  didEnter(bucket: TestRouteBucket, args: NavigationArgs & { enter?: boolean }): void {
+    const transition = args.transition;
+    const routeInfo = args.to;
+    const route = (routeInfo?.route ?? bucket.route) as Route<any>;
+    // Read context from the routeInfo. routeInfo is the per-render handle;
+    // bucket.context is being phased out.
+    const context = routeInfo?.context;
+
+    if (route) {
+      // Fire route.enter() for fresh entries (not for context-updates), mirroring
+      // classic setupContexts which gated enter on the `enter` flag passed in.
+      if (args.enter !== false && route.enter) {
+        route.enter(transition);
+      }
+      // If enter triggered a redirect (router.transitionTo from inside enter),
+      // the transition is now aborted. Throw so the outer didEnter loop bails
+      // before calling setup or invoking later routes' enter, mirroring the
+      // throwIfAborted between enter and setup in main's setupContexts.
+      throwIfAborted(transition);
+      route.context = context as any;
+      if (route.setup) {
+        route.setup(context as any, transition);
+      }
+      // Same guard between setup and the next route, so a redirect from setup
+      // also stops further enters/setups in this loop iteration.
+      throwIfAborted(transition);
+    }
+  }
+
+  willExit(_bucket: TestRouteBucket, _args: NavigationArgs & { isExiting?: boolean }): void {}
+
+  exit(bucket: TestRouteBucket, args: NavigationArgs): void {
+    // Mirror classic setupContexts: fire route.exit and clear route.context
+    // when the route is leaving the active hierarchy.
+    const transition = args.transition;
+    const route = bucket.route;
+    if (route) {
+      delete route.context;
+      if (route.exit) {
+        route.exit(transition);
+      }
+    }
+  }
+
+  didExit(_bucket: TestRouteBucket, _args: NavigationArgs): void {}
+
+  // Sentinel wrapper. router_js tests never actually render so the value is
+  // unused, we just need to satisfy the manager interface.
+  getRouteWrapper(_bucket: TestRouteBucket): object {
+    return TEST_WRAPPER_SENTINEL;
+  }
+
+  // Gate on enterPromise so the resolution loop stays sequential, mirroring
+  // classic behaviour. Most existing tests assume a route's model resolves
+  // before its child route's model starts.
+  getInvokable(
+    _bucket: TestRouteBucket,
+    enterPromise: Promise<unknown>
+  ): Promise<object | undefined> {
+    return (enterPromise ?? Promise.resolve()).then(() => undefined);
+  }
+}
+
+const TEST_WRAPPER_SENTINEL = {};
+
+const SHARED_TEST_MANAGER = new TestRouteManager();
+
 export function createHandler<T extends IModel>(name: string, options?: Dict<unknown>): Route<T> {
-  return Object.assign(
+  const handler = Object.assign(
     { name, routeName: name, context: {}, names: [], handler: name, _internalName: name },
     options
   ) as unknown as Route<T>;
+  // Attach a manager+bucket so resolveViaManager has something to work with.
+  // Without this, route.manager is undefined and the resolution loop blows up.
+  SHARED_TEST_MANAGER.createRoute(handler as unknown as Route, { name });
+  return handler;
 }
 
 export class TestRouter<R extends Route = Route> extends Router<R> {
@@ -94,14 +276,206 @@ export class TestRouter<R extends Route = Route> extends Router<R> {
       return error.error;
     }
   }
-  getRoute(_name: string): any {
-    return {};
+  getRoute(name: string): any {
+    // Return a handler with a manager attached so resolveViaManager has
+    // something to work with. Bare {} would crash on route.manager access.
+    return createHandler(name);
   }
   getSerializer(_name: string): any {
     return () => {};
   }
+
+  // As each route's getInvokable resolves, write the resolved routeInfo into
+  // currentRouteInfos at its slot. Mirrors EmberRouter.onRouteInvokableReady.
+  onRouteInvokableReady(
+    routeInfo: InternalRouteInfoLike,
+    _transition: any,
+    routeIndex: number
+  ): void {
+    const current = (this.currentRouteInfos as any[]) ?? [];
+    current[routeIndex] = routeInfo;
+    (this as any).currentRouteInfos = current;
+  }
+
+  // Mirrors EmberRouter.onIntermediateTransition. Substate routes have no
+  // model hook to await, so we synchronously fire didEnter on each entered
+  // route (after splicing currentRouteInfos), so route.enter/route.setup run.
+  // For async getRoute scenarios the route may not be resolved yet at this
+  // point (becomeResolved was called before fetchRoute); chain on routePromise
+  // so didEnter still fires once the handler is available, mirroring main's
+  // routeEnteredOrUpdated path that defers via routePromise.then.
+  onIntermediateTransition(newState: any, transition: any): void {
+    const partition = this.partitionRoutes(this.state!, newState);
+
+    const currentRouteInfos = [...partition.unchanged, ...partition.entered];
+    (this as any).currentRouteInfos = currentRouteInfos;
+
+    this.oldState = this.state;
+    this.state = newState;
+
+    const fireDidEnter = (routeInfo: any, route: any) => {
+      if (!route?.manager) return;
+      route.manager.didEnter(route.bucket, { transition, to: routeInfo, enter: true } as any);
+    };
+
+    for (const routeInfo of partition.entered) {
+      const route = (routeInfo as any).route;
+      if (route) {
+        fireDidEnter(routeInfo, route);
+      } else {
+        // Async route: trigger fetchRoute via routePromise and defer didEnter
+        // until it resolves. Without this faq.setup never fires in scenarios
+        // where getRoute returns a Promise.
+        (routeInfo as any).routePromise.then((resolved: any) => {
+          fireDidEnter(routeInfo, resolved);
+        });
+      }
+    }
+  }
+
+  // Mirrors EmberRouter.onTransitionSettled, the orchestrator that fires
+  // willExit/exit/didEnter/didExit, awaits enterPromises, finalizes QPs, and
+  // updates the URL. Without this, classic route.enter/route.exit hooks never
+  // run for tests that use a manager-driven router.
+  onTransitionSettled(activeTransition: any, newState: any): Promise<void> {
+    const partition = this.partitionRoutes(this.state!, newState);
+
+    // Capture pre-transition state so we can revert on didEnter throws.
+    // Mirrors classic setupContexts: a throw inside enter/setup must roll
+    // back router state so the next transition sees the routes as still-
+    // unentered and re-fires their enter hooks.
+    const preTransitionState = this.state;
+    this.oldState = this.state;
+    this.state = newState;
+
+    // willExit + exit on routes leaving the hierarchy.
+    for (const exitingRouteInfo of partition.exited) {
+      const route = (exitingRouteInfo as any).route;
+      if (route?.manager) {
+        route.manager.willExit(route.bucket, { transition: activeTransition } as any);
+        route.manager.exit(route.bucket, { transition: activeTransition } as any);
+      }
+    }
+
+    // Filter exited routes out of currentRouteInfos. Cannot truncate to
+    // unchanged.length because onRouteInvokableReady may have already written
+    // entering routes at higher indices.
+    const exitedRouteObjects = new Set(partition.exited.map((ri: any) => ri.route));
+    if (this.currentRouteInfos) {
+      this.currentRouteInfos = this.currentRouteInfos.filter(
+        (cri: any) => !exitedRouteObjects.has(cri.route)
+      ) as any;
+    }
+
+    // Reset routes whose context changed but which are not exiting.
+    for (const resetRouteInfo of partition.reset) {
+      const route = (resetRouteInfo as any).route;
+      if (route?.manager && route.bucket !== undefined) {
+        route.manager.willExit(route.bucket, {
+          transition: activeTransition,
+          isExiting: false,
+        } as any);
+      }
+    }
+
+    // Wait for all entering routes' enter() promises before firing didEnter.
+    // Swallow rejections so a single failed transition does not poison the
+    // global RSVP unhandled rejection handler.
+    const enteringRouteInfos = [...partition.entered, ...partition.updatedContext];
+    const enterPromises = enteringRouteInfos.map((routeInfo: any) => {
+      const p = routeInfo.enterPromise ?? Promise.resolve(undefined);
+      return (p as any).catch ? (p as any).catch(() => undefined) : p;
+    });
+
+    return (Promise as any).all(enterPromises).then(() => {
+      if (activeTransition.isAborted) return;
+
+      try {
+        for (const enteredRouteInfo of partition.entered) {
+          const route = (enteredRouteInfo as any).route;
+          if (!route) continue;
+          route.manager.didEnter(route.bucket, {
+            transition: activeTransition,
+            to: enteredRouteInfo,
+            enter: true,
+          } as any);
+        }
+
+        for (const updatedRouteInfo of partition.updatedContext) {
+          const route = (updatedRouteInfo as any).route;
+          if (!route) continue;
+          route.manager.didEnter(route.bucket, {
+            transition: activeTransition,
+            to: updatedRouteInfo,
+            enter: false,
+          } as any);
+        }
+      } catch (error) {
+        // Roll back state to the pre-transition values so the next transition
+        // sees these routes as still-unentered and re-fires their enter hooks.
+        // Mirrors classic setupContexts' rollback behaviour on throw.
+        // Copy the routeInfos array (don't alias) so subsequent transitions
+        // that mutate currentRouteInfos via onRouteInvokableReady don't also
+        // write back into preTransitionState.routeInfos, corrupting the state
+        // baseline used by partitionRoutes for the next transition.
+        this.state = preTransitionState;
+        this.currentRouteInfos = preTransitionState
+          ? (preTransitionState.routeInfos.slice() as any)
+          : undefined;
+        const errorRoute = (newState.routeInfos[newState.routeInfos.length - 1] as any)?.route;
+        const reason = this.transitionDidError(
+          { error, route: errorRoute, wasAborted: false } as any,
+          activeTransition
+        );
+        throw reason;
+      }
+
+      // If a route's enter or setup hook redirected (called router.transitionTo),
+      // the original transition is now aborted. Reject so the original handleURL/
+      // transitionTo promise rejects with a TransitionAborted, mirroring main's
+      // setupContexts post-check before _updateURL fires.
+      if (activeTransition.isAborted) {
+        throw logAbort(activeTransition);
+      }
+
+      // didExit on routes that left the hierarchy.
+      for (const exitedRouteInfo of partition.exited) {
+        const route = (exitedRouteInfo as any).route;
+        if (route?.manager) {
+          route.manager.didExit(route.bucket, { transition: activeTransition } as any);
+        }
+      }
+
+      // Replace currentRouteInfos with the authoritative settled list.
+      this.currentRouteInfos = newState.routeInfos.slice();
+
+      // Finalize query params with the settled route infos.
+      this.state!.queryParams = this.finalizeQueryParamChange(
+        this.currentRouteInfos!,
+        newState.queryParams,
+        activeTransition
+      );
+
+      this._updateURL(activeTransition, newState);
+
+      activeTransition.isActive = false;
+      this.activeTransition = undefined;
+
+      this.triggerEvent(this.currentRouteInfos!, true, 'didTransition', []);
+      this.didTransition(this.currentRouteInfos!);
+      this.toInfos(activeTransition, newState.routeInfos, true);
+      this.routeDidChange(activeTransition);
+
+      // Resolve the transition's promise with the leaf route to mirror the
+      // original router_js finalizeTransition contract that tests rely on.
+      return (newState.routeInfos[newState.routeInfos.length - 1] as any)?.route;
+    });
+  }
 }
 
+// Loose alias for InternalRouteInfo to keep TestRouter signatures legible.
+type InternalRouteInfoLike = RouteInfo<Route>;
+
 export function createHandlerInfo(name: string, options: Dict<unknown> = {}): RouteInfo<Route> {
   class Stub extends RouteInfo<Route> {
     constructor(name: string, router: Router<Route>, handler?: Route) {
@@ -115,8 +489,12 @@ export function createHandlerInfo(name: string, options: Dict<unknown> = {}): Ro
     }
   }
 
-  let handler = (options['handler'] as Route) || createHandler('foo');
+  // Tests pass the route under either `handler` or `route`; both are valid
+  // ergonomics. Pull whichever is set, fall back to a fresh handler.
+  let handler =
+    (options['handler'] as Route) || (options['route'] as Route) || createHandler('foo');
   delete options['handler'];
+  delete options['route'];
 
   Object.assign(Stub.prototype, options);
   let stub = new Stub(name, new TestRouter(), handler);
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 652dd7d501e..8641b335343 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -2759,6 +2759,9 @@ importers:
         specifier: workspace:*
         version: link:../@glimmer/env
     devDependencies:
+      '@ember/-internals':
+        specifier: workspace:*
+        version: link:../@ember/-internals
       '@types/qunit':
         specifier: ^2.9.6
         version: 2.19.13
@@ -10739,7 +10742,6 @@ packages:
     engines: {node: '>=0.6.0', teleport: '>=0.2.0'}
     deprecated: |-
       You or someone you depend on is using Q, the JavaScript Promise library that gave JavaScript developers strong feelings about promises. They can almost certainly migrate to the native JavaScript promise now. Thank you literally everyone for joining me in this bet against the odds. Be excellent to each other.
-
       (For a CapTP with native promises, see @endo/eventual-send and @endo/captp)
 
   qified@0.9.0: