diff --git a/.gitignore b/.gitignore
index 9bf32df156f..86bbbbb3da9 100644
--- a/.gitignore
+++ b/.gitignore
@@ -31,6 +31,7 @@ test/version_tmp
 test_*.html
 /tests/ember-tests.js
 /smoke-tests/scenarios/output/
+/smoke-tests/scenarios/output-*/
 tmp
 tmp*.gem
 tmp.bpm
diff --git a/package.json b/package.json
index 86c1d3d37db..a005a274a8f 100644
--- a/package.json
+++ b/package.json
@@ -187,6 +187,13 @@
       "@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/api.js": "ember-source/@ember/-internals/routing/route-managers/api.js",
+      "@ember/-internals/routing/route-managers/classic/bucket.js": "ember-source/@ember/-internals/routing/route-managers/classic/bucket.js",
+      "@ember/-internals/routing/route-managers/classic/manager.js": "ember-source/@ember/-internals/routing/route-managers/classic/manager.js",
+      "@ember/-internals/routing/route-managers/classic/query-params.js": "ember-source/@ember/-internals/routing/route-managers/classic/query-params.js",
+      "@ember/-internals/routing/route-managers/classic/substates.js": "ember-source/@ember/-internals/routing/route-managers/classic/substates.js",
+      "@ember/-internals/routing/route-managers/classic/wrapper.js": "ember-source/@ember/-internals/routing/route-managers/classic/wrapper.js",
+      "@ember/-internals/routing/route-managers/registry.js": "ember-source/@ember/-internals/routing/route-managers/registry.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/glimmer/lib/component-managers/outlet.ts b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
index aba8e2e979d..f3825d3f60c 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts
@@ -41,8 +41,17 @@ interface OutletInstanceState {
 export interface OutletDefinitionState {
   ref: Reference<OutletState | undefined>;
   name: string;
-  template: object;
-  controller: unknown;
+
+  /**
+   * What this outlet renders. The root `OutletView` provides the upgraded
+   * root template as `invokable`; per-outlet states built by the `{{outlet}}`
+   * helper carry the manager's `wrapper` (when present) plus `invokable` and
+   * `controller`, which the helper's stability check keys on.
+   */
+  controller?: unknown;
+  wrapper?: object;
+  invokable?: object;
+  bucket?: object;
 }
 
 const CAPABILITIES: InternalComponentCapabilities = {
@@ -171,10 +180,15 @@ class OutletComponentManager
 
 const OUTLET_MANAGER = /*@__PURE__*/ new OutletComponentManager();
 
-const OUTLET_COMPONENT_TEMPLATE = precompileTemplate(
-  '<@Component @controller={{@controller}} @model={{@model}} />',
-  { strictMode: true }
-);
+// The one outlet layout. `@Component` is always a value that already
+// carries everything it needs — the outlet helper curries the args (the
+// invokable/bucket/live context for wrapped renders, the live context for
+// wrapper-less ones) onto the render target before handing it over, and the
+// root outlet's invokable takes no args at all. Keeping the layout arg-less
+// also keeps stray named args out of the debug render tree.
+const OUTLET_COMPONENT_TEMPLATE = precompileTemplate('<@Component />', {
+  strictMode: true,
+});
 
 export class OutletComponent implements ComponentDefinition<
   OutletDefinitionState,
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts b/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
index c1cba0428ef..cc2acd2db1a 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts
@@ -1,5 +1,4 @@
 import type { InternalOwner } from '@ember/-internals/owner';
-import { _instrumentStart } from '@ember/instrumentation';
 import type {
   CapturedArguments,
   CompilableProgram,
@@ -14,20 +13,19 @@ import type {
   WithCustomDebugRenderTree,
 } from '@glimmer/interfaces';
 import type { Nullable } from '@ember/-internals/utility-types';
-import { DEBUG } from '@glimmer/env';
 import { capabilityFlagsFrom } from '@glimmer/manager/lib/util/capabilities';
 import type { Reference } from '@glimmer/reference/lib/reference';
-import { createDebugAliasRef, valueForRef } from '@glimmer/reference/lib/reference';
+import { UNDEFINED_REFERENCE, valueForRef } from '@glimmer/reference/lib/reference';
 import { curry, type CurriedValue } from '@glimmer/runtime/lib/curried-value';
 import { unwrapTemplate } from './unwrap-template';
 
 interface RouteTemplateInstanceState {
   self: Reference;
-  controller: unknown;
 }
 
 export interface RouteTemplateDefinitionState {
   name: string;
+  self: Reference;
 }
 
 const CAPABILITIES: InternalComponentCapabilities = {
@@ -55,18 +53,10 @@ class RouteTemplateManager
 {
   create(
     _owner: InternalOwner,
-    _definition: RouteTemplateDefinitionState,
-    args: VMArguments
+    definition: RouteTemplateDefinitionState,
+    _args: VMArguments
   ): RouteTemplateInstanceState {
-    let self = args.named.get('controller');
-
-    if (DEBUG) {
-      self = createDebugAliasRef!('this', self);
-    }
-
-    let controller = valueForRef(self);
-
-    return { self, controller };
+    return { self: definition.self };
   }
 
   getSelf({ self }: RouteTemplateInstanceState): Reference {
@@ -88,7 +78,7 @@ class RouteTemplateManager
         type: 'route-template',
         name,
         args,
-        instance: state.controller,
+        instance: valueForRef(state.self),
       },
     ];
   }
@@ -111,7 +101,7 @@ class RouteTemplateManager
 const ROUTE_TEMPLATE_MANAGER = /*@__PURE__*/ new RouteTemplateManager();
 
 /**
- * This "upgrades" a route template into a invocable component. Conceptually
+ * This "upgrades" a route template into a invokable component. Conceptually
  * it can be 1:1 for each unique `Template`, but it's also cheap to construct,
  * so unless the stability is desirable for other reasons, it's probably not
  * worth caching this.
@@ -129,13 +119,13 @@ export class RouteTemplate implements ComponentDefinition<
   public capabilities = CAPABILITIES_MASK;
   public compilable: CompilableProgram;
 
-  constructor(name: string, template: Template) {
+  constructor(name: string, template: Template, self: Reference) {
     let unwrapped = unwrapTemplate(template);
     // TODO This actually seems inaccurate – it ultimately came from the
     // outlet's name. Also, setting this overrides `getDebugName()` in that
     // message. Is that desirable?
     this.resolvedName = name;
-    this.state = { name };
+    this.state = { name, self };
     this.compilable = unwrapped.asLayout();
   }
 }
@@ -150,8 +140,9 @@ export class RouteTemplate implements ComponentDefinition<
 export function makeRouteTemplate(
   owner: InternalOwner,
   name: string,
-  template: Template
+  template: Template,
+  self: Reference = UNDEFINED_REFERENCE
 ): CurriedValue {
-  let routeTemplate = new RouteTemplate(name, template);
+  let routeTemplate = new RouteTemplate(name, template, self);
   return curry(0 as CurriedComponent, routeTemplate, owner, null, true);
 }
diff --git a/packages/@ember/-internals/glimmer/lib/renderer.ts b/packages/@ember/-internals/glimmer/lib/renderer.ts
index e533c4042ba..90334f6d5aa 100644
--- a/packages/@ember/-internals/glimmer/lib/renderer.ts
+++ b/packages/@ember/-internals/glimmer/lib/renderer.ts
@@ -41,7 +41,6 @@ import { RootComponentDefinition } from './component-managers/root';
 import RouterResolver from './router-resolver';
 import type { OutletState } from './utils/outlet';
 import OutletView from './views/outlet';
-import { makeRouteTemplate } from './component-managers/route-template';
 import type { IBuilder, RendererRoot } from './base-renderer';
 import { BaseRenderer, errorLoopTransaction } from './base-renderer';
 
@@ -218,31 +217,25 @@ export class Renderer extends BaseRenderer {
   // renderer HOOKS
 
   appendOutletView(view: OutletView, target: SimpleElement): void {
+    // The append is scheduled into the `render` queue, so a teardown that
+    // starts in the same run loop (e.g. a deferred incremental outlet pass
+    // racing test cleanup) can destroy this renderer before the queue
+    // flushes. Rendering into a destroying renderer would assert deep in
+    // the destroyable graph; skip instead.
+    if (isDestroying(this) || isDestroyed(this)) {
+      return;
+    }
+
     // TODO: This bypasses the {{outlet}} syntax so logically duplicates
     // some of the set up code. Since this is all internal (or is it?),
     // 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 { invokable } = view.state;
+    assert('[BUG] OutletView state is unexpectedly missing its root invokable', invokable);
 
     let named = dict<Reference>();
-
-    named['Component'] = createConstRef(
-      makeRouteTemplate(view.owner, name, template as Template),
-      '@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;
+    named['Component'] = createConstRef(invokable, '@Component');
 
     let args = createCapturedArgs(named, EMPTY_POSITIONAL);
 
diff --git a/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts b/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
index f39637e320b..ce2303b0c03 100644
--- a/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/syntax/outlet.ts
@@ -1,12 +1,7 @@
 import type { InternalOwner } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import type {
-  CapturedArguments,
-  CurriedComponent,
-  DynamicScope,
-  Template,
-} from '@glimmer/interfaces';
+import type { CapturedArguments, CurriedComponent, DynamicScope } from '@glimmer/interfaces';
 import type { Reference } from '@glimmer/reference/lib/reference';
 import {
   childRefFromParts,
@@ -19,9 +14,7 @@ import type { CurriedValue } from '@glimmer/runtime/lib/curried-value';
 import { createCapturedArgs, EMPTY_POSITIONAL } from '@glimmer/runtime/lib/vm/arguments';
 import { curry } from '@glimmer/runtime/lib/curried-value';
 import { dict } from '@glimmer/util/lib/collections';
-import { hasInternalComponentManager } from '@glimmer/manager/lib/internal/api';
 import { OutletComponent, type OutletDefinitionState } from '../component-managers/outlet';
-import { makeRouteTemplate } from '../component-managers/route-template';
 import { internalHelper } from '../helpers/internal-helper';
 import type { OutletState } from '../utils/outlet';
 
@@ -33,15 +26,15 @@ import type { OutletState } from '../utils/outlet';
   ```app/templates/application.gjs
   import MyHeader from '../components/my-header';
   import MyFooter from '../components/my-footer';
-    
+
   <template>
     <MyHeader />
-  
+
     <div class="my-dynamic-content">
       <!-- this content will change based on the current route, which depends on the current URL -->
       {{outlet}}
     </div>
-  
+
     <MyFooter />
   </template>
   ```
@@ -50,8 +43,8 @@ import type { OutletState } from '../utils/outlet';
   information on how your `route` interacts with the `{{outlet}}` helper.
   Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
 
-  `outlet` is built-in and does not need to be imported. 
- 
+  `outlet` is built-in and does not need to be imported.
+
   @method outlet
   @for Ember.Templates.helpers
   @public
@@ -86,110 +79,86 @@ export const outletHelper = /*@__PURE__*/ internalHelper(
       // same route, but return a different one when the route changes. On the
       // other hand, changing the model only intentionally do not teardown the
       // component and instead re-render in-place.
-      if (!isStable(state, lastState)) {
-        lastState = state;
-
-        if (state !== null) {
-          // If we are crossing an engine mount point, this is how the owner
-          // gets switched.
-          let outletOwner = outletState?.render?.owner ?? owner;
-
-          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;
-          } 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';
-                }
-              };
-
-              // 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 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
-          outlet = curry(
-            0 as CurriedComponent,
-            new OutletComponent(owner, state),
-            outletOwner,
-            args,
-            true
-          );
-        } else {
-          outlet = null;
+      if (isStable(state, lastState)) {
+        return outlet;
+      }
+
+      lastState = state;
+
+      if (state === null) {
+        return null;
+      }
+
+      // If we are crossing an engine mount point, this is how the owner
+      // gets switched.
+      let outletOwner = outletState?.render?.owner ?? owner;
+
+      let modelRef = childRefFromParts(outletRef, ['render', 'model']);
+      let model = valueForRef(modelRef);
+
+      let context: Reference = createComputeRef(() => {
+        if (lastState === state) {
+          model = valueForRef(modelRef);
         }
+        return model;
+      });
+
+      if (DEBUG) {
+        context = createDebugAliasRef!('@context', context);
+      }
+
+      // stateFor guarantees an invokable is present.
+      assert('Expected outlet state to have an invokable to render', state.invokable !== undefined);
+
+      // Args are delivered by currying them onto the render target — the
+      // outlet's layout is arg-less. Currying (rather than writing the args
+      // into the layout) keeps the target from showing up as an opaque
+      // `@Component` frame in the debug render tree and
+      // backtracking-assertion messages. Curried refs stay live, so the
+      // `@context` compute ref keeps updating across renders of the mount.
+      let targetArgs = dict<Reference>();
+      let target;
+
+      if (state.wrapper !== undefined) {
+        // Manager render with a wrapper: the RFC's wrapper args —
+        // `@Component` (the per-bucket invokable), `@bucket`, and the live
+        // `@context`.
+        targetArgs['Component'] = createConstRef(state.invokable, '@Component');
+        targetArgs['bucket'] = createConstRef(state.bucket, '@bucket');
+        target = state.wrapper;
+      } else {
+        // Wrapper-less render (a manager that opted out, or a legacy
+        // `setOutletState` caller): the invokable itself is the target and
+        // receives only the live `@context`. No `@bucket`: unlike the
+        // module-stable wrapper, the invokable is per-bucket and built by
+        // the manager, so anything bucket-shaped it needs the manager can
+        // attach itself — the live context ref is the one thing only the
+        // outlet can supply. (Legacy renders have no bucket at all.)
+        target = state.invokable;
       }
 
+      targetArgs['context'] = context;
+
+      let named = dict<Reference>();
+      named['Component'] = createConstRef(
+        curry(
+          0 as CurriedComponent,
+          target,
+          outletOwner,
+          createCapturedArgs(targetArgs, EMPTY_POSITIONAL),
+          false
+        ),
+        '@Component'
+      );
+
+      outlet = curry(
+        0 as CurriedComponent,
+        new OutletComponent(owner, state),
+        outletOwner,
+        createCapturedArgs(named, EMPTY_POSITIONAL),
+        true
+      );
+
       return outlet;
     });
   }
@@ -202,17 +171,19 @@ function stateFor(
   if (outlet === undefined) return null;
   let render = outlet.render;
   if (render === undefined) return null;
-  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
-  // assert, but that is probably overly strict for very little to gain.
-  if (template === undefined || template === null) return null;
+
+  // There is nothing to render until we have an invokable. This is either the
+  // manager-driven invokable or a route template that `OutletView` upgraded
+  // from a legacy raw `template`.
+  if (render.invokable === undefined) return null;
 
   return {
     ref,
     name: render.name,
-    template,
     controller: render.controller,
+    wrapper: render.wrapper,
+    invokable: render.invokable,
+    bucket: render.bucket,
   };
 }
 
@@ -224,5 +195,16 @@ function isStable(
     return false;
   }
 
-  return state.template === lastState.template && state.controller === lastState.controller;
+  // Manager-driven routes with a wrapper: the wrapper is module-stable, so
+  // route identity is carried by the per-bucket invokable. `controller` is
+  // deliberately excluded here: it can legitimately appear after the first
+  // render (setupController runs in didEnter) and must not tear the route
+  // down.
+  if (state.wrapper !== undefined || lastState.wrapper !== undefined) {
+    return state.wrapper === lastState.wrapper && state.invokable === lastState.invokable;
+  }
+
+  // Legacy `setOutletState` callers have no wrapper; key on the upgraded
+  // invokable and controller.
+  return state.invokable === lastState.invokable && state.controller === lastState.controller;
 }
diff --git a/packages/@ember/-internals/glimmer/lib/utils/outlet.ts b/packages/@ember/-internals/glimmer/lib/utils/outlet.ts
index 61cb1ead256..34e5f5cf6d1 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/outlet.ts
@@ -1,5 +1,4 @@
 import type { InternalOwner } from '@ember/-internals/owner';
-import type { Template } from '@glimmer/interfaces';
 
 export interface RenderState {
   /**
@@ -25,10 +24,27 @@ export interface RenderState {
   model: unknown;
 
   /**
-   * The route's template – this is either a Template or a component, and it
-   * gets normalized during the render process.
+   * The stable wrapper component returned by `RouteManager.getRouteWrapper`
    */
-  template: Template | object | undefined;
+  wrapper: object | undefined;
+
+  /**
+   * The per-render invokable returned by `RouteManager.getInvokable`
+   */
+  invokable: object | undefined;
+
+  /**
+   * The manager's bucket for the route; the outlet curries it onto the
+   * wrapper as `@bucket`.
+   */
+  bucket?: object;
+
+  /**
+   * Legacy template used by `setOutletState` callers (older test-helpers,
+   * liquid-fire-style addons). Usually a `Template`, but a pre-built
+   * component definition is also accepted (see `OutletView`).
+   */
+  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..7895bed3fd2 100644
--- a/packages/@ember/-internals/glimmer/lib/views/outlet.ts
+++ b/packages/@ember/-internals/glimmer/lib/views/outlet.ts
@@ -6,15 +6,18 @@ import { type InternalOwner, getOwner } from '@ember/-internals/owner';
 import type { BootOptions } from '@ember/engine/instance';
 import { assert } from '@ember/debug';
 import { schedule } from '@ember/runloop';
+import { DEBUG } from '@glimmer/env';
 import type { Template, TemplateFactory } from '@glimmer/interfaces';
+import { hasInternalComponentManager } from '@glimmer/manager/lib/internal/api';
 import type { Reference } from '@glimmer/reference/lib/reference';
-import { createComputeRef, updateRef } from '@glimmer/reference/lib/reference';
+import { createComputeRef, createConstRef, updateRef } from '@glimmer/reference/lib/reference';
 import { consumeTag } from '@glimmer/validator/lib/tracking';
 import { createTag, DIRTY_TAG as dirtyTag } from '@glimmer/validator/lib/validators';
 import type { SimpleElement } from '@simple-dom/interface';
 import type { OutletDefinitionState } from '../component-managers/outlet';
 import type { Renderer } from '../renderer';
 import type { OutletState } from '../utils/outlet';
+import { makeRouteTemplate } from '../component-managers/route-template';
 
 export interface BootEnvironment {
   hasDOM: boolean;
@@ -25,6 +28,15 @@ export interface BootEnvironment {
 
 const TOP_LEVEL_NAME = '-top-level';
 
+function isTemplate(value: unknown): value is Template {
+  if (value === null || typeof value !== 'object') {
+    return false;
+  }
+
+  let template = value as Partial<Template>;
+  return template.result === 'ok' || template.result === 'error';
+}
+
 export default class OutletView {
   static extend(injections: any): typeof OutletView {
     return class extends OutletView {
@@ -71,7 +83,8 @@ export default class OutletView {
         name: TOP_LEVEL_NAME,
         controller: undefined,
         model: undefined,
-        template,
+        wrapper: undefined,
+        invokable: undefined,
       },
     };
 
@@ -89,8 +102,13 @@ export default class OutletView {
     this.state = {
       ref,
       name: TOP_LEVEL_NAME,
-      template,
-      controller: undefined,
+      // The root template renders with no `self`; all template→invokable
+      // upgrading (root and legacy alike) lives in this module. The template
+      // is only absent when unit tests construct a bare OutletView — those
+      // never render, so the missing invokable is caught by the renderer's
+      // assertion if one ever tries.
+      invokable:
+        template !== undefined ? makeRouteTemplate(owner, TOP_LEVEL_NAME, template) : undefined,
     };
   }
 
@@ -114,7 +132,63 @@ export default class OutletView {
     /**/
   }
 
+  // Legacy `setOutletState` callers (the rendering test-helpers and
+  // liquid-fire-style addons) provide a raw `template` with no `invokable`.
+  // The outlet helper only knows how to render an invokable, so we upgrade any
+  // raw template into a route template here, mutating the renders in place.
+  // Walk the whole outlet chain so nested legacy states are normalized too.
+  // We skip renders that already have an invokable (the manager-driven router
+  // path), which keeps the invokable identity stable when the same render
+  // object is set again.
+  private upgradeLegacyTemplates(state: OutletState): void {
+    let current: OutletState | undefined = state;
+
+    while (current !== undefined) {
+      let render = current.render;
+
+      if (render !== undefined && render.invokable === undefined && render.template) {
+        render.invokable = this.invokableForTemplate(
+          render.name,
+          render.template,
+          render.controller
+        );
+      }
+
+      current = current.outlets.main;
+    }
+  }
+
+  // Turn a legacy raw `template` into something the outlet can render. A
+  // caller may also hand us a pre-built component definition instead of a
+  // template (an intimate API older addons may rely on), in which case we
+  // use it directly rather than trying to wrap it.
+  private invokableForTemplate(name: string, template: object, controller: unknown): object {
+    if (hasInternalComponentManager(template)) {
+      return template;
+    }
+
+    if (DEBUG && !isTemplate(template)) {
+      let label: string;
+      try {
+        label = `\`${String(template)}\``;
+      } catch {
+        label = 'an unknown object';
+      }
+
+      assert(
+        `Failed to render the \`${name}\` route: expected a component or Template object, but got ${label}.`
+      );
+    }
+
+    // The route template renders with the controller as its `self` (`this`).
+    // This path is for legacy `setOutletState` callers that provide a raw `template`
+    // We know they use controllers, so we can safely reach for the controller here.
+    let self = createConstRef(controller, 'this');
+    return makeRouteTemplate(this.owner, name, template as Template, self);
+  }
+
   setOutletState(state: OutletState): void {
+    this.upgradeLegacyTemplates(state);
     updateRef(this.ref, state);
   }
 
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..53650ae7f08 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
@@ -1556,7 +1556,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/glimmer/tests/integration/outlet-test.js b/packages/@ember/-internals/glimmer/tests/integration/outlet-test.js
index fc17ee2730e..0f860bd401e 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/outlet-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/outlet-test.js
@@ -159,5 +159,26 @@ moduleFor(
 
       this.assertStableRerender();
     }
+
+    ['@test renders the controller as the template `this` (legacy setOutletState)']() {
+      this.registerTemplate('application', 'Hello {{this.message}}!');
+      let outletState = {
+        render: {
+          owner: this.owner,
+          name: 'application',
+          controller: { message: 'world' },
+          template: this.owner.lookup('template:application')(this.owner),
+        },
+        outlets: Object.create(null),
+      };
+
+      runTask(() => this.component.setOutletState(outletState));
+
+      runAppend(this.component);
+
+      this.assertText('Hello world!');
+
+      this.assertStableRerender();
+    }
   }
 );
diff --git a/packages/@ember/-internals/package.json b/packages/@ember/-internals/package.json
index ed45dfe6c74..7f5f825722b 100644
--- a/packages/@ember/-internals/package.json
+++ b/packages/@ember/-internals/package.json
@@ -16,6 +16,7 @@
     "./metal": "./metal/index.ts",
     "./owner": "./owner/index.ts",
     "./routing": "./routing/index.ts",
+    "./routing/route-managers": "./routing/route-managers/index.ts",
     "./runtime": "./runtime/index.ts",
     "./string": "./string/index.ts",
     "./utility-types": "./utility-types/index.ts",
diff --git a/packages/@ember/-internals/routing/route-managers/api.ts b/packages/@ember/-internals/routing/route-managers/api.ts
new file mode 100644
index 00000000000..6dcfd91ba07
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/api.ts
@@ -0,0 +1,43 @@
+/**
+  Route Manager API. The contract lives in `router_js` (so it has no upward
+  dependency on `@ember/routing`); this module re-exports it for `@ember`-layer
+  consumers and defines `RouteManagerFactory`, which is `@ember`-specific
+  because it references `Owner`.
+*/
+
+import type Owner from '@ember/owner';
+import type { RouteManager } from 'router_js';
+
+export { routeCapabilities, hasClassicInterop } from 'router_js';
+export type {
+  RouteManager,
+  RouteManagerWithClassicInterop,
+  RouteStateBucket,
+  RouteCapabilities,
+  RouteCapabilitiesVersions,
+  NavigationState,
+  NavigationActions,
+  AsyncNavigationState,
+  ClassicInteropArgs,
+  WillEnterState,
+  EnterState,
+  DidEnterState,
+  WillExitState,
+  ExitState,
+  DidExitState,
+  ClassicWillEnterState,
+  ClassicEnterState,
+  ClassicDidEnterState,
+  ClassicWillExitState,
+  ClassicExitState,
+  ClassicDidExitState,
+  CreateRouteArgs,
+} from 'router_js';
+
+/**
+  Factory function the user passes to `setRouteManager`. The router calls it
+  once per owner and caches the result.
+ */
+export type RouteManagerFactory<O extends Owner = Owner, M extends RouteManager = RouteManager> = (
+  owner: O
+) => M;
diff --git a/packages/@ember/-internals/routing/route-managers/classic/bucket.ts b/packages/@ember/-internals/routing/route-managers/classic/bucket.ts
new file mode 100644
index 00000000000..ba242582f20
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/classic/bucket.ts
@@ -0,0 +1,24 @@
+import type Controller from '@ember/controller';
+import type Route from '@ember/routing/route';
+import type { scheduleOnce } from '@ember/runloop';
+
+export class ClassicRouteBucket {
+  // Cached invokable, written by buildClassicInvokable on first build.
+  invokable: object | undefined = undefined;
+
+  // The route's controller, read through as a getter so there is a single
+  // source of truth. An eagerly-copied field would go stale for substate
+  // routes: they enter via intermediate transitions that skip `willEnter`,
+  // so the copy would stay `undefined` while `route.controller` is set
+  // later by `setup` — and their templates would render with no `{{this}}`.
+  get controller(): Controller | undefined {
+    return this.route.controller;
+  }
+
+  // Runloop timer for the pending loading-event dispatch scheduled during
+  // willEnter. Per-bucket so concurrent routes track their own timers and
+  // didEnter can cancel the right one.
+  loadingSubstateTimer: ReturnType<typeof scheduleOnce> | null = null;
+
+  constructor(public route: Route) {}
+}
diff --git a/packages/@ember/-internals/routing/route-managers/classic/manager.ts b/packages/@ember/-internals/routing/route-managers/classic/manager.ts
new file mode 100644
index 00000000000..a587ff16b8a
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/classic/manager.ts
@@ -0,0 +1,428 @@
+/**
+  Classic Route Manager. Encapsulates Ember's existing classic `Route`
+  behaviour behind the `RouteManager` API.
+*/
+
+import type { Template, TemplateFactory } from '@glimmer/interfaces';
+import { hasInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+import { DEBUG } from '@glimmer/env';
+import { assert, info } from '@ember/debug';
+import { getOwner } from '@ember/-internals/owner';
+import type { default as Owner } from '@ember/-internals/owner';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { makeRouteTemplate } from '@ember/-internals/glimmer/lib/component-managers/route-template';
+import { createConstRef } from '@glimmer/reference/lib/reference';
+import { Promise as RSVPPromise } from 'rsvp';
+import { cancel, scheduleOnce } from '@ember/runloop';
+import type { InternalRouteInfo, BaseRoute as IRoute, RouteInfo, Transition } from 'router_js';
+import { throwIfAborted } from 'router_js';
+import type Route from '@ember/routing/route';
+import type {
+  ClassicDidEnterState,
+  ClassicDidExitState,
+  ClassicEnterState,
+  ClassicExitState,
+  ClassicWillEnterState,
+  ClassicWillExitState,
+  CreateRouteArgs,
+  RouteCapabilities,
+  RouteManagerWithClassicInterop,
+} from '../api';
+import { routeCapabilities } from '../api';
+import type { QueryParamMeta } from '@ember/routing/route';
+import { ClassicRouteBucket } from './bucket';
+import {
+  finalizeQueryParamChange as finalizeClassicQueryParamChange,
+  queryParamsDidChange as classicQueryParamsDidChange,
+} from './query-params';
+import {
+  type ActiveTransition,
+  enterErrorSubstate as enterClassicErrorSubstate,
+  enterLoadingSubstate as enterClassicLoadingSubstate,
+  fireLoadingEvent,
+} from './substates';
+import { CLASSIC_ROUTE_WRAPPER } from './wrapper';
+
+type TransitionLike = Transition & {
+  isAborted?: boolean;
+  error?: unknown;
+  trigger?(ignoreFailure: boolean, name: string, ...args: unknown[]): void;
+  resolvedModels?: Record<string, unknown>;
+};
+
+function isTransitionObject(value: unknown): boolean {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    (value as { isTransition?: boolean }).isTransition === true
+  );
+}
+
+export class ClassicRouteManager implements RouteManagerWithClassicInterop<ClassicRouteBucket> {
+  capabilities: RouteCapabilities = routeCapabilities('1.0', { classicInterop: true });
+
+  #owner: Owner;
+
+  constructor(owner: Owner) {
+    this.#owner = owner;
+  }
+
+  createRoute(_factory: object, args: CreateRouteArgs): ClassicRouteBucket {
+    const route = this.#owner.lookup(`route:${args.name}`) as Route;
+    route._setRouteName(args.name);
+
+    return new ClassicRouteBucket(route);
+  }
+
+  getRoute(bucket: ClassicRouteBucket) {
+    assert('Expected route bucket to expose a `route` instance', bucket.route);
+    return bucket.route;
+  }
+
+  getDestroyable(_bucket: ClassicRouteBucket): object | null {
+    // Classic routes are container-managed (`owner.lookup('route:…')`), so
+    // the owner already destroys them at teardown.
+    return null;
+  }
+
+  getRenderState(bucket: ClassicRouteBucket) {
+    const route = bucket.route;
+
+    let owner = getOwner(route);
+    assert('Route is unexpectedly missing an owner', owner);
+
+    return {
+      owner,
+      name: route.routeName,
+      controller: route.controller,
+      model: route.currentModel,
+      wrapper: this.getRouteWrapper(),
+      invokable: buildClassicInvokable(bucket),
+      bucket,
+    };
+  }
+
+  willEnter(bucket: ClassicRouteBucket, state: ClassicWillEnterState): void {
+    // Ensure the controller exists (idempotent) so the outlet can curry
+    // @controller as soon as the route renders.
+    bucket.route._initController();
+
+    const transition = state.transition as Transition & { isActive: boolean };
+    if (!transition.isActive) {
+      return;
+    }
+    // Schedule the classic `loading` event rather than entering the substate
+    // directly: the event bubbles through `actions.loading` handlers first,
+    // and only the router's default handler (dispatching back through
+    // `enterLoadingSubstate` below) enters the substate.
+    bucket.loadingSubstateTimer = scheduleOnce(
+      'routerTransitions',
+      null,
+      fireLoadingEvent,
+      bucket,
+      transition
+    );
+  }
+
+  enter(bucket: ClassicRouteBucket, state: ClassicEnterState): Promise<unknown> {
+    // Classic model chain: beforeModel → getModel → afterModel. The routeInfo
+    // (state.to) dispatches getModel polymorphically based on whether the
+    // transition was initiated with a model object or URL params.
+    const route = bucket.route;
+    const transition = state.transition as TransitionLike;
+    const routeInfo = state.internalRouteInfo;
+
+    // Classic event, fired before beforeModel (matching the pre-manager
+    // router): observable via route `actions.willResolveModel` handlers.
+    transition.trigger?.(true, 'willResolveModel', transition, route);
+
+    return RSVPPromise.resolve()
+      .then(() => {
+        let result: unknown;
+        if (route.beforeModel !== undefined) {
+          result = route.beforeModel(transition);
+        }
+        if (isTransitionObject(result)) {
+          return undefined;
+        }
+        return result;
+      })
+      .then(() => {
+        throwIfAborted(transition);
+        // We use the `getModel` on the routeInfo, as the routeInfo will be the correct
+        // subclass (e.g. ResolvedRouteInfo vs InternalRouteInfo).
+        return routeInfo.getModel(transition);
+      })
+      .then((resolvedModel) => {
+        throwIfAborted(transition);
+        transition.resolvedModels = transition.resolvedModels || {};
+        transition.resolvedModels[routeInfo.name] = resolvedModel;
+
+        let result: unknown;
+        if (route.afterModel !== undefined) {
+          result = route.afterModel(resolvedModel as never, transition);
+        }
+        if (isTransitionObject(result)) {
+          result = undefined;
+        }
+        // Re-read the stash rather than closing over `resolvedModel`: classic
+        // router.js lets afterModel swap the model out by writing into
+        // `transition.resolvedModels`.
+        return RSVPPromise.resolve(result).then(() => transition.resolvedModels![routeInfo.name]);
+      });
+  }
+
+  didEnter(bucket: ClassicRouteBucket, state: ClassicDidEnterState): void {
+    // Cancel a pending loading substate if `enter` resolved first.
+    if (bucket.loadingSubstateTimer) {
+      cancel(bucket.loadingSubstateTimer);
+      bucket.loadingSubstateTimer = null;
+    }
+
+    const route = bucket.route;
+    const transition = state.transition;
+    const context = state.internalRouteInfo.context;
+
+    if (state.enter) {
+      route.activate(transition);
+      route.trigger('activate', transition);
+    }
+
+    route.context = context;
+    if (route.contextDidChange !== undefined) {
+      route.contextDidChange();
+    }
+
+    if (route.setup !== undefined) {
+      route.setup(context, transition);
+    }
+  }
+
+  willExit(bucket: ClassicRouteBucket, state: ClassicWillExitState): void {
+    // Classic _internalReset resets the QP delegate on the controller.
+    bucket.route._internalReset(state.isExiting, state.transition);
+  }
+
+  exit(bucket: ClassicRouteBucket, state: ClassicExitState = {}): void {
+    const route = bucket.route;
+    delete route.context;
+    route.deactivate(state.transition);
+    route.trigger('deactivate', state.transition);
+    route.teardownViews();
+  }
+
+  didExit(_bucket: ClassicRouteBucket, _state: ClassicDidExitState): void {
+    // No-op for classic routes.
+  }
+
+  getRouteWrapper(): object {
+    // Module-stable, per the RFC: the outlet supplies `@Component` (the
+    // invokable), `@context`, and `@bucket` at render time, and keys its
+    // stability check on the per-bucket invokable.
+    return CLASSIC_ROUTE_WRAPPER;
+  }
+
+  getInvokable(
+    bucket: ClassicRouteBucket,
+    enterPromise?: Promise<unknown>
+  ): Promise<object | undefined> {
+    // Build the invokable synchronously, then gate its resolution on the
+    // enter promise so onRouteInvokableReady does not fire (and the real
+    // route template does not render) until the model has loaded. During
+    // the wait, the deferred scheduleOnce in willEnter fires and enters
+    // the loading substate.
+
+    const invokable = buildClassicInvokable(bucket);
+    return (enterPromise || Promise.resolve()).then(() => invokable);
+  }
+
+  qp(bucket: ClassicRouteBucket): QueryParamMeta {
+    return get(bucket.route, '_qp') as QueryParamMeta;
+  }
+
+  stashNames(
+    bucket: ClassicRouteBucket,
+    routeInfo: InternalRouteInfo<IRoute>,
+    dynamicParent: InternalRouteInfo<IRoute>
+  ): void {
+    bucket.route._stashNames(
+      routeInfo as Parameters<Route['_stashNames']>[0],
+      dynamicParent as Parameters<Route['_stashNames']>[1]
+    );
+  }
+
+  serializeQueryParam(
+    bucket: ClassicRouteBucket,
+    value: unknown,
+    urlKey: string,
+    defaultValueType: string
+  ): unknown {
+    return bucket.route.serializeQueryParam(value, urlKey, defaultValueType);
+  }
+
+  deserializeQueryParam(
+    bucket: ClassicRouteBucket,
+    value: unknown,
+    urlKey: string,
+    defaultValueType: string
+  ): unknown {
+    return bucket.route.deserializeQueryParam(value, urlKey, defaultValueType);
+  }
+
+  serializeContext(
+    bucket: ClassicRouteBucket,
+    routeInfo: InternalRouteInfo<Route>,
+    value: unknown
+  ): Record<string, unknown> | undefined {
+    return bucket.route.serialize(value, routeInfo.paramNames) as
+      | Record<string, unknown>
+      | undefined;
+  }
+
+  queryParamsDidChange(
+    bucket: ClassicRouteBucket,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    changed: {},
+    totalPresent: unknown,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    removed: {}
+  ): boolean | void {
+    return classicQueryParamsDidChange(bucket, changed, totalPresent, removed);
+  }
+
+  finalizeQueryParamChange(
+    bucket: ClassicRouteBucket,
+    params: Record<string, string | null | undefined>,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    finalParams: {}[],
+    transition: Transition
+  ): boolean | void {
+    return finalizeClassicQueryParamChange(bucket, params, finalParams, transition);
+  }
+
+  getContext(
+    bucket: ClassicRouteBucket,
+    params: Record<string, unknown>,
+    transition: Transition
+  ): unknown {
+    const route = bucket.route;
+    // `deserialize` is the router-contract entry point: it scopes the full
+    // params down to this route's own params (via `paramsFor`) before
+    // delegating to the user's `model` hook. Calling `model` directly would
+    // pass it the un-scoped params, so `deserialize` is preferred and `model`
+    // is only a fallback for handlers that don't define `deserialize`.
+    if (route.deserialize) {
+      return route.deserialize(params, transition);
+    }
+    if (route.model) {
+      return route.model(params, transition);
+    }
+    return undefined;
+  }
+
+  redirect(
+    bucket: ClassicRouteBucket,
+    _routeInfo: RouteInfo,
+    context: unknown,
+    transition: Transition
+  ): void {
+    bucket.route.redirect(context as never, transition);
+  }
+
+  enterLoadingSubstate(
+    bucket: ClassicRouteBucket,
+    transition: Transition,
+    originRoute: unknown
+  ): void {
+    enterClassicLoadingSubstate(
+      bucket.route._router,
+      originRoute as Route | undefined,
+      transition as ActiveTransition
+    );
+  }
+
+  enterErrorSubstate(
+    bucket: ClassicRouteBucket,
+    transition: Transition,
+    error: Error,
+    originRoute: unknown
+  ): boolean {
+    return enterClassicErrorSubstate(
+      bucket.route._router,
+      originRoute as Route | undefined,
+      transition as ActiveTransition,
+      error
+    );
+  }
+
+  getRouteInfoMetadata(bucket: ClassicRouteBucket): unknown {
+    return bucket.route.buildRouteInfoMetadata();
+  }
+}
+
+// Build or return cached invokable for a classic route: look up `template:<name>`,
+// upgrade a TemplateFactory into a Template, then wrap as a RouteTemplate. If the
+// lookup returns a component definition, use it directly. Falls back to the
+// shared top-level `{{outlet}}` template when no template is registered.
+function buildClassicInvokable(bucket: ClassicRouteBucket): object {
+  if (bucket.invokable !== undefined) {
+    return bucket.invokable;
+  }
+
+  const route = bucket.route;
+  const owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
+
+  const name = route.templateName || route.routeName;
+  const templateFactoryOrComponent = owner.lookup(`template:${name}`) as
+    | TemplateFactory
+    | object
+    | undefined;
+
+  // The route template renders with the controller as its `self` (`this`).
+  // This is the routing layer deciding what `self` is; the route template
+  // manager itself is controller-agnostic.
+  const self = createConstRef(bucket.controller, 'this');
+
+  let invokable: object;
+
+  if (templateFactoryOrComponent) {
+    if (hasInternalComponentManager(templateFactoryOrComponent)) {
+      // ComponentLike, used directly as the invokable.
+      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.`
+        );
+      }
+
+      const template = (templateFactoryOrComponent as TemplateFactory)(owner);
+      invokable = makeRouteTemplate(owner, name, template as Template, self);
+    }
+  } else {
+    if (DEBUG) {
+      const 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}`,
+        });
+      }
+    }
+    const template = route._topLevelViewTemplate(owner);
+    invokable = makeRouteTemplate(owner, name, template as Template, self);
+  }
+  // Cache here (rather than in getInvokable) so every caller shares one
+  // invokable — substate routes never go through getInvokable and would
+  // otherwise rebuild it on every _setOutlets pass.
+  return (bucket.invokable = invokable);
+}
diff --git a/packages/@ember/-internals/routing/route-managers/classic/query-params.ts b/packages/@ember/-internals/routing/route-managers/classic/query-params.ts
new file mode 100644
index 00000000000..b004778ac47
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/classic/query-params.ts
@@ -0,0 +1,176 @@
+/**
+  Classic query-param event handling, lifted out of the classic `Route`'s
+  `actions` hash so the logic lives behind the `RouteManager` boundary. The
+  router reaches these via `ClassicRouteManager.queryParamsDidChange` and
+  `ClassicRouteManager.finalizeQueryParamChange`, which forward to the
+  functions below.
+*/
+
+import { A as emberA } from '@ember/array';
+import { assert } from '@ember/debug';
+import { flushAsyncObservers } from '@ember/-internals/metal/lib/observer';
+import { get } from '@ember/-internals/metal/lib/property_get';
+import { set } from '@ember/-internals/metal/lib/property_set';
+import { stashParamNames } from '@ember/routing/lib/utils';
+import type Route from '@ember/routing/route';
+import type { QueryParam } from '@ember/routing/router';
+import type { Transition } from 'router_js';
+import { STATE_SYMBOL } from 'router_js';
+import type { ClassicRouteBucket } from './bucket';
+
+// Returns a fresh native array when the value is an array so callers cannot
+// mutate the shared default. Also used by `@ember/routing/route`'s QP meta
+// building.
+export function copyDefaultValue<T>(value: T): T {
+  if (Array.isArray(value)) {
+    // SAFETY: We lost the type data about the array if we don't cast.
+    return emberA(value.slice()) as unknown as T;
+  }
+  return value;
+}
+
+/**
+  Classic `queryParamsDidChange`. Triggers a model refresh when a changed query
+  param opts into `refreshModel`. Returns `true` so the event keeps bubbling.
+ */
+export function queryParamsDidChange(
+  bucket: ClassicRouteBucket,
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  changed: {},
+  _totalPresent: unknown,
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  removed: {}
+): boolean {
+  let { route } = bucket;
+  // SAFETY: Since `_qp` is protected we can't infer the type
+  let qpMap = (get(route, '_qp') as Route['_qp']).map;
+
+  let totalChanged = Object.keys(changed).concat(Object.keys(removed));
+  for (let change of totalChanged) {
+    let qp = qpMap[change];
+    if (qp) {
+      let options = route._optionsForQueryParam(qp);
+      assert('options exists', options && typeof options === 'object');
+      if ((get(options, 'refreshModel') as boolean) && route._router.currentState) {
+        route.refresh();
+        break;
+      }
+    }
+  }
+
+  return true;
+}
+
+/**
+  Classic `finalizeQueryParamChange`. Only the `application` route does the
+  work: it reconciles every controller's query-param values with the URL and
+  collects the final serialized params.
+ */
+export function finalizeQueryParamChange(
+  bucket: ClassicRouteBucket,
+  params: Record<string, string | null | undefined>,
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  finalParams: {}[],
+  transition: Transition
+): boolean | void {
+  let { route } = bucket;
+  if (route.fullRouteName !== 'application') {
+    return true;
+  }
+
+  // Transition object is absent for intermediate transitions.
+  if (!transition) {
+    return;
+  }
+
+  let routeInfos = transition[STATE_SYMBOL]!.routeInfos;
+  let router = route._router;
+  let qpMeta = router._queryParamsFor(routeInfos);
+  let changes = router._qpUpdates;
+  let qpUpdated = false;
+  let replaceUrl;
+
+  stashParamNames(router, routeInfos);
+
+  for (let qp of qpMeta.qps) {
+    let qpRoute = qp.route;
+    let controller = qpRoute.controller;
+    let presentKey = qp.urlKey in params && qp.urlKey;
+
+    // Do a reverse lookup to see if the changed query
+    // param URL key corresponds to a QP property on
+    // this controller.
+    let value;
+    let svalue: string | null | undefined;
+    if (changes.has(qp.urlKey)) {
+      // Value updated in/before setupController
+      value = get(controller, qp.prop);
+      svalue = qpRoute.serializeQueryParam(value, qp.urlKey, qp.type);
+    } else {
+      if (presentKey) {
+        svalue = params[presentKey];
+
+        if (svalue !== undefined) {
+          value = qpRoute.deserializeQueryParam(svalue, qp.urlKey, qp.type);
+        }
+      } else {
+        // No QP provided; use default value.
+        svalue = qp.serializedDefaultValue;
+        value = copyDefaultValue(qp.defaultValue);
+      }
+    }
+
+    // SAFETY: Since `_qp` is protected we can't infer the type
+    controller._qpDelegate = (get(qpRoute, '_qp') as Route['_qp']).states.inactive;
+
+    let thisQueryParamChanged = svalue !== qp.serializedValue;
+    if (thisQueryParamChanged) {
+      if (transition.queryParamsOnly && replaceUrl !== false) {
+        let options = qpRoute._optionsForQueryParam(qp);
+        let replaceConfigValue = get(options, 'replace');
+        if (replaceConfigValue) {
+          replaceUrl = true;
+        } else if (replaceConfigValue === false) {
+          // Explicit pushState wins over any other replaceStates.
+          replaceUrl = false;
+        }
+      }
+
+      set(controller, qp.prop, value);
+
+      qpUpdated = true;
+    }
+
+    // Stash current serialized value of controller.
+    qp.serializedValue = svalue;
+
+    let thisQueryParamHasDefaultValue = qp.serializedDefaultValue === svalue;
+    if (!thisQueryParamHasDefaultValue) {
+      finalParams.push({
+        value: svalue,
+        visible: true,
+        key: presentKey || qp.urlKey,
+      });
+    }
+  }
+
+  // Some QPs have been updated, and those changes need to be propogated
+  // immediately. Eventually, we should work on making this async somehow.
+  if (qpUpdated === true) {
+    flushAsyncObservers(false);
+  }
+
+  if (replaceUrl) {
+    transition.method('replace');
+  }
+
+  qpMeta.qps.forEach((qp: QueryParam) => {
+    // SAFETY: Since `_qp` is protected we can't infer the type
+    let routeQpMeta = get(qp.route, '_qp') as Route['_qp'];
+    let finalizedController = qp.route.controller;
+    finalizedController['_qpDelegate'] = get(routeQpMeta, 'states.active');
+  });
+
+  router._qpUpdates.clear();
+  return;
+}
diff --git a/packages/@ember/-internals/routing/route-managers/classic/substates.ts b/packages/@ember/-internals/routing/route-managers/classic/substates.ts
new file mode 100644
index 00000000000..fbac553893d
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/classic/substates.ts
@@ -0,0 +1,244 @@
+/**
+  Classic substate detection for the route manager. Walks the active
+  transition's route hierarchy looking for a `*_<state>` or `*.<state>` route
+  matching the route currently resolving (or erroring) and triggers an
+  intermediate transition into it.
+
+  Mirrors the original `defaultActionHandlers.loading` and
+  `defaultActionHandlers.error` + `forEachRouteAbove` machinery that lived
+  in `router_js`. Moved here because substates are a classic-interop concern,
+  not a router_js responsibility.
+*/
+
+import { assert } from '@ember/debug';
+import type Owner from '@ember/-internals/owner';
+import { getOwner } from '@ember/-internals/owner';
+import type Route from '@ember/routing/route';
+import type EmberRouter from '@ember/routing/router';
+import type { InternalRouteInfo } from 'router_js';
+import { getRouteManagement, hasClassicInterop, STATE_SYMBOL } from 'router_js';
+import type { ClassicRouteBucket } from './bucket';
+
+export type ActiveTransition = {
+  isActive: boolean;
+  pivotHandler?: unknown;
+  trigger?(ignoreFailure: boolean, name: string, ...args: unknown[]): void;
+  [STATE_SYMBOL]?: { routeInfos: InternalRouteInfo<Route>[] };
+};
+
+/**
+  Finds the name of the substate route if it exists for the given route. A
+  substate route is of the form `route_state`, such as `foo_loading`.
+
+  @private
+  @param {Route} route
+  @param {String} state
+  @return {String}
+*/
+function findRouteSubstateName(route: Route, state: string) {
+  let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
+
+  let managed = getRouteManagement(route);
+  if (managed === undefined || !hasClassicInterop(managed.manager)) {
+    return '';
+  }
+
+  let { routeName, fullRouteName, _router: router } = route;
+
+  let substateName = `${routeName}_${state}`;
+  let substateNameFull = `${fullRouteName}_${state}`;
+
+  return routeHasBeenDefined(owner, router, substateName, substateNameFull) ? substateNameFull : '';
+}
+
+/**
+  Finds the name of the state route if it exists for the given route. A state
+  route is of the form `route.state`, such as `foo.loading`. Properly Handles
+  `application` named routes.
+
+  @private
+  @param {Route} route
+  @param {String} state
+  @return {String}
+*/
+function findRouteStateName(route: Route, state: string) {
+  let owner = getOwner(route);
+  assert('Route is unexpectedly missing an owner', owner);
+
+  let managed = getRouteManagement(route);
+  if (managed === undefined || !hasClassicInterop(managed.manager)) {
+    return '';
+  }
+
+  let { routeName, fullRouteName, _router: router } = route;
+
+  let stateName = routeName === 'application' ? state : `${routeName}.${state}`;
+  let stateNameFull = fullRouteName === 'application' ? state : `${fullRouteName}.${state}`;
+
+  return routeHasBeenDefined(owner, router, stateName, stateNameFull) ? stateNameFull : '';
+}
+
+/**
+  Determines whether or not a route has been defined by checking that the route
+  is in the Router's map and the owner has a registration for that route.
+
+  @private
+  @param {Owner} owner
+  @param {Router} router
+  @param {String} localName
+  @param {String} fullName
+  @return {Boolean}
+*/
+function routeHasBeenDefined(owner: Owner, router: any, localName: string, fullName: string) {
+  let routerHasRoute = router.hasRoute(fullName);
+  let ownerHasRoute =
+    owner.factoryFor(`template:${localName}`) || owner.factoryFor(`route:${localName}`);
+  return routerHasRoute && ownerHasRoute;
+}
+
+/**
+  Fires the classic `loading` event for a slow transition. The event bubbles
+  through each route's `actions.loading` handler (public API — apps intercept
+  it for custom loading UI, or return `true` to keep bubbling); only if it
+  bubbles unhandled does the router's default `loading` action handler
+  dispatch back through `ClassicRouteManager.enterLoadingSubstate` to enter
+  the substate. Scheduled by the manager's `willEnter`; no-op if the
+  transition is no longer active by the time the timer fires.
+
+  @private
+  @param {ClassicRouteBucket} bucket
+  @param {Transition} transition
+ */
+export function fireLoadingEvent(bucket: ClassicRouteBucket, transition: ActiveTransition): void {
+  if (!transition.isActive) {
+    return;
+  }
+
+  transition.trigger?.(true, 'loading', transition, bucket.route);
+}
+
+/**
+  Look up the `loading` substate (if any) for the route that is loading
+  slowly and trigger an intermediate transition into it. No-op if the
+  transition is no longer active or no matching substate exists.
+
+  Reached via `ClassicRouteManager.enterLoadingSubstate`, which the router's
+  default `loading` action handler dispatches to through the classic-interop
+  contract once the loading event has bubbled unhandled.
+
+  @private
+  @param {EmberRouter} router
+  @param {Route|undefined} originRoute the route whose model is slow;
+    `undefined` when that route was never created (the walk then starts at
+    the transition's leaf)
+  @param {Transition} transition
+ */
+export function enterLoadingSubstate(
+  router: EmberRouter,
+  originRoute: Route | undefined,
+  transition: ActiveTransition
+): void {
+  if (!transition.isActive) {
+    return;
+  }
+
+  const substateName = findSubstateName(originRoute, transition, 'loading');
+  if (substateName) {
+    router.intermediateTransitionTo(substateName);
+  }
+}
+
+/**
+  Look up the `error` substate (if any) for the route that errored and
+  trigger an intermediate transition into it, passing the error along so the
+  error route's `model` hook receives it. Returns `true` if a substate was
+  entered (and the error should be considered handled), `false` otherwise.
+
+  Reached via `ClassicRouteManager.enterErrorSubstate`, which the router's
+  default `error` action handler dispatches to through the classic-interop
+  contract once the error has bubbled unhandled above the application route.
+
+  @private
+  @param {EmberRouter} router
+  @param {Route|undefined} originRoute the route that errored; `undefined`
+    when the erroring route never got created (the walk then starts at the
+    transition's leaf)
+  @param {Transition} transition
+  @param {Error} error the error that triggered this substate transition
+ */
+export function enterErrorSubstate(
+  router: EmberRouter,
+  originRoute: Route | undefined,
+  transition: ActiveTransition,
+  error: Error
+): boolean {
+  const substateName = findSubstateName(originRoute, transition, 'error');
+  if (!substateName) {
+    return false;
+  }
+
+  // Mark the error handled before transitioning so it is not re-raised
+  // after the substate has taken over rendering it.
+  router._markErrorAsHandled(error);
+  router.intermediateTransitionTo(substateName, error);
+  return true;
+}
+
+/**
+  Walk up from the route currently being resolved (or erroring) through the
+  transition's route hierarchy, returning the name of the closest matching
+  `*_<state>` or `*.<state>` substate, or an empty string if none is
+  defined.
+
+  Rules:
+  - For the originating route itself, only the substate form
+    (`foo_loading` / `foo_error`) is considered. The state form
+    (`foo.loading` / `foo.error`) is conceptually a child route and is
+    "below" where we are, so it should not be entered.
+  - For ancestor routes, both forms are considered.
+  - A `loading` walk stops at the transition's pivot route; an `error` walk
+    does not. This matches the classic router's asymmetry: loading substates
+    never appear above the pivot, but an error can be handled arbitrarily
+    far up.
+
+  @private
+  @param {Route|undefined} originRoute the route currently resolving (or
+    erroring); when `undefined` the walk starts at the transition's leaf and
+    considers both substate forms everywhere
+  @param {Transition} transition the active transition
+  @param {String} state the substate to look for, e.g. `loading` or `error`
+ */
+function findSubstateName(
+  originRoute: Route | undefined,
+  transition: ActiveTransition,
+  state: 'loading' | 'error'
+): string {
+  const routeInfos = transition[STATE_SYMBOL]?.routeInfos ?? [];
+  const pivotHandler = transition.pivotHandler;
+
+  const originIndex =
+    originRoute === undefined
+      ? -1
+      : routeInfos.findIndex((candidate) => candidate?.route === originRoute);
+  const originRouteInfo = originIndex >= 0 ? routeInfos[originIndex] : undefined;
+  const startIndex = originIndex >= 0 ? originIndex : routeInfos.length - 1;
+
+  for (let i = startIndex; i >= 0; i--) {
+    const ancestorRouteInfo = routeInfos[i];
+    const ancestorRoute = ancestorRouteInfo?.route;
+    if (!ancestorRoute) continue;
+
+    if (ancestorRouteInfo !== originRouteInfo) {
+      const stateName = findRouteStateName(ancestorRoute, state);
+      if (stateName) return stateName;
+    }
+
+    const substateName = findRouteSubstateName(ancestorRoute, state);
+    if (substateName) return substateName;
+
+    if (state === 'loading' && pivotHandler === ancestorRoute) break;
+  }
+
+  return '';
+}
diff --git a/packages/@ember/-internals/routing/route-managers/classic/wrapper.ts b/packages/@ember/-internals/routing/route-managers/classic/wrapper.ts
new file mode 100644
index 00000000000..f816d97d627
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/classic/wrapper.ts
@@ -0,0 +1,85 @@
+/**
+  The wrapper component returned by `ClassicRouteManager.getRouteWrapper`.
+  Module-stable — one instance serves every route. The outlet invokes it
+  with `@Component` (the per-bucket invokable), `@context` (the live model),
+  and `@bucket`; the template forwards model and controller onto the
+  invokable. Route identity for the outlet's stability check is carried by
+  the invokable, not the wrapper.
+*/
+
+import type {
+  CustomRenderNode,
+  InternalComponentCapabilities,
+  InternalComponentManager,
+  Reference,
+  WithCustomDebugRenderTree,
+} from '@glimmer/interfaces';
+import { setInternalComponentManager } from '@glimmer/manager/lib/internal/api';
+import { setComponentTemplate } from '@glimmer/manager/lib/public/template';
+import { NULL_REFERENCE } from '@glimmer/reference/lib/reference';
+import { precompileTemplate } from '@ember/template-compilation';
+
+// Renders the invokable passed in as `@Component` and forwards
+// `@model` / `@controller` onto it.
+const CLASSIC_WRAPPER_TEMPLATE = precompileTemplate(
+  `<@Component @model={{@context}} @controller={{@bucket.controller}} />`,
+  {
+    moduleName: 'packages/@ember/-internals/routing/route-managers/classic/wrapper.hbs',
+    strictMode: true,
+  }
+);
+
+class ClassicRouteWrapperManager
+  implements
+    InternalComponentManager<null, ClassicRouteWrapperDefinition>,
+    WithCustomDebugRenderTree<null, ClassicRouteWrapperDefinition>
+{
+  getCapabilities(): InternalComponentCapabilities {
+    // Match templateOnlyComponent's capabilities: no element, no args capture,
+    // no instance state.
+    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 '';
+  }
+
+  // Returning an empty array hides the wrapper from the debug render tree, so
+  // the tree shape stays the same as before the wrapper layer existed.
+  getDebugCustomRenderTree(): CustomRenderNode[] {
+    return [];
+  }
+
+  getSelf(): Reference {
+    return NULL_REFERENCE;
+  }
+
+  getDestroyable(): null {
+    return null;
+  }
+}
+
+export class ClassicRouteWrapperDefinition {}
+
+setInternalComponentManager(
+  new ClassicRouteWrapperManager(),
+  ClassicRouteWrapperDefinition.prototype
+);
+setComponentTemplate(CLASSIC_WRAPPER_TEMPLATE, ClassicRouteWrapperDefinition.prototype);
+
+// The one wrapper instance shared by every classic route.
+export const CLASSIC_ROUTE_WRAPPER = new ClassicRouteWrapperDefinition();
diff --git a/packages/@ember/-internals/routing/route-managers/registry.ts b/packages/@ember/-internals/routing/route-managers/registry.ts
new file mode 100644
index 00000000000..95be1939499
--- /dev/null
+++ b/packages/@ember/-internals/routing/route-managers/registry.ts
@@ -0,0 +1,77 @@
+/**
+  Registry that associates a `RouteManagerFactory` with a route definition
+  (typically a `Route` class).
+*/
+
+import { DEBUG } from '@glimmer/env';
+import { debugAssert } from '@glimmer/global-context';
+import type { RouteManagerFactory } from './api';
+
+const ROUTE_MANAGERS = new WeakMap<object, RouteManagerFactory>();
+
+/**
+  Associates a `RouteManagerFactory` with `definition`. The router calls the
+  factory the first time it needs a manager for any route whose class extends
+  (directly or via prototype chain) `definition`.
+
+  ```ts
+  import { setRouteManager } from '@ember/routing';
+
+  class MyRouteManager { ... }
+
+  setRouteManager((owner) => new MyRouteManager(owner), MyRoute);
+  ```
+
+  @param factory Factory invoked once per owner with that owner as its only
+    argument. Must return an object whose `capabilities` field was produced by
+    `routeCapabilities`.
+  @param definition The route class or object the manager applies to.
+ */
+export function setRouteManager<Def extends object>(
+  factory: RouteManagerFactory,
+  definition: Def
+): Def {
+  if (DEBUG) {
+    debugAssert(
+      definition !== null && (typeof definition === 'object' || typeof definition === 'function'),
+      `Attempted to set a route manager on a non-object value. Route managers can only be associated with objects or functions. Value was ${definition}`
+    );
+
+    debugAssert(
+      !ROUTE_MANAGERS.has(definition),
+      `Attempted to set a route manager more than once on the same value. Each route definition can only have one manager. Value was ${definition}`
+    );
+  }
+
+  ROUTE_MANAGERS.set(definition, factory);
+  return definition;
+}
+
+/**
+  Returns the `RouteManagerFactory` registered for `definition`, walking the
+  prototype chain. Returns `undefined` if no manager is registered.
+
+  Note that this only returns the factory, the router is responsible for
+  invoking it (typically once per owner) and caching the resulting manager
+  instance.
+
+  Not to be confused with `getRouteManagement` (router_js): this registry is
+  keyed by the route **class** and answers "which kind of manager handles
+  routes of this class?", while `getRouteManagement` is keyed by a route
+  **instance** and returns the live manager instance + bucket driving it.
+  `EmberRouter.getRoute` connects the two — it resolves the factory here,
+  instantiates the manager and bucket, then records the per-instance result
+  via `associateRouteManagement`.
+ */
+export function getRouteManager(definition: object): RouteManagerFactory | undefined {
+  let pointer: object | null = definition;
+  while (pointer !== null) {
+    const factory = ROUTE_MANAGERS.get(pointer);
+    if (factory !== undefined) {
+      return factory;
+    }
+    pointer = Object.getPrototypeOf(pointer) as object | null;
+  }
+
+  return undefined;
+}
diff --git a/packages/@ember/routing/index.ts b/packages/@ember/routing/index.ts
index be0dd6e698f..effc98f8488 100644
--- a/packages/@ember/routing/index.ts
+++ b/packages/@ember/routing/index.ts
@@ -1 +1,22 @@
 export { default as LinkTo } from '@ember/-internals/glimmer/lib/components/link-to';
+
+export { routeCapabilities } from '@ember/-internals/routing/route-managers/api';
+export { setRouteManager } from '@ember/-internals/routing/route-managers/registry';
+
+export type {
+  RouteManager,
+  RouteManagerFactory,
+  RouteStateBucket,
+  RouteCapabilities,
+  RouteCapabilitiesVersions,
+  NavigationState,
+  NavigationActions,
+  AsyncNavigationState,
+  WillEnterState,
+  EnterState,
+  DidEnterState,
+  WillExitState,
+  ExitState,
+  DidExitState,
+  CreateRouteArgs,
+} from '@ember/-internals/routing/route-managers/api';
diff --git a/packages/@ember/routing/lib/router_state.ts b/packages/@ember/routing/lib/router_state.ts
index 4f9475d9e2d..2e2e20e0e66 100644
--- a/packages/@ember/routing/lib/router_state.ts
+++ b/packages/@ember/routing/lib/router_state.ts
@@ -1,17 +1,17 @@
-import type { ModelFor, TransitionState } from 'router_js';
+import type { BaseRoute, ModelFor, TransitionState } from 'router_js';
 import type Router from 'router_js';
 import { shallowEqual } from './utils';
 import type Route from '@ember/routing/route';
 import type EmberRouter from '@ember/routing/router';
 
 export default class RouterState {
-  router: Router<Route>;
+  router: Router<BaseRoute>;
   emberRouter: EmberRouter;
-  routerJsState: TransitionState<Route>;
+  routerJsState: TransitionState<BaseRoute>;
   constructor(
     emberRouter: EmberRouter,
-    router: Router<Route>,
-    routerJsState: TransitionState<Route>
+    router: Router<BaseRoute>,
+    routerJsState: TransitionState<BaseRoute>
   ) {
     this.emberRouter = emberRouter;
     this.router = router;
diff --git a/packages/@ember/routing/lib/utils.ts b/packages/@ember/routing/lib/utils.ts
index 6f01ef3aab2..669c8b42eba 100644
--- a/packages/@ember/routing/lib/utils.ts
+++ b/packages/@ember/routing/lib/utils.ts
@@ -3,12 +3,14 @@ import { getOwner } from '@ember/-internals/owner';
 import type { ControllerQueryParam, ControllerQueryParamType } from '@ember/controller';
 import { assert } from '@ember/debug';
 import EngineInstance from '@ember/engine/instance';
-import type { InternalRouteInfo } from 'router_js';
+import type { BaseRoute, InternalRouteInfo } from 'router_js';
 import type Router from 'router_js';
 import { STATE_SYMBOL } from 'router_js';
 import type { ExtendedInternalRouteInfo } from '@ember/routing/route';
 import type Route from '@ember/routing/route';
 import type EmberRouter from '@ember/routing/router';
+import { hasClassicInterop } from '@ember/-internals/routing/route-managers/api';
+import type { BaseRoute as IRoute } from 'router_js';
 
 const ALL_PERIODS_REGEX = /\./g;
 
@@ -65,7 +67,7 @@ export function extractRouteArgs(args: RouteArgs): ExtractedArgs {
   return { routeName, models, queryParams };
 }
 
-export function getActiveTargetName(router: Router<Route>): string {
+export function getActiveTargetName(router: Router<BaseRoute>): string {
   let routeInfos = router.activeTransition
     ? router.activeTransition[STATE_SYMBOL]!.routeInfos
     : router.state!.routeInfos;
@@ -103,8 +105,16 @@ export function stashParamNames(
 
     routeInfo['_names'] = names;
 
-    let route = routeInfo.route!;
-    route._stashNames(routeInfo, dynamicParent!);
+    // Dispatch through the route manager so the router talks to the manager
+    // boundary rather than calling the classic Route directly.
+    let { manager, bucket } = routeInfo;
+    if (manager !== undefined && bucket !== undefined && hasClassicInterop(manager)) {
+      manager.stashNames(
+        bucket,
+        routeInfo as unknown as InternalRouteInfo<IRoute>,
+        dynamicParent! as unknown as InternalRouteInfo<IRoute>
+      );
+    }
   }
 
   routeInfos['_namesStashed'] = true;
diff --git a/packages/@ember/routing/route.ts b/packages/@ember/routing/route.ts
index 28831d60328..cd9751378fd 100644
--- a/packages/@ember/routing/route.ts
+++ b/packages/@ember/routing/route.ts
@@ -12,7 +12,7 @@ import getProperties from '@ember/-internals/metal/lib/get_properties';
 import setProperties from '@ember/-internals/metal/lib/set_properties';
 import EmberObject from '@ember/object';
 import Evented from '@ember/object/evented';
-import { A as emberA } from '@ember/array';
+import { copyDefaultValue } from '@ember/-internals/routing/route-managers/classic/query-params';
 import ActionHandler from '@ember/-internals/runtime/lib/mixins/action_handler';
 import typeOf from '@ember/utils/lib/type-of';
 import { isProxy } from '@ember/-internals/utils/lib/is_proxy';
@@ -21,17 +21,22 @@ 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';
+import { setRouteManager } from '@ember/-internals/routing/route-managers/registry';
+import { ClassicRouteManager } from '@ember/-internals/routing/route-managers/classic/manager';
+import { hasClassicInterop } from '@ember/-internals/routing/route-managers/api';
+import type {
+  BaseRoute,
+  InternalRouteInfo,
+  BaseRoute as IRoute,
+  Transition,
+  TransitionState,
+} from 'router_js';
+import { getRouteManagement, PARAMS_SYMBOL, STATE_SYMBOL } from 'router_js';
+import type { default as EmberRouter } from '@ember/routing/router';
 import { default as generateController } from './lib/generate_controller';
 import type { ExpandedControllerQueryParam, NamedRouteArgs } from './lib/utils';
 import {
@@ -45,6 +50,23 @@ export interface ExtendedInternalRouteInfo<R extends Route> extends InternalRout
   _names?: unknown[];
 }
 
+export interface QueryParam {
+  prop: string;
+  urlKey: string;
+  type: string;
+  route: Route;
+  parts?: string[];
+  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+  values: {} | null;
+  scopedPropertyName: string;
+  scope: string;
+  defaultValue: unknown;
+  undecoratedDefaultValue: unknown;
+  serializedValue: string | null | undefined;
+  serializedDefaultValue: string | null | undefined;
+  controllerName: string;
+}
+
 export type QueryParamMeta = {
   qps: QueryParam[];
   map: Record<string, QueryParam>;
@@ -56,7 +78,7 @@ export type QueryParamMeta = {
   };
 };
 
-type RouteTransitionState = TransitionState<Route> & {
+type RouteTransitionState = TransitionState<BaseRoute> & {
   fullQueryParams?: Record<string, unknown>;
   queryParamsFor?: Record<string, Record<string, unknown>>;
 };
@@ -64,9 +86,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
 */
@@ -277,7 +296,6 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
 
   _router!: EmberRouter;
   declare _topLevelViewTemplate: any;
-  declare _environment: any;
 
   constructor(owner?: Owner) {
     super(owner);
@@ -288,7 +306,6 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
       this._router = router as EmberRouter;
       this._bucketCache = bucketCache as BucketCache;
       this._topLevelViewTemplate = owner.lookup('template:-outlet');
-      this._environment = owner.lookup('-environment:main');
     }
   }
 
@@ -766,17 +783,6 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
     return this as unknown as void;
   }
 
-  /**
-    @private
-
-    @method exit
-  */
-  exit(transition?: Transition) {
-    this.deactivate(transition);
-    this.trigger('deactivate', transition);
-    this.teardownViews();
-  }
-
   /**
     @private
 
@@ -791,17 +797,6 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
     this.resetController(controller, isExiting, transition);
   }
 
-  /**
-    @private
-
-    @method enter
-  */
-  enter(transition: Transition) {
-    this[RENDER_STATE] = undefined;
-    this.activate(transition);
-    this.trigger('activate', transition);
-  }
-
   /**
     This event is triggered when the router enters the route. It is
     not executed when the model for the route changes.
@@ -912,6 +907,27 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
     return this._router._routerMicrolib.refresh(this);
   }
 
+  /**
+    Resolve and assign this route's controller. Used by the route
+    manager during `willEnter` so the controller is available when the
+    route template renders, before `setup` runs
+
+    @method _initController
+    @private
+   */
+  _initController(): Controller {
+    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'];
+    addQueryParamsObservers(controller, queryParams.propertyNames);
+    this.controller = controller;
+    return controller;
+  }
+
   /**
     This hook is the entry point for router.js
 
@@ -919,21 +935,11 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
     @method setup
   */
   setup(context: Model | undefined, transition: Transition) {
-    let controllerName = this.controllerName || this.routeName;
-    let definedController = this.controllerFor(controllerName, true);
-    let controller = definedController ?? this.generateController(controllerName);
+    let controller = this._initController();
 
     // SAFETY: Since `_qp` is protected we can't infer the type
     let queryParams = get(this, '_qp') as Route<Model>['_qp'];
 
-    // Assign the route's controller so that it can more easily be
-    // referenced in action handlers. Side effects. Side effects everywhere.
-    if (!this.controller) {
-      let propNames = queryParams.propertyNames;
-      addQueryParamsObservers(controller, propNames);
-      this.controller = controller;
-    }
-
     let states = queryParams.states;
 
     controller._qpDelegate = states.allowOverrides;
@@ -962,9 +968,9 @@ class Route<Model = unknown> extends EmberObject.extend(ActionHandler, Evented)
 
     this.setupController(controller, context, transition);
 
-    if (this._environment.options.shouldRender) {
-      this[RENDER]();
-    }
+    // `_setOutlets` itself is the single `shouldRender` gate (it returns
+    // early when the app was booted with `shouldRender: false`).
+    once(this._router, '_setOutlets');
 
     // Setup can cause changes to QPs which need to be propogated immediately in
     // some situations. Eventually, we should work on making these async somehow.
@@ -1464,18 +1470,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 +1480,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 +1783,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;
@@ -1920,6 +1822,7 @@ function getQueryParamsFor(route: Route, state: RouteTransitionState): Record<st
   // Copy over all the query params for this route/controller into params hash.
   // SAFETY: Since `_qp` is protected we can't infer the type
   let qps = (get(route, '_qp') as Route['_qp']).qps;
+
   for (let qp of qps) {
     // Put deserialized qp on params hash.
     let qpValueWasPassedIn = qp.prop in fullQueryParams;
@@ -1931,15 +1834,6 @@ function getQueryParamsFor(route: Route, state: RouteTransitionState): Record<st
   return params;
 }
 
-// FIXME: This should probably actually return a `NativeArray` if the passed in value is an Array.
-function copyDefaultValue<T>(value: T): T {
-  if (Array.isArray(value)) {
-    // SAFETY: We lost the type data about the array if we don't cast.
-    return emberA(value.slice()) as unknown as T;
-  }
-  return value;
-}
-
 /*
   Merges all query parameters from a controller with those from
   a route, returning a new object and avoiding any mutations to
@@ -2103,24 +1997,15 @@ Route.reopen({
     @private
    */
     // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-    queryParamsDidChange<T>(this: Route<T>, changed: {}, _totalPresent: unknown, removed: {}) {
-      // SAFETY: Since `_qp` is protected we can't infer the type
-      let qpMap = (get(this, '_qp') as Route<T>['_qp']).map;
-
-      let totalChanged = Object.keys(changed).concat(Object.keys(removed));
-      for (let change of totalChanged) {
-        let qp = qpMap[change];
-        if (qp) {
-          let options = this._optionsForQueryParam(qp);
-          assert('options exists', options && typeof options === 'object');
-          if ((get(options, 'refreshModel') as boolean) && this._router.currentState) {
-            this.refresh();
-            break;
-          }
-        }
-      }
-
-      return true;
+    queryParamsDidChange<T>(this: Route<T>, changed: {}, totalPresent: unknown, removed: {}) {
+      // Logic lives on the route manager so the router talks to the manager
+      // boundary rather than the classic Route directly.
+      let managed = getRouteManagement(this);
+      assert(
+        'Expected a classic-interop route manager to handle queryParamsDidChange',
+        managed !== undefined && hasClassicInterop(managed.manager)
+      );
+      return managed.manager.queryParamsDidChange(managed.bucket, changed, totalPresent, removed);
     },
 
     finalizeQueryParamChange<T>(
@@ -2130,107 +2015,23 @@ Route.reopen({
       finalParams: {}[],
       transition: Transition
     ) {
-      if (this.fullRouteName !== 'application') {
-        return true;
-      }
-
-      // Transition object is absent for intermediate transitions.
-      if (!transition) {
-        return;
-      }
-
-      let routeInfos = transition[STATE_SYMBOL]!.routeInfos;
-      let router = this._router;
-      let qpMeta = router._queryParamsFor(routeInfos);
-      let changes = router._qpUpdates;
-      let qpUpdated = false;
-      let replaceUrl;
-
-      stashParamNames(router, routeInfos);
-
-      for (let qp of qpMeta.qps) {
-        let route = qp.route;
-        let controller = route.controller;
-        let presentKey = qp.urlKey in params && qp.urlKey;
-
-        // Do a reverse lookup to see if the changed query
-        // param URL key corresponds to a QP property on
-        // this controller.
-        let value;
-        let svalue: string | null | undefined;
-        if (changes.has(qp.urlKey)) {
-          // Value updated in/before setupController
-          value = get(controller, qp.prop);
-          svalue = route.serializeQueryParam(value, qp.urlKey, qp.type);
-        } else {
-          if (presentKey) {
-            svalue = params[presentKey];
-
-            if (svalue !== undefined) {
-              value = route.deserializeQueryParam(svalue, qp.urlKey, qp.type);
-            }
-          } else {
-            // No QP provided; use default value.
-            svalue = qp.serializedDefaultValue;
-            value = copyDefaultValue(qp.defaultValue);
-          }
-        }
-
-        // SAFETY: Since `_qp` is protected we can't infer the type
-        controller._qpDelegate = (get(route, '_qp') as Route<T>['_qp']).states.inactive;
-
-        let thisQueryParamChanged = svalue !== qp.serializedValue;
-        if (thisQueryParamChanged) {
-          if (transition.queryParamsOnly && replaceUrl !== false) {
-            let options = route._optionsForQueryParam(qp);
-            let replaceConfigValue = get(options, 'replace');
-            if (replaceConfigValue) {
-              replaceUrl = true;
-            } else if (replaceConfigValue === false) {
-              // Explicit pushState wins over any other replaceStates.
-              replaceUrl = false;
-            }
-          }
-
-          set(controller, qp.prop, value);
-
-          qpUpdated = true;
-        }
-
-        // Stash current serialized value of controller.
-        qp.serializedValue = svalue;
-
-        let thisQueryParamHasDefaultValue = qp.serializedDefaultValue === svalue;
-        if (!thisQueryParamHasDefaultValue) {
-          finalParams.push({
-            value: svalue,
-            visible: true,
-            key: presentKey || qp.urlKey,
-          });
-        }
-      }
-
-      // Some QPs have been updated, and those changes need to be propogated
-      // immediately. Eventually, we should work on making this async somehow.
-      if (qpUpdated === true) {
-        flushAsyncObservers(false);
-      }
-
-      if (replaceUrl) {
-        transition.method('replace');
-      }
-
-      qpMeta.qps.forEach((qp: QueryParam) => {
-        // SAFETY: Since `_qp` is protected we can't infer the type
-        let routeQpMeta = get(qp.route, '_qp') as Route<T>['_qp'];
-        let finalizedController = qp.route.controller;
-        finalizedController['_qpDelegate'] = get(routeQpMeta, 'states.active');
-      });
-
-      router._qpUpdates.clear();
-      return;
+      // Logic lives on the route manager so the router talks to the manager
+      // boundary rather than the classic Route directly.
+      let managed = getRouteManagement(this);
+      assert(
+        'Expected a classic-interop route manager to handle finalizeQueryParamChange',
+        managed !== undefined && hasClassicInterop(managed.manager)
+      );
+      return managed.manager.finalizeQueryParamChange(
+        managed.bucket,
+        params,
+        finalParams,
+        transition
+      );
     },
   },
 });
 
+setRouteManager((owner) => new ClassicRouteManager(owner), Route);
+
 export default Route;
diff --git a/packages/@ember/routing/router.ts b/packages/@ember/routing/router.ts
index 7f6d760dd9d..23a2e0f30aa 100644
--- a/packages/@ember/routing/router.ts
+++ b/packages/@ember/routing/router.ts
@@ -10,6 +10,10 @@ import { set } from '@ember/-internals/metal/lib/property_set';
 import type { FactoryManager } from '@ember/-internals/owner';
 import type Owner from '@ember/owner';
 import { getOwner } from '@ember/owner';
+import { getRouteManager } from '@ember/-internals/routing/route-managers/registry';
+import type { RouteManager } from '@ember/-internals/routing/route-managers/api';
+import type { RouteManagement } from 'router_js';
+import { hasClassicInterop } from '@ember/-internals/routing/route-managers/api';
 import { default as BucketCache } from './lib/cache';
 import { default as DSL, type DSLCallback } from './lib/dsl';
 import RouterState from './lib/router_state';
@@ -31,17 +35,19 @@ 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 { cancel, later, once, run } from '@ember/runloop';
+import { associateDestroyableChild } from '@glimmer/destroyable';
 import { DEBUG } from '@glimmer/env';
 import {
-  type QueryParamMeta,
   type default as Route,
+  type QueryParam,
+  type QueryParamMeta,
   defaultSerialize,
   getFullQueryParams,
-  getRenderState,
   hasDefaultSerialize,
 } from '@ember/routing/route';
 import type {
+  BaseRoute,
   InternalRouteInfo,
   ModelFor,
   RouteInfo,
@@ -50,8 +56,12 @@ import type {
   TransitionError,
   TransitionState,
 } from 'router_js';
-import Router, { logAbort, STATE_SYMBOL } from 'router_js';
-import type { Timer } from 'backburner.js';
+import Router, {
+  associateRouteManagement,
+  getRouteManagement,
+  logAbort,
+  STATE_SYMBOL,
+} from 'router_js';
 import EngineInstance from '@ember/engine/instance';
 import type { QueryParams } from 'route-recognizer';
 import type { AnyFn, MethodNamesOf, OmitFirst } from '@ember/-internals/utility-types';
@@ -65,8 +75,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);
 
@@ -110,22 +118,10 @@ if (DEBUG) {
   };
 }
 
-export interface QueryParam {
-  prop: string;
-  urlKey: string;
-  type: string;
-  route: Route;
-  parts?: string[];
-  // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-  values: {} | null;
-  scopedPropertyName: string;
-  scope: string;
-  defaultValue: unknown;
-  undecoratedDefaultValue: unknown;
-  serializedValue: string | null | undefined;
-  serializedDefaultValue: string | null | undefined;
-  controllerName: string;
-}
+// `QueryParam` now lives in `@ember/routing/route`. It was historically
+// exported from `@ember/routing/router`, so re-export it here to preserve that
+// published deep-import path.
+export type { QueryParam };
 
 function K(this: Router<Route>) {
   return this;
@@ -175,7 +171,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
   // Set with reopen to allow overriding via extend
   declare location: (keyof LocationRegistry & string) | EmberLocation;
 
-  _routerMicrolib!: Router<Route>;
+  _routerMicrolib!: Router<BaseRoute>;
   _didSetupRouter = false;
   _initialTransitionStarted = false;
 
@@ -197,7 +193,14 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
   _engineInfoByRoute = Object.create(null);
   _routerService: RouterService;
 
-  _slowTransitionTimer: Timer | null = null;
+  // Per-owner caches for the manager-driven route lookup path. Route
+  // management ({manager, bucket} pairs) is keyed by owner first so that
+  // engine routes (which can reuse local names) stay isolated; a cache hit
+  // skips factory resolution entirely. Manager instances are similarly keyed first
+  // by owner, then by the factory function that produced them, so that
+  // routes sharing a factory share one manager within a given owner.
+  #routeManagement = new WeakMap<Owner, Map<string, RouteManagement>>();
+  #routeManagerInstances = new WeakMap<Owner, WeakMap<object, RouteManager>>();
 
   private namespace: any;
 
@@ -262,7 +265,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     return this;
   }
 
-  static _routePath(routeInfos: InternalRouteInfo<Route>[]) {
+  static _routePath(routeInfos: InternalRouteInfo<BaseRoute>[]) {
     let path: string[] = [];
 
     // We have to handle coalescing resource names that
@@ -318,62 +321,131 @@ 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);
+  /**
+    Returns the `Route` instance for `name`, creating it through the route
+    manager registered against the route class on first access. Subsequent
+    calls return the same instance without re-running factory resolution.
 
-    class PrivateRouter extends Router<Route> {
-      getRoute(name: string): Route {
-        let routeName = name;
-        let routeOwner = owner;
-        let engineInfo = router._engineInfoByRoute[routeName];
+    Engine routes are resolved by their fully-qualified name via
+    `_engineInfoByRoute`.
 
-        if (engineInfo) {
-          let engineInstance = router._getEngineInstance(engineInfo);
+    @private
+   */
+  getRoute(name: string): unknown {
+    // Guard against a stringified `undefined` route name: without this, the
+    // auto-generation path below would happily register and hand back a junk
+    // `route:undefined`.
+    if (name === 'undefined') {
+      return undefined;
+    }
 
-          routeOwner = engineInstance;
-          routeName = engineInfo.localFullName;
-        }
+    assert('Name should not start with "route:"', !name.startsWith('route:'));
 
-        let fullRouteName = `route:${routeName}` as const;
+    let mainOwner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', mainOwner);
 
-        assert('Route is unexpectedly missing an owner', routeOwner);
+    let routeOwner: Owner = mainOwner;
+    let routeName = name;
 
-        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;
-        }
+    let ownerRouteManagement = this.#routeManagement.get(routeOwner);
+    if (!ownerRouteManagement) {
+      ownerRouteManagement = new Map();
+      this.#routeManagement.set(routeOwner, ownerRouteManagement);
+    }
 
-        seen[name] = true;
+    let managed = ownerRouteManagement.get(routeName);
 
-        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;
+    if (managed === undefined) {
+      const fullRouteName = `route:${routeName}` as const;
+      let factoryManager = routeOwner.factoryFor(fullRouteName);
+      if (!factoryManager) {
+        // Auto-generate a default route if none is registered.
+        // SAFETY: configured in commonSetupRegistry in @ember/application/lib.
+        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);
+      const RouteClass = factoryManager.class as object;
 
-        if (engineInfo && !hasDefaultSerialize(route)) {
-          throw new Error(
-            'Defining a custom serialize method on an Engine route is not supported.'
-          );
-        }
+      if (routeOwner !== mainOwner && !hasDefaultSerialize((RouteClass as any).prototype)) {
+        throw new Error('Defining a custom serialize method on an Engine route is not supported.');
+      }
+
+      const managerFactory = getRouteManager(RouteClass);
+      assert(
+        `No route manager is registered for route '${routeName}'. ` +
+          `Use \`setRouteManager\` to associate a manager with the route class.`,
+        managerFactory !== undefined
+      );
+
+      let ownerManagers = this.#routeManagerInstances.get(routeOwner);
+      if (!ownerManagers) {
+        ownerManagers = new WeakMap();
+        this.#routeManagerInstances.set(routeOwner, ownerManagers);
+      }
+      let manager = ownerManagers.get(managerFactory);
+      if (manager === undefined) {
+        manager = managerFactory(routeOwner);
+        ownerManagers.set(managerFactory, manager);
+      }
+
+      const bucket = manager.createRoute(RouteClass, { name: routeName });
+
+      const destroyable = manager.getDestroyable(bucket);
+      if (destroyable !== null) {
+        associateDestroyableChild(routeOwner, destroyable);
+      }
+
+      managed = { manager, bucket };
+      ownerRouteManagement.set(routeName, managed);
+    }
+
+    const route = managed.manager.getRoute(managed.bucket);
+
+    // Register the route → {manager, bucket} association that router_js
+    // dispatches lifecycle hooks through. Owned by the router so managers
+    // don't have to stamp anything onto their route objects. Registered on
+    // every call (cheap WeakMap set) because a manager may instantiate its
+    // route lazily rather than at `createRoute` time.
+    if (typeof route === 'object' && route !== null) {
+      associateRouteManagement(route, managed.manager, managed.bucket);
+    }
+
+    return route;
+  }
 
-        return 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<BaseRoute> {
+      getRoute(name: string) {
+        // All route instantiation, manager dispatch, and engine-owner
+        // resolution lives on EmberRouter.getRoute. This wrapper just
+        // delegates.
+        const route = router.getRoute(name);
+        assert(`Expected to find route '${name}'`, route !== undefined);
+        // SAFETY: the manager contract types routes as `unknown`; this is the
+        // one boundary where they enter router_js's generic machinery. All
+        // manager/bucket dispatch goes through the routeInfo association, so
+        // nothing downstream depends on the route's actual shape.
+        return route as BaseRoute;
       }
 
       getSerializer(name: string) {
@@ -451,7 +523,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
 
       transitionDidError(error: TransitionError, transition: Transition) {
         if (error.wasAborted || transition.isAborted) {
-          // If the error was a transition erorr or the transition aborted
+          // If the error was a transition error or the transition aborted
           // log the abort.
           return logAbort(transition);
         } else {
@@ -485,6 +557,59 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
           this.updateURL(url);
         }
       }
+
+      // The manager-driven transition lifecycle (onTransitionSettled and
+      // friends) is inherited from the base router_js Router; only the
+      // Ember-specific hooks are provided here.
+
+      protected override isRouterDestroyed(): boolean {
+        return router.isDestroying || router.isDestroyed;
+      }
+
+      #pendingOutletFlush: ReturnType<typeof later> | null = null;
+
+      protected override scheduleOutletUpdate(immediate = false): void {
+        if (immediate) {
+          if (this.#pendingOutletFlush !== null) {
+            cancel(this.#pendingOutletFlush);
+            this.#pendingOutletFlush = null;
+          }
+          once(router as any, '_setOutlets');
+          return;
+        }
+
+        // Incremental (mid-transition) passes are coalesced onto the next
+        // timer tick: an instant-resolving transition never yields the event
+        // loop, so its per-route readiness folds into the settle-time render
+        // (12 passes down to 2, measured on a 9-deep transition); a genuinely
+        // pending model yields, the timer fires, and parents still render
+        // progressively above the pending child.
+        //
+        // `once` would not coalesce here: each route's readiness arrives via
+        // a native promise callback, which backburner wraps in its own
+        // autorun, and `once` only dedupes within a single run loop — one
+        // pass per resolving route, the exact behavior this replaces. A
+        // timer lives outside any one run loop, so the pending-handle guard
+        // below dedupes across all of them. `later` (not setTimeout) so the
+        // pass is cancelable and visible to test waiters.
+        if (this.#pendingOutletFlush !== null) {
+          return;
+        }
+        this.#pendingOutletFlush = later(() => {
+          this.#pendingOutletFlush = null;
+          if (router.isDestroying || router.isDestroyed) {
+            return;
+          }
+          router._setOutlets();
+        }, 0);
+      }
+
+      cancelPendingOutletUpdate(): void {
+        if (this.#pendingOutletFlush !== null) {
+          cancel(this.#pendingOutletFlush);
+          this.#pendingOutletFlush = null;
+        }
+      }
     }
 
     let routerMicrolib = (this._routerMicrolib = new PrivateRouter());
@@ -602,6 +727,18 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
       return;
     }
 
+    // Skip rendering when the application instance was booted with
+    // `shouldRender: false`. The full transition lifecycle still runs
+    // (resolve, controllers, models) but no DOM is created. Used by
+    // `application.visit()` in non-rendering scenarios such as fastboot
+    // prefetching or route-only unit tests. This is the single
+    // `shouldRender` gate for the render path. (`environment` is also
+    // reused by the toplevel-view creation below.)
+    let environment = getOwner(this)?.lookup('-environment:main') as BootEnvironment | undefined;
+    if (environment?.options?.shouldRender === false) {
+      return;
+    }
+
     let routeInfos = this._routerMicrolib.currentRouteInfos;
     if (!routeInfos) {
       return;
@@ -611,32 +748,22 @@ 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;
-        }
+      let { manager, bucket } = routeInfo;
+      assert('Expected active route to have a manager and bucket', manager && bucket);
+      let render = manager.getRenderState(bucket);
+
+      let state: OutletState = {
+        render,
+        outlets: { main: undefined },
+      };
 
-        parent = state;
+      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
@@ -662,7 +789,6 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
       let application = owner.lookup('application:main') as Owner | undefined;
       assert('[BUG] unexpectedly missing `application:-main`', application !== undefined);
 
-      let environment = owner.lookup('-environment:main') as BootEnvironment | undefined;
       assert('[BUG] unexpectedly missing `-environment:main`', environment !== undefined);
 
       let template = owner.lookup('template:-outlet') as Template | undefined;
@@ -835,6 +961,10 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
   }
 
   willDestroy() {
+    // A deferred incremental outlet pass must not fire into a tearing-down
+    // renderer.
+    (this._routerMicrolib as { cancelPendingOutletUpdate?(): void })?.cancelPendingOutletUpdate?.();
+
     if (this._toplevelView) {
       this._toplevelView.destroy();
       this._toplevelView = null;
@@ -928,7 +1058,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     @return {Void}
   */
   _serializeQueryParams(
-    routeInfos: InternalRouteInfo<Route>[],
+    routeInfos: InternalRouteInfo<BaseRoute>[],
     queryParams: Record<string, unknown>
   ): asserts queryParams is Record<string, string | null | undefined> {
     forEachQueryParam(
@@ -938,7 +1068,17 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
       (key: string, value: unknown, qp: QueryParam | undefined) => {
         if (qp) {
           delete queryParams[key];
-          queryParams[qp.urlKey] = qp.route.serializeQueryParam(value, qp.urlKey, qp.type);
+          let managed = getRouteManagement(qp.route);
+          assert(
+            'Expected a classic-interop route manager to serialize a query param',
+            managed !== undefined && hasClassicInterop(managed.manager)
+          );
+          queryParams[qp.urlKey] = managed.manager.serializeQueryParam(
+            managed.bucket,
+            value,
+            qp.urlKey,
+            qp.type
+          );
         } else if (value === undefined) {
           return; // We don't serialize undefined values
         } else {
@@ -976,7 +1116,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     @return {Void}
   */
   _deserializeQueryParams(
-    routeInfos: InternalRouteInfo<Route>[],
+    routeInfos: InternalRouteInfo<BaseRoute>[],
     queryParams: Record<string, unknown>
   ) {
     forEachQueryParam(
@@ -988,7 +1128,17 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
         // because all values will be treated as strings
         if (qp) {
           delete queryParams[key];
-          queryParams[qp.prop] = qp.route.deserializeQueryParam(value, qp.urlKey, qp.type);
+          let managed = getRouteManagement(qp.route);
+          assert(
+            'Expected a classic-interop route manager to deserialize a query param',
+            managed !== undefined && hasClassicInterop(managed.manager)
+          );
+          queryParams[qp.prop] = managed.manager.deserializeQueryParam(
+            managed.bucket,
+            value,
+            qp.urlKey,
+            qp.type
+          );
         }
       }
     );
@@ -1026,7 +1176,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     @return {Void}
   */
   _pruneDefaultQueryParamValues(
-    routeInfos: InternalRouteInfo<Route>[],
+    routeInfos: InternalRouteInfo<BaseRoute>[],
     queryParams: Record<string, string | null | undefined>
   ) {
     let qps = this._queryParamsFor(routeInfos);
@@ -1133,9 +1283,14 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     @param {RouteInfo} routeInfo
     @return {Object}
   */
-  _getQPMeta(routeInfo: InternalRouteInfo<Route>) {
-    let route = routeInfo.route;
-    return route && (get(route, '_qp') as Route['_qp']);
+  _getQPMeta(routeInfo: InternalRouteInfo<BaseRoute>) {
+    let { manager, bucket } = routeInfo;
+    if (manager === undefined || bucket === undefined || !hasClassicInterop(manager)) {
+      return undefined;
+    }
+    // The manager contract types `qp()` as `unknown`. Having
+    // confirmed classic interop, narrow it to the concrete type.
+    return manager.qp(bucket) as QueryParamMeta;
   }
 
   /**
@@ -1147,7 +1302,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     @param {Array<RouteInfo>} routeInfos
     @return {Object}
    */
-  _queryParamsFor(routeInfos: InternalRouteInfo<Route>[]) {
+  _queryParamsFor(routeInfos: InternalRouteInfo<BaseRoute>[]) {
     let routeInfoLength = routeInfos.length;
     let leafRouteName = routeInfos[routeInfoLength - 1]!.name;
     let cached = this._qpCache[leafRouteName];
@@ -1254,7 +1409,7 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
     @return {Void}
   */
   _hydrateUnsuppliedQueryParams(
-    state: TransitionState<Route>,
+    state: TransitionState<BaseRoute>,
     queryParams: QueryParams,
     _fromRouterService: boolean
   ): void {
@@ -1318,43 +1473,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) {
@@ -1490,43 +1611,26 @@ class EmberRouter extends EmberObject.extend(Evented) implements Evented {
   @param {Function} callback
   @return {Void}
  */
-function forEachRouteAbove(
-  routeInfos: InternalRouteInfo<Route>[],
-  callback: (route: Route, routeInfo: InternalRouteInfo<Route>) => boolean
-) {
-  for (let i = routeInfos.length - 1; i >= 0; --i) {
-    let routeInfo = routeInfos[i];
-    assert('has routeInfo', routeInfo);
-
-    let route = routeInfo.route;
-
-    // routeInfo.handler being `undefined` generally means either:
-    //
-    // 1. an error occurred during creation of the route in question
-    // 2. the route is across an async boundary (e.g. within an engine)
-    //
-    // In both of these cases, we cannot invoke the callback on that specific
-    // route, because it just doesn't exist...
-    if (route === undefined) {
-      continue;
-    }
-
-    if (callback(route, routeInfo) !== true) {
-      return;
-    }
-  }
-}
-
 // 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 loading route or substate to enter. Like
+  // `error` below, this only forwards through the classic-interop contract;
+  // the manager owns substate entry.
+  loading(this: EmberRouter, routeInfos: InternalRouteInfo<Route>[], transition: Transition) {
+    let originRoute = routeInfos[routeInfos.length - 1]?.route;
+
+    let dispatchRoute = originRoute;
+    for (let i = routeInfos.length - 2; dispatchRoute === undefined && i >= 0; i--) {
+      dispatchRoute = routeInfos[i]?.route;
+    }
+
+    if (dispatchRoute !== undefined) {
+      let managed = getRouteManagement(dispatchRoute);
+      if (managed !== undefined && hasClassicInterop(managed.manager)) {
+        managed.manager.enterLoadingSubstate(managed.bucket, transition, originRoute);
+      }
+    }
   },
 
   // Attempt to find an appropriate error route or substate to enter.
@@ -1536,66 +1640,29 @@ let defaultActionHandlers = {
     error: Error,
     transition: Transition
   ) {
-    let router = this;
-
-    let routeInfoWithError = routeInfos[routeInfos.length - 1];
-
-    forEachRouteAbove(routeInfos, (route, routeInfo) => {
-      // We don't check the leaf most routeInfo since that would
-      // technically be below where we're at in the route hierarchy.
-      if (routeInfo !== routeInfoWithError) {
-        // Check for the existence of an 'error' route.
-        let errorRouteName = findRouteStateName(route, 'error');
-        if (errorRouteName) {
-          router._markErrorAsHandled(error);
-          router.intermediateTransitionTo(errorRouteName, error);
-          return false;
-        }
-      }
+    // Error substates are classic machinery; the router only forwards the
+    // unhandled error through the classic-interop contract. The event's
+    // routeInfos are sliced to end at the route that errored, so its leaf
+    // is the origin of the substate walk. That route may never have been
+    // created (e.g. across an engine's async boundary) — dispatch then
+    // falls to the deepest created route, and the manager walks from the
+    // transition's leaf.
+    let originRoute = routeInfos[routeInfos.length - 1]?.route;
+
+    let dispatchRoute = originRoute;
+    for (let i = routeInfos.length - 2; dispatchRoute === undefined && i >= 0; i--) {
+      dispatchRoute = routeInfos[i]?.route;
+    }
 
-      // Check for an 'error' substate route
-      let errorSubstateName = findRouteSubstateName(route, 'error');
-      if (errorSubstateName) {
-        router._markErrorAsHandled(error);
-        router.intermediateTransitionTo(errorSubstateName, error);
-        return false;
+    if (dispatchRoute !== undefined) {
+      let managed = getRouteManagement(dispatchRoute);
+      if (managed !== undefined && hasClassicInterop(managed.manager)) {
+        managed.manager.enterErrorSubstate(managed.bucket, transition, error, originRoute);
       }
-
-      return true;
-    });
+    }
 
     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) {
@@ -1627,67 +1694,6 @@ function logError(_error: any, initialMessage: string) {
   console.error(...errorArgs); //eslint-disable-line no-console
 }
 
-/**
-  Finds the name of the substate route if it exists for the given route. A
-  substate route is of the form `route_state`, such as `foo_loading`.
-
-  @private
-  @param {Route} route
-  @param {String} state
-  @return {String}
-*/
-function findRouteSubstateName(route: Route, state: string) {
-  let owner = getOwner(route);
-  assert('Route is unexpectedly missing an owner', owner);
-
-  let { routeName, fullRouteName, _router: router } = route;
-
-  let substateName = `${routeName}_${state}`;
-  let substateNameFull = `${fullRouteName}_${state}`;
-
-  return routeHasBeenDefined(owner, router, substateName, substateNameFull) ? substateNameFull : '';
-}
-
-/**
-  Finds the name of the state route if it exists for the given route. A state
-  route is of the form `route.state`, such as `foo.loading`. Properly Handles
-  `application` named routes.
-
-  @private
-  @param {Route} route
-  @param {String} state
-  @return {String}
-*/
-function findRouteStateName(route: Route, state: string) {
-  let owner = getOwner(route);
-  assert('Route is unexpectedly missing an owner', owner);
-
-  let { routeName, fullRouteName, _router: router } = route;
-
-  let stateName = routeName === 'application' ? state : `${routeName}.${state}`;
-  let stateNameFull = fullRouteName === 'application' ? state : `${fullRouteName}.${state}`;
-
-  return routeHasBeenDefined(owner, router, stateName, stateNameFull) ? stateNameFull : '';
-}
-
-/**
-  Determines whether or not a route has been defined by checking that the route
-  is in the Router's map and the owner has a registration for that route.
-
-  @private
-  @param {Owner} owner
-  @param {Router} router
-  @param {String} localName
-  @param {String} fullName
-  @return {Boolean}
-*/
-function routeHasBeenDefined(owner: Owner, router: any, localName: string, fullName: string) {
-  let routerHasRoute = router.hasRoute(fullName);
-  let ownerHasRoute =
-    owner.factoryFor(`template:${localName}`) || owner.factoryFor(`route:${localName}`);
-  return routerHasRoute && ownerHasRoute;
-}
-
 export function triggerEvent<N extends MethodNamesOf<typeof defaultActionHandlers>>(
   this: EmberRouter,
   routeInfos: InternalRouteInfo<Route>[],
@@ -1797,7 +1803,7 @@ function didBeginTransition(transition: Transition, router: EmberRouter) {
 
 function forEachQueryParam(
   router: EmberRouter,
-  routeInfos: InternalRouteInfo<Route>[],
+  routeInfos: InternalRouteInfo<BaseRoute>[],
   queryParams: Record<string, unknown>,
   callback: (key: string, value: unknown, qp: QueryParam | undefined) => void
 ) {
diff --git a/packages/ember/tests/routing/model_loading_test.js b/packages/ember/tests/routing/model_loading_test.js
index ce1ab1532d5..733af89f554 100644
--- a/packages/ember/tests/routing/model_loading_test.js
+++ b/packages/ember/tests/routing/model_loading_test.js
@@ -933,3 +933,38 @@ moduleFor(
     }
   }
 );
+
+moduleFor(
+  'Route - model loading (afterModel model swapping)',
+  class extends ApplicationTestCase {
+    ['@test afterModel can swap the resolved model via transition.resolvedModels'](assert) {
+      assert.expect(2);
+      let swapped = { name: 'swapped' };
+
+      this.router.map(function () {
+        this.route('post');
+      });
+
+      this.add(
+        'route:post',
+        class extends Route {
+          model() {
+            return { name: 'original' };
+          }
+          afterModel(resolvedModel, transition) {
+            assert.equal(resolvedModel.name, 'original', 'afterModel received the resolved model');
+            // Classic router.js contract: `model()`'s result is stashed in
+            // `transition.resolvedModels` before afterModel runs, and re-read
+            // afterwards — so afterModel may swap the model out.
+            transition.resolvedModels['post'] = swapped;
+          }
+          setupController(controller, model) {
+            assert.strictEqual(model, swapped, 'setupController received the swapped model');
+          }
+        }
+      );
+
+      return this.visit('/post');
+    }
+  }
+);
diff --git a/packages/ember/tests/routing/route_manager_test.js b/packages/ember/tests/routing/route_manager_test.js
new file mode 100644
index 00000000000..50a50174ea7
--- /dev/null
+++ b/packages/ember/tests/routing/route_manager_test.js
@@ -0,0 +1,660 @@
+import Route from '@ember/routing/route';
+import { setRouteManager } from '@ember/routing';
+import { ClassicRouteManager } from '@ember/-internals/routing/route-managers/classic/manager';
+import {
+  moduleFor,
+  ApplicationTestCase,
+  ModuleBasedTestResolver,
+  runDestroy,
+  runTask,
+} from 'internal-test-helpers';
+import { registerDestructor } from '@ember/destroyable';
+import { precompileTemplate } from '@ember/template-compilation';
+import { getOwner } from '@ember/owner';
+import { defer, reject, resolve } from 'rsvp';
+
+// A manager that delegates everything to the ClassicRouteManager so existing
+// routing behaviour is preserved, but records every hook into a shared log so
+// the tests can assert the routing pipeline goes through the manager.
+class RecordingRouteManager extends ClassicRouteManager {
+  constructor(owner, log) {
+    super(owner);
+    this.log = log;
+  }
+
+  createRoute(factory, args) {
+    let bucket = super.createRoute(factory, args);
+    this.log.push(['createRoute', bucket.route.routeName]);
+    return bucket;
+  }
+
+  getRouteWrapper() {
+    this.log.push(['getRouteWrapper']);
+    return super.getRouteWrapper();
+  }
+
+  getInvokable(bucket, enterPromise) {
+    this.log.push(['getInvokable', bucket.route.routeName]);
+    return super.getInvokable(bucket, enterPromise);
+  }
+
+  willEnter(bucket, state) {
+    this.log.push(['willEnter', bucket.route.routeName]);
+    return super.willEnter(bucket, state);
+  }
+
+  enter(bucket, state) {
+    this.log.push(['enter', bucket.route.routeName]);
+    return super.enter(bucket, state);
+  }
+
+  didEnter(bucket, state) {
+    this.log.push(['didEnter', bucket.route.routeName, state.enter]);
+    return super.didEnter(bucket, state);
+  }
+
+  willExit(bucket, state) {
+    this.log.push(['willExit', bucket.route.routeName, state.isExiting]);
+    return super.willExit(bucket, state);
+  }
+
+  exit(bucket, state) {
+    this.log.push(['exit', bucket.route.routeName]);
+    return super.exit(bucket, state);
+  }
+
+  didExit(bucket, state) {
+    this.log.push(['didExit', bucket.route.routeName]);
+    return super.didExit(bucket, state);
+  }
+
+  getContext(bucket, params, transition) {
+    this.log.push(['getContext', bucket.route.routeName, params]);
+    return super.getContext(bucket, params, transition);
+  }
+
+  serializeContext(bucket, routeInfo, value) {
+    this.log.push(['serializeContext', bucket.route.routeName, value]);
+    return super.serializeContext(bucket, routeInfo, value);
+  }
+
+  redirect(bucket, routeInfo, context, transition) {
+    this.log.push(['redirect', bucket.route.routeName]);
+    return super.redirect(bucket, routeInfo, context, transition);
+  }
+
+  getRouteInfoMetadata(bucket) {
+    this.log.push(['getRouteInfoMetadata', bucket.route.routeName]);
+    return super.getRouteInfoMetadata(bucket);
+  }
+}
+
+moduleFor(
+  'Route manager - integration',
+  class extends ApplicationTestCase {
+    constructor() {
+      super(...arguments);
+
+      let TestRoute = class extends Route {};
+
+      this.log = [];
+      this.managers = [];
+      let test = this;
+      setRouteManager((owner) => {
+        let manager = new RecordingRouteManager(owner, test.log);
+        test.managers.push(manager);
+        return manager;
+      }, TestRoute);
+
+      this.add('route:application', class extends TestRoute {});
+      this.add('route:index', class extends TestRoute {});
+      this.add('template:application', precompileTemplate('app:{{outlet}}'));
+      this.add('template:index', precompileTemplate('index'));
+    }
+
+    async ['@test routes flow through their registered RouteManager'](assert) {
+      await this.visit('/');
+
+      assert.strictEqual(this.managers.length, 1, 'one manager instance per owner');
+      let methods = this.log.map(([m]) => m);
+
+      assert.ok(methods.includes('createRoute'), 'createRoute was called');
+      assert.ok(methods.includes('getRouteWrapper'), 'getRouteWrapper was called');
+      assert.ok(methods.includes('getInvokable'), 'getInvokable was called');
+
+      let createdRoutes = this.log
+        .filter(([m]) => m === 'createRoute')
+        .map(([, name]) => name)
+        .sort();
+      assert.deepEqual(
+        createdRoutes,
+        ['application', 'index'],
+        'createRoute fired for application and index'
+      );
+
+      assert.strictEqual(this.element.textContent, 'app:index', 'route templates rendered');
+    }
+  }
+);
+
+moduleFor(
+  'Route manager - getDestroyable wiring',
+  class extends ApplicationTestCase {
+    constructor() {
+      super(...arguments);
+
+      let TestRoute = class extends Route {};
+      let test = this;
+      this.destroyedBuckets = [];
+
+      // Simulates a manager whose per-route state is not container-managed:
+      // it returns the bucket as its destroyable, so the router is
+      // responsible for tying it to the owner's lifetime.
+      class DestroyableRouteManager extends ClassicRouteManager {
+        createRoute(factory, args) {
+          let bucket = super.createRoute(factory, args);
+          registerDestructor(bucket, () => test.destroyedBuckets.push(args.name));
+          return bucket;
+        }
+
+        getDestroyable(bucket) {
+          return bucket;
+        }
+      }
+
+      setRouteManager((owner) => new DestroyableRouteManager(owner), TestRoute);
+
+      this.add('route:application', class extends TestRoute {});
+      this.add('route:index', class extends TestRoute {});
+      this.add('template:application', precompileTemplate('app:{{outlet}}'));
+      this.add('template:index', precompileTemplate('index'));
+    }
+
+    async ['@test destroyables returned from getDestroyable are destroyed with the owner'](assert) {
+      await this.visit('/');
+
+      assert.deepEqual(this.destroyedBuckets, [], 'no buckets destroyed while the app is live');
+
+      runDestroy(this.applicationInstance);
+
+      assert.deepEqual(
+        this.destroyedBuckets.sort(),
+        ['application', 'index'],
+        'bucket destructors ran at owner teardown'
+      );
+    }
+  }
+);
+
+moduleFor(
+  'Route manager - wrapper-less rendering',
+  class extends ApplicationTestCase {
+    constructor() {
+      super(...arguments);
+
+      let TestRoute = class extends Route {};
+
+      // A manager that opts out of the wrapper: the outlet then invokes the
+      // route's invokable directly, passing the live model as `@context`,
+      // and keys teardown on invokable identity.
+      class WrapperlessRouteManager extends ClassicRouteManager {
+        getRenderState(bucket) {
+          return { ...super.getRenderState(bucket), wrapper: undefined };
+        }
+      }
+
+      setRouteManager((owner) => new WrapperlessRouteManager(owner), TestRoute);
+
+      this.add('route:application', class extends TestRoute {});
+      this.add(
+        'route:index',
+        class extends TestRoute {
+          model() {
+            return { msg: 'INDEX-CTX' };
+          }
+        }
+      );
+      this.add(
+        'route:other',
+        class extends TestRoute {
+          model() {
+            return { msg: 'OTHER-CTX' };
+          }
+        }
+      );
+      this.add('template:application', precompileTemplate('app:{{outlet}}'));
+      // Wrapper-less invokables receive the live model as `@context`.
+      this.add('template:index', precompileTemplate('index:{{@context.msg}}'));
+      this.add('template:other', precompileTemplate('other:{{@context.msg}}'));
+
+      this.router.map(function () {
+        this.route('other');
+      });
+    }
+
+    async ['@test a manager without a wrapper renders and tears down per route'](assert) {
+      await this.visit('/');
+      assert.strictEqual(
+        this.element.textContent,
+        'app:index:INDEX-CTX',
+        'wrapper-less route rendered with @context'
+      );
+
+      await this.visit('/other');
+      assert.strictEqual(
+        this.element.textContent,
+        'app:other:OTHER-CTX',
+        'route change tore down and rendered the next invokable'
+      );
+
+      await this.visit('/');
+      assert.strictEqual(
+        this.element.textContent,
+        'app:index:INDEX-CTX',
+        'round-trip renders correctly'
+      );
+    }
+  }
+);
+
+// Real-world resolvers (ember-resolver, the strict resolver) normalize a
+// dotted route name like `posts.show` to the slashed module path
+// `posts/show`. The default test resolver does NOT, which is why this never
+// surfaced in the rest of the suite: the router and a `route:` container
+// lookup ended up with the same spelling, so the route manager's per-name
+// bucket cache only ever held one instance.
+//
+// With a normalizing resolver the two callers disagree: router_js calls
+// `getRoute('parent.child')` (dotted, straight from the recognizer) while a
+// `paramsFor`/`modelFor` container lookup is intercepted and calls
+// `getRoute('parent/child')` (slashed, post-normalize). If the bucket cache
+// keys on the raw name those become two different route instances with
+// different `fullRouteName`s, and `paramsFor` reads `state.params` under the
+// wrong key, so a nested dynamic route resolves with empty params.
+class NormalizingResolver extends ModuleBasedTestResolver {
+  normalize(fullName) {
+    let [type, name] = fullName.split(':');
+    if (type === 'route') {
+      return `route:${name.replace(/\./g, '/')}`;
+    }
+    return fullName;
+  }
+
+  add(specifier, factory) {
+    return super.add(
+      typeof specifier === 'string' ? this.normalize(specifier) : specifier,
+      factory
+    );
+  }
+
+  resolve(specifier) {
+    return super.resolve(this.normalize(specifier));
+  }
+}
+
+moduleFor(
+  'Route manager - nested dynamic params with a normalizing resolver',
+  class extends ApplicationTestCase {
+    get applicationOptions() {
+      return Object.assign(super.applicationOptions, {
+        Resolver: NormalizingResolver,
+      });
+    }
+
+    constructor() {
+      super(...arguments);
+
+      let test = this;
+      this.childParams = undefined;
+
+      this.add('route:application', class extends Route {});
+      this.add('route:parent', class extends Route {});
+      this.add(
+        'route:parent.child',
+        class extends Route {
+          model(params) {
+            test.childParams = params;
+            return params;
+          }
+        }
+      );
+
+      this.add('template:application', precompileTemplate('{{outlet}}'));
+      this.add('template:parent', precompileTemplate('{{outlet}}'));
+      this.add('template:parent.child', precompileTemplate('child'));
+
+      this.router.map(function () {
+        this.route('parent', function () {
+          this.route('child', { path: '/:child_id' });
+        });
+      });
+    }
+
+    async ['@test a nested dynamic route receives its params when the resolver normalizes route names'](
+      assert
+    ) {
+      await this.visit('/parent/42');
+
+      assert.strictEqual(this.currentURL, '/parent/42', 'transitioned to the nested route');
+      assert.ok(this.childParams, 'the nested route model hook ran');
+      assert.strictEqual(
+        this.childParams.child_id,
+        '42',
+        'the nested route received its dynamic segment param'
+      );
+    }
+  }
+);
+
+// Lifecycle ordering. A single recording manager instance (one per
+// owner) logs every hook in call order so the tests can assert the router
+// drives willEnter -> enter -> didEnter on the way in and
+// willExit -> exit -> didExit on the way out, plus the context-update and
+// enter-gates-didEnter guarantees.
+moduleFor(
+  'Route manager - lifecycle ordering',
+  class extends ApplicationTestCase {
+    constructor() {
+      super(...arguments);
+
+      let test = this;
+      this.log = [];
+
+      let TestRoute = class extends Route {};
+      setRouteManager((owner) => new RecordingRouteManager(owner, test.log), TestRoute);
+
+      this.add('route:application', class extends TestRoute {});
+      this.add('route:parent', class extends TestRoute {});
+      this.add(
+        'route:parent.child',
+        class extends TestRoute {
+          model(params) {
+            // Mark when this route's async model work settles so the
+            // enter-gates-didEnter test can assert ordering against it.
+            return resolve().then(() => {
+              test.log.push(['model-settled', 'parent.child']);
+              return params;
+            });
+          }
+        }
+      );
+      this.add('route:other', class extends TestRoute {});
+
+      this.add('template:application', precompileTemplate('{{outlet}}'));
+      this.add('template:parent', precompileTemplate('{{outlet}}'));
+      this.add('template:parent.child', precompileTemplate('child'));
+      this.add('template:other', precompileTemplate('other'));
+
+      this.router.map(function () {
+        this.route('parent', function () {
+          this.route('child', { path: '/:child_id' });
+        });
+        this.route('other');
+      });
+    }
+
+    async ['@test entering routes fire willEnter -> enter -> didEnter in order'](assert) {
+      await this.visit('/parent/1');
+
+      for (let name of ['application', 'parent', 'parent.child']) {
+        let willEnter = this.log.findIndex(([h, n]) => h === 'willEnter' && n === name);
+        let enter = this.log.findIndex(([h, n]) => h === 'enter' && n === name);
+        let didEnter = this.log.findIndex(([h, n]) => h === 'didEnter' && n === name);
+
+        assert.notStrictEqual(willEnter, -1, `willEnter fired for ${name}`);
+        assert.notStrictEqual(enter, -1, `enter fired for ${name}`);
+        assert.notStrictEqual(didEnter, -1, `didEnter fired for ${name}`);
+        assert.ok(willEnter < enter, `willEnter before enter for ${name}`);
+        assert.ok(enter < didEnter, `enter before didEnter for ${name}`);
+      }
+
+      // The manager awaits every enter promise before running any didEnter,
+      // so the last enter must precede the first didEnter across all routes.
+      let lastEnter = this.log.findLastIndex(([h]) => h === 'enter');
+      let firstDidEnter = this.log.findIndex(([h]) => h === 'didEnter');
+      assert.ok(lastEnter < firstDidEnter, 'all enters resolve before any didEnter runs');
+    }
+
+    async ['@test exiting routes fire willExit -> exit -> didExit, leaf-first'](assert) {
+      await this.visit('/parent/1');
+      this.log.length = 0;
+      await this.visit('/other');
+
+      for (let name of ['parent.child', 'parent']) {
+        let willExit = this.log.findIndex(([h, n]) => h === 'willExit' && n === name);
+        let exit = this.log.findIndex(([h, n]) => h === 'exit' && n === name);
+        let didExit = this.log.findIndex(([h, n]) => h === 'didExit' && n === name);
+
+        assert.notStrictEqual(willExit, -1, `willExit fired for ${name}`);
+        assert.notStrictEqual(exit, -1, `exit fired for ${name}`);
+        assert.notStrictEqual(didExit, -1, `didExit fired for ${name}`);
+        assert.ok(willExit < exit, `willExit before exit for ${name}`);
+        assert.ok(exit < didExit, `exit before didExit for ${name}`);
+      }
+
+      // Leaf exits before its parent.
+      let childExit = this.log.findIndex(([h, n]) => h === 'exit' && n === 'parent.child');
+      let parentExit = this.log.findIndex(([h, n]) => h === 'exit' && n === 'parent');
+      assert.ok(childExit < parentExit, 'child exits before parent');
+    }
+
+    async ['@test a context update fires didEnter(enter:false) and willExit(isExiting:false)'](
+      assert
+    ) {
+      await this.visit('/parent/1');
+      this.log.length = 0;
+      await this.visit('/parent/2');
+
+      let didEnter = this.log.find(([h, n]) => h === 'didEnter' && n === 'parent.child');
+      assert.ok(didEnter, 'didEnter fired for the context-updated route');
+      assert.strictEqual(didEnter[2], false, 'didEnter ran with enter=false');
+
+      let willExit = this.log.find(([h, n]) => h === 'willExit' && n === 'parent.child');
+      assert.ok(willExit, 'willExit fired for the context-updated route');
+      assert.strictEqual(willExit[2], false, 'willExit ran with isExiting=false');
+
+      let fullExit = this.log.find(([h, n]) => h === 'exit' && n === 'parent.child');
+      assert.notOk(fullExit, 'the route did not fully exit on a context update');
+    }
+
+    async ['@test didEnter waits for the enter promise to settle'](assert) {
+      await this.visit('/parent/1');
+
+      let modelSettled = this.log.findIndex(([h]) => h === 'model-settled');
+      let childDidEnter = this.log.findIndex(([h, n]) => h === 'didEnter' && n === 'parent.child');
+
+      assert.notStrictEqual(modelSettled, -1, 'the async model settled');
+      assert.ok(
+        modelSettled < childDidEnter,
+        'didEnter ran only after the async enter work settled'
+      );
+    }
+  }
+);
+
+// Classic-interop surface. Asserts the router resolves models
+// (getContext), serializes URLs (serializeContext), runs redirects, and
+// surfaces metadata (getRouteInfoMetadata) through the manager boundary.
+moduleFor(
+  'Route manager - classic interop surface',
+  class extends ApplicationTestCase {
+    constructor() {
+      super(...arguments);
+
+      let test = this;
+      this.log = [];
+
+      let TestRoute = class extends Route {};
+      setRouteManager((owner) => new RecordingRouteManager(owner, test.log), TestRoute);
+
+      this.add('route:application', class extends TestRoute {});
+      this.add(
+        'route:post',
+        class extends TestRoute {
+          model(params) {
+            test.postParams = params;
+            // `id` drives the default `_id` serialize convention.
+            return { id: params.post_id };
+          }
+          buildRouteInfoMetadata() {
+            return { kind: 'post' };
+          }
+        }
+      );
+      this.add(
+        'route:redirector',
+        class extends TestRoute {
+          redirect() {
+            getOwner(this).lookup('service:router').transitionTo('target');
+          }
+        }
+      );
+      this.add('route:target', class extends TestRoute {});
+
+      this.add('template:application', precompileTemplate('{{outlet}}'));
+      this.add('template:post', precompileTemplate('post'));
+      this.add('template:redirector', precompileTemplate('redirector'));
+      this.add('template:target', precompileTemplate('target'));
+
+      this.router.map(function () {
+        this.route('post', { path: '/post/:post_id' });
+        this.route('redirector');
+        this.route('target');
+      });
+    }
+
+    get routerService() {
+      return this.applicationInstance.lookup('service:router');
+    }
+
+    async ['@test getContext resolves the model from URL params'](assert) {
+      await this.visit('/post/42');
+
+      let call = this.log.find(([h, n]) => h === 'getContext' && n === 'post');
+      assert.ok(call, 'getContext was dispatched for the dynamic route');
+      assert.strictEqual(call[2].post_id, '42', 'getContext received the dynamic segment param');
+      assert.strictEqual(this.postParams.post_id, '42', 'the model hook ran with that param');
+    }
+
+    async ['@test serializeContext runs through the manager'](assert) {
+      await this.visit('/');
+
+      let url = this.routerService.urlFor('post', { id: 7 });
+
+      assert.strictEqual(url, '/post/7', 'the model serialized into the dynamic segment');
+      let call = this.log.find(([h, n]) => h === 'serializeContext' && n === 'post');
+      assert.ok(call, 'serializeContext was dispatched');
+      assert.deepEqual(call[2], { id: 7 }, 'serializeContext received the model');
+    }
+
+    async ['@test redirect runs through the manager'](assert) {
+      await this.visit('/redirector');
+
+      assert.strictEqual(this.currentURL, '/target', 'the redirect landed on the target route');
+      let call = this.log.find(([h, n]) => h === 'redirect' && n === 'redirector');
+      assert.ok(call, 'redirect was dispatched through the manager');
+    }
+
+    async ['@test getRouteInfoMetadata surfaces buildRouteInfoMetadata'](assert) {
+      await this.visit('/post/42');
+
+      assert.deepEqual(
+        this.routerService.currentRoute.metadata,
+        { kind: 'post' },
+        'the RouteInfo carries the metadata the route built'
+      );
+      let call = this.log.find(([h, n]) => h === 'getRouteInfoMetadata' && n === 'post');
+      assert.ok(call, 'getRouteInfoMetadata was dispatched');
+    }
+  }
+);
+
+// Substates. A pending model enters the loading substate and a
+// rejected model enters the error substate. Both substate routes extend the
+// tracked base class, so the recording manager proves the router drives them
+// (via the intermediate transition) through the manager boundary.
+moduleFor(
+  'Route manager - substates',
+  class extends ApplicationTestCase {
+    constructor() {
+      super(...arguments);
+
+      let test = this;
+      this.log = [];
+      this.TestRoute = class extends Route {};
+      setRouteManager((owner) => new RecordingRouteManager(owner, test.log), this.TestRoute);
+
+      this.add('template:application', precompileTemplate('<div id="app">{{outlet}}</div>'));
+    }
+
+    // runTask lets the loading substate render synchronously while the model
+    // promise is still pending, so the test can inspect the DOM mid-transition.
+    visit(...args) {
+      return runTask(() => super.visit(...args));
+    }
+
+    ['@test a pending model enters the loading substate through the manager'](assert) {
+      let TestRoute = this.TestRoute;
+      let deferred = defer();
+
+      this.router.map(function () {
+        this.route('slow');
+      });
+
+      this.add(
+        'route:slow',
+        class extends TestRoute {
+          model() {
+            return deferred.promise;
+          }
+        }
+      );
+      this.add('route:loading', class extends TestRoute {});
+      this.add('template:slow', precompileTemplate('SLOW'));
+      this.add('template:loading', precompileTemplate('LOADING'));
+
+      let promise = this.visit('/slow').then(() => {
+        assert.equal(this.$('#app').text(), 'SLOW', 'the real route replaced the loading substate');
+        let didExit = this.log.find(([h, n]) => h === 'didExit' && n === 'loading');
+        assert.ok(didExit, 'the loading substate exited through the manager');
+      });
+
+      // While the model is pending, the loading substate is active.
+      assert.equal(this.$('#app').text(), 'LOADING', 'the loading substate rendered');
+      let didEnter = this.log.find(([h, n]) => h === 'didEnter' && n === 'loading');
+      assert.ok(didEnter, 'the loading substate entered through the manager');
+
+      deferred.resolve();
+      return promise;
+    }
+
+    async ['@test a rejected model enters the error substate through the manager'](assert) {
+      let TestRoute = this.TestRoute;
+
+      this.router.map(function () {
+        this.route('boom');
+      });
+
+      this.add(
+        'route:boom',
+        class extends TestRoute {
+          model() {
+            return reject({ msg: 'broke' });
+          }
+        }
+      );
+      this.add('route:error', class extends TestRoute {});
+      this.add('template:error', precompileTemplate('<span id="err">ERROR: {{@model.msg}}</span>'));
+
+      await this.visit('/boom');
+
+      assert.equal(
+        this.$('#err').text(),
+        'ERROR: broke',
+        'the error substate rendered with the error as its model'
+      );
+      let didEnter = this.log.find(([h, n]) => h === 'didEnter' && n === 'error');
+      assert.ok(didEnter, 'the error substate entered through the manager');
+    }
+  }
+);
diff --git a/packages/ember/tests/routing/substates_test.js b/packages/ember/tests/routing/substates_test.js
index fd0396596ec..5bdbe9b3441 100644
--- a/packages/ember/tests/routing/substates_test.js
+++ b/packages/ember/tests/routing/substates_test.js
@@ -89,6 +89,51 @@ moduleFor(
       return promise;
     }
 
+    ['@test Loading substate template can access its controller via {{this}}'](assert) {
+      // Regression test: substate routes enter via intermediate transitions
+      // that skip the manager's willEnter, so the controller must be read
+      // through the route rather than cached on the bucket at willEnter time.
+      let turtleDeferred = RSVP.defer();
+
+      this.router.map(function () {
+        this.route('turtle');
+      });
+
+      this.add(
+        'route:turtle',
+        class extends Route {
+          model() {
+            return turtleDeferred.promise;
+          }
+        }
+      );
+      this.add('template:turtle', precompileTemplate('TURTLE'));
+      this.add(
+        'controller:loading',
+        class extends Controller {
+          message = 'WAIT';
+        }
+      );
+      this.add('template:loading', precompileTemplate('{{this.message}}'));
+
+      let promise = this.visit('/turtle').then(() => {
+        assert.equal(
+          this.$('#app').text(),
+          'TURTLE',
+          'turtle template has loaded and replaced the loading template'
+        );
+      });
+
+      assert.equal(
+        this.$('#app').text(),
+        'WAIT',
+        'the loading template rendered with its controller as {{this}}'
+      );
+
+      turtleDeferred.resolve();
+      return promise;
+    }
+
     [`@test Slow promises returned from ApplicationRoute#model don't enter LoadingRoute`](assert) {
       let appDeferred = RSVP.defer();
 
@@ -777,17 +822,19 @@ moduleFor(
     }
 
     async [`@test Loading actions bubble to root but don't enter substates above pivot `](assert) {
-      await this.visit('/');
-
       let sallyDeferred = RSVP.defer();
       let puppiesDeferred = RSVP.defer();
+      let loadingActionCalls = 0;
 
+      // Registered before the initial visit: the application route is
+      // instantiated (and cached) during the first boot, so adding it later
+      // would leave the action-less default instance in place.
       this.add(
         'route:application',
         class extends Route {
           @action
           loading() {
-            assert.ok(true, 'loading action received on ApplicationRoute');
+            loadingActionCalls++;
           }
         }
       );
@@ -810,31 +857,39 @@ moduleFor(
         }
       );
 
-      let promise = this.visit('/grandma/mom/sally');
+      await this.visit('/');
+
+      // Drive the transition inside a run loop so resolution genuinely parks
+      // on sally's pending model; otherwise the deferred resolves before the
+      // waterfall reaches it and the transition is never actually slow.
+      let promise = runTask(() => this.visit('/grandma/mom/sally'));
       assert.equal(this.appRouter.currentPath, 'index', 'Initial route fully loaded');
+      assert.ok(
+        loadingActionCalls > 0,
+        'loading action bubbled to ApplicationRoute during the slow transition'
+      );
 
       sallyDeferred.resolve();
+      await promise;
 
-      promise
-        .then(() => {
-          assert.equal(this.appRouter.currentPath, 'grandma.mom.sally', 'transition completed');
-
-          let visit = this.visit('/grandma/puppies');
-          assert.equal(
-            this.appRouter.currentPath,
-            'grandma.mom.sally',
-            'still in initial state because the only loading state is above the pivot route'
-          );
+      assert.equal(this.appRouter.currentPath, 'grandma.mom.sally', 'transition completed');
 
-          return visit;
-        })
-        .then(() => {
-          runTask(() => puppiesDeferred.resolve());
+      let callsBeforeSecondTransition = loadingActionCalls;
+      let visit = runTask(() => this.visit('/grandma/puppies'));
+      assert.equal(
+        this.appRouter.currentPath,
+        'grandma.mom.sally',
+        'still in initial state because the only loading state is above the pivot route'
+      );
+      assert.ok(
+        loadingActionCalls > callsBeforeSecondTransition,
+        'loading action bubbled to ApplicationRoute for the transition above the pivot'
+      );
 
-          assert.equal(this.appRouter.currentPath, 'grandma.puppies', 'Finished transition');
-        });
+      runTask(() => puppiesDeferred.resolve());
+      await visit;
 
-      return promise;
+      assert.equal(this.appRouter.currentPath, 'grandma.puppies', 'Finished transition');
     }
 
     async ['@test Default error event moves into nested route'](assert) {
diff --git a/packages/router_js/index.ts b/packages/router_js/index.ts
index 11f8f8bb438..1da17994310 100644
--- a/packages/router_js/index.ts
+++ b/packages/router_js/index.ts
@@ -12,8 +12,42 @@ export type { PublicTransition as Transition } from './lib/transition';
 export { default as TransitionState, TransitionError } from './lib/transition-state';
 export {
   default as InternalRouteInfo,
-  type Route,
+  type BaseRoute,
   type RouteInfo,
   type RouteInfoWithAttributes,
   type ModelFor,
 } from './lib/route-info';
+
+export { throwIfAborted } from './lib/transition-aborted-error';
+
+export {
+  routeCapabilities,
+  hasClassicInterop,
+  associateRouteManagement,
+  getRouteManagement,
+} from './lib/route-manager';
+export type {
+  RouteManager,
+  RouteManagerWithClassicInterop,
+  RouteStateBucket,
+  RouteManagement,
+  RouteCapabilities,
+  RouteCapabilitiesVersions,
+  NavigationState,
+  NavigationActions,
+  AsyncNavigationState,
+  ClassicInteropArgs,
+  WillEnterState,
+  EnterState,
+  DidEnterState,
+  WillExitState,
+  ExitState,
+  DidExitState,
+  ClassicWillEnterState,
+  ClassicEnterState,
+  ClassicDidEnterState,
+  ClassicWillExitState,
+  ClassicExitState,
+  ClassicDidExitState,
+  CreateRouteArgs,
+} from './lib/route-manager';
diff --git a/packages/router_js/lib/route-info.ts b/packages/router_js/lib/route-info.ts
index 443a49e8105..24986e1f5bd 100644
--- a/packages/router_js/lib/route-info.ts
+++ b/packages/router_js/lib/route-info.ts
@@ -3,23 +3,42 @@ import { Promise } from 'rsvp';
 import type { Dict, Option } from './core';
 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,
+  type PublicTransition as Transition,
+  QUERY_PARAMS_SYMBOL,
+  STATE_SYMBOL,
+} from './transition';
 import { isParam, isPromise, merge } from './utils';
 import { throwIfAborted } from './transition-aborted-error';
+import type { EnterState, RouteManager, RouteStateBucket } from './route-manager';
+import { getRouteManagement, hasClassicInterop } from './route-manager';
 
 export type IModel = {} & {
   id?: string | number;
 };
 
-export type ModelFor<T> = T extends Route<infer V> ? V : never;
+export type ModelFor<T> = T extends BaseRoute<infer V> ? V : never;
 
-export interface Route<T = unknown> {
+export interface BaseRoute<T = unknown> {
+  context: T | undefined;
+
+  // this is used to identify the route in router_js machinery, and is not the same as the
+  // routeName property on classic ember routes. It is totally internal to router_js, and
+  // not to be confused with the routeName property on classic ember routes
+  _internalName?: string;
+
+  // I think this could potentially be deleted
+  // it's not mentioned in any ember docs that I can find, and is only
+  // used in a couple of places in router_js
   inaccessibleByURL?: boolean;
+}
+
+// used by old router_js tests that expect to be working with the classic ember routes
+export interface ClassicRoute<T = unknown> extends BaseRoute<T> {
   routeName: string;
-  _internalName: string;
-  context: T | undefined;
   events?: Dict<(...args: unknown[]) => unknown>;
   model?(params: Dict<unknown>, transition: Transition): PromiseLike<T> | undefined | T;
   deserialize?(params: Dict<unknown>, transition: Transition): T | PromiseLike<T> | undefined;
@@ -54,11 +73,11 @@ export interface RouteInfoWithAttributes extends RouteInfo {
   attributes: any;
 }
 
-type RouteInfosKey = InternalRouteInfo<Route>;
+type RouteInfosKey = InternalRouteInfo<BaseRoute>;
 
 let ROUTE_INFOS = new WeakMap<RouteInfosKey, RouteInfo | RouteInfoWithAttributes>();
 
-export function toReadOnlyRouteInfo<R extends Route>(
+export function toReadOnlyRouteInfo<R extends BaseRoute>(
   routeInfos: InternalRouteInfo<R>[],
   queryParams: Dict<unknown> = {},
   options: {
@@ -69,12 +88,12 @@ export function toReadOnlyRouteInfo<R extends Route>(
   const LOCAL_ROUTE_INFOS = new WeakMap<RouteInfosKey, RouteInfo | RouteInfoWithAttributes>();
 
   return routeInfos.map((info, i) => {
-    let { name, params, paramNames, context, route } = info;
+    let { name, params, paramNames, context } = info;
     // SAFETY: This should be safe since it is just for use as a key
     let key = info as unknown as RouteInfosKey;
     if (ROUTE_INFOS.has(key) && options.includeAttributes) {
       let routeInfo = ROUTE_INFOS.get(key)!;
-      routeInfo = attachMetadata(route!, routeInfo);
+      routeInfo = attachMetadata(info, routeInfo);
       let routeInfoWithAttribute = createRouteInfoWithAttributes(routeInfo, context);
       LOCAL_ROUTE_INFOS.set(key, routeInfo);
       if (!options.localizeMapUpdates) {
@@ -120,7 +139,7 @@ export function toReadOnlyRouteInfo<R extends Route>(
       },
 
       get metadata() {
-        return buildRouteInfoMetadata(info.route);
+        return buildRouteInfoMetadata(info);
       },
 
       get parent() {
@@ -192,18 +211,19 @@ function createRouteInfoWithAttributes(
   return Object.assign(routeInfo, attributes);
 }
 
-function buildRouteInfoMetadata(route?: Route) {
-  if (route !== undefined && route !== null && route.buildRouteInfoMetadata !== undefined) {
-    return route.buildRouteInfoMetadata();
+function buildRouteInfoMetadata(info: InternalRouteInfo<BaseRoute>) {
+  let { manager, bucket } = info;
+  if (manager !== undefined && hasClassicInterop(manager) && bucket !== undefined) {
+    return manager.getRouteInfoMetadata(bucket);
   }
 
   return null;
 }
 
-function attachMetadata(route: Route, routeInfo: RouteInfo) {
+function attachMetadata(info: InternalRouteInfo<BaseRoute>, routeInfo: RouteInfo) {
   let metadata = {
     get metadata() {
-      return buildRouteInfoMetadata(route);
+      return buildRouteInfoMetadata(info);
     },
   };
 
@@ -214,7 +234,7 @@ function attachMetadata(route: Route, routeInfo: RouteInfo) {
   return Object.assign(routeInfo, metadata);
 }
 
-export default class InternalRouteInfo<R extends Route> {
+export default class InternalRouteInfo<R extends BaseRoute> {
   private _routePromise?: Promise<R> = undefined;
   private _route?: Option<R> = null;
   protected router: Router<R>;
@@ -224,6 +244,7 @@ export default class InternalRouteInfo<R extends Route> {
   declare queryParams?: Dict<unknown>;
   declare context?: ModelFor<R> | PromiseLike<ModelFor<R>> | undefined;
   isResolved = false;
+  enterPromise?: globalThis.Promise<unknown> = undefined;
 
   constructor(router: Router<R>, name: string, paramNames: string[], route?: R) {
     this.name = name;
@@ -244,19 +265,82 @@ export default class InternalRouteInfo<R extends Route> {
 
   resolve(transition: InternalTransition<R>): Promise<ResolvedRouteInfo<R>> {
     return Promise.resolve(this.routePromise)
-      .then((route: Route) => {
+      .then((route: R) => {
         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(() => {
+        const { manager, bucket } = this;
+        if (manager === undefined || bucket === undefined) {
+          throw new Error(
+            `Route '${this.name}' has no RouteManager attached. Use \`setRouteManager\` to associate one with the route class.`
+          );
+        }
+
+        // RFC NavigationState: transition-level from/to, populated by
+        // routeWillChange before any lifecycle hook runs. Hand-built
+        // transitions in unit tests may lack `to`; fall back to this route's
+        // own public info.
+        const to =
+          (transition.to as RouteInfo | undefined) ??
+          (ROUTE_INFOS.get(this as unknown as RouteInfosKey) as RouteInfo | undefined) ??
+          (this as unknown as RouteInfo);
+        const from = (transition.from ?? undefined) as RouteInfo | undefined;
+
+        const navigationArgs: EnterState = {
+          from,
+          to,
+          cancel: () => transition.abort(),
+          signal: transition.signal,
+          getAncestorContext: (ancestor: RouteInfo) => {
+            const routeInfos = transition[STATE_SYMBOL]?.routeInfos ?? [];
+            // Only true ancestors count: searching the whole hierarchy would
+            // hand a route its own (or a descendant's) pending enter promise —
+            // an easy deadlock for a manager that awaits it. When this info
+            // isn't in the transition state (hand-built test transitions),
+            // fall back to searching the full list.
+            const selfIndex = routeInfos.indexOf(this);
+            const ancestors = selfIndex === -1 ? routeInfos : routeInfos.slice(0, selfIndex);
+            const matched = ancestors.find((ri) => ri?.name === ancestor.name);
+            return matched?.enterPromise ?? Promise.resolve(undefined);
+          },
+        };
+
+        // The raw transition and the internal route info are classic-interop
+        // concerns; only provide them when the manager opts in.
+        if (hasClassicInterop(manager)) {
+          Object.assign(navigationArgs, { transition, internalRouteInfo: this });
+        }
+
+        manager.willEnter(bucket, navigationArgs);
+
+        const enterPromise = manager.enter(bucket, navigationArgs);
+        this.enterPromise = enterPromise;
+
+        // Capture the entered context locally rather than writing it onto
+        // this route info: `shouldSupersede` treats an own `context` as
+        // meaningful when infos are reused across transitions, so the info
+        // must not gain one it never had. `becomeResolved` receives the
+        // value explicitly below.
+        let enteredContext: ModelFor<R> | undefined;
+        enterPromise.then(
+          (resolvedContext) => {
+            if (transition.isAborted) return;
+            enteredContext = resolvedContext as ModelFor<R> | undefined;
+          },
+          () => {
+            // Swallow rejections; transition-level error handling reports them.
+          }
+        );
+
+        // The manager decides whether to gate getInvokable on enterPromise. The
+        // classic manager does, so getInvokable rejects when enter rejects
+        return manager.getInvokable(bucket, enterPromise).then(() => {
+          throwIfAborted(transition);
+          const resolvedContext = enteredContext ?? (this.context as ModelFor<R> | undefined);
+          return this.becomeResolved(transition, resolvedContext);
+        });
+      });
   }
 
   becomeResolved(
@@ -279,19 +363,47 @@ export default class InternalRouteInfo<R extends Route> {
     }
 
     // SAFETY: Since this is just for lookup, it should be safe
-    let cached = ROUTE_INFOS.get(this as unknown as InternalRouteInfo<Route>);
+    let cached = ROUTE_INFOS.get(this as unknown as InternalRouteInfo<BaseRoute>);
     let resolved = new ResolvedRouteInfo<R>(
       this.router,
       this.name,
       this.paramNames,
       params,
       this.route!,
-      context
+      context,
+      this.enterPromise
     );
 
+    // Back-fill the model onto `resolved` once `enter` settles, but only for
+    // managers that render before their model resolves. A manager whose
+    // `getInvokable` gates on `enter` (e.g. the classic manager) reaches here
+    // with `resolvedContext` already set, so `resolved` was built with its final
+    // `context` and there is nothing to wait for. A manager whose `getInvokable`
+    // resolves *before* `enter` (e.g. a manager which renders
+    // immediately and shows a loading state) reaches here while `enterPromise`
+    // is still pending and `resolvedContext` is undefined; the resolve()-level
+    // `.then` only updates the now-replaced unresolved info, so this is the
+    // subscription that writes the model onto the live `resolved` info (and the
+    // transition's resolved models) when it finally arrives.
+    if (resolvedContext === undefined && this.enterPromise !== undefined) {
+      this.enterPromise.then(
+        (enteredContext) => {
+          if (transition && transition.isAborted) return;
+          resolved.context = enteredContext as ModelFor<R> | undefined;
+          if (transition) {
+            transition.resolvedModels = transition.resolvedModels || {};
+            transition.resolvedModels[resolved.name] = enteredContext as ModelFor<R> | undefined;
+          }
+        },
+        () => {
+          // enter rejected; transition-level error handling reports it.
+        }
+      );
+    }
+
     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);
+      ROUTE_INFOS.set(resolved as unknown as InternalRouteInfo<BaseRoute>, cached);
     }
 
     return resolved;
@@ -326,6 +438,22 @@ export default class InternalRouteInfo<R extends Route> {
     return this.fetchRoute();
   }
 
+  /**
+    The manager driving this route's lifecycle, read from the association the
+    framework router registered via `associateRouteManagement` when it resolved
+    the route. `undefined` until the route has loaded.
+   */
+  get manager(): RouteManager | undefined {
+    let route = this.route;
+    return route === undefined ? undefined : getRouteManagement(route)?.manager;
+  }
+
+  /** The manager's bucket for this route. `undefined` until the route has loaded. */
+  get bucket(): RouteStateBucket | undefined {
+    let route = this.route;
+    return route === undefined ? undefined : getRouteManagement(route)?.bucket;
+  }
+
   set route(route: R | undefined) {
     this._route = route;
   }
@@ -355,53 +483,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.
-      // SAFETY: 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
@@ -436,7 +517,7 @@ export default class InternalRouteInfo<R extends Route> {
   }
 }
 
-export class ResolvedRouteInfo<R extends Route> extends InternalRouteInfo<R> {
+export class ResolvedRouteInfo<R extends BaseRoute> extends InternalRouteInfo<R> {
   isResolved: boolean;
   context: ModelFor<R> | undefined;
   constructor(
@@ -445,12 +526,14 @@ export class ResolvedRouteInfo<R extends Route> extends InternalRouteInfo<R> {
     paramNames: string[],
     params: Dict<unknown> | undefined,
     route: R,
-    context?: ModelFor<R>
+    context?: ModelFor<R>,
+    enterPromise?: globalThis.Promise<unknown>
   ) {
     super(router, name, paramNames, route);
     this.params = params;
     this.isResolved = true;
     this.context = context;
+    this.enterPromise = enterPromise;
   }
 
   resolve(transition: InternalTransition<R>): Promise<this> {
@@ -462,7 +545,7 @@ export class ResolvedRouteInfo<R extends Route> extends InternalRouteInfo<R> {
   }
 }
 
-export class UnresolvedRouteInfoByParam<R extends Route> extends InternalRouteInfo<R> {
+export class UnresolvedRouteInfoByParam<R extends BaseRoute> extends InternalRouteInfo<R> {
   params: Dict<unknown> = {};
   constructor(
     router: Router<R>,
@@ -485,18 +568,11 @@ export class UnresolvedRouteInfoByParam<R extends Route> extends InternalRouteIn
       fullParams['queryParams'] = transition[QUERY_PARAMS_SYMBOL];
     }
 
-    let route = this.route!;
-
     let result: ModelFor<R> | PromiseLike<ModelFor<R>> | undefined;
 
-    // FIXME: Review these casts
-    if (route.deserialize) {
-      result = route.deserialize(fullParams, transition) as
-        | ModelFor<R>
-        | PromiseLike<ModelFor<R>>
-        | undefined;
-    } else if (route.model) {
-      result = route.model(fullParams, transition) as
+    let { manager, bucket } = this;
+    if (manager !== undefined && hasClassicInterop(manager) && bucket !== undefined) {
+      result = manager.getContext(bucket, fullParams, transition) as
         | ModelFor<R>
         | PromiseLike<ModelFor<R>>
         | undefined;
@@ -510,7 +586,7 @@ export class UnresolvedRouteInfoByParam<R extends Route> extends InternalRouteIn
   }
 }
 
-export class UnresolvedRouteInfoByObject<R extends Route> extends InternalRouteInfo<R> {
+export class UnresolvedRouteInfoByObject<R extends BaseRoute> extends InternalRouteInfo<R> {
   serializer?: SerializerFunc<ModelFor<R>>;
   constructor(
     router: Router<R>,
@@ -558,9 +634,10 @@ export class UnresolvedRouteInfoByObject<R extends Route> extends InternalRouteI
     if (this.serializer) {
       // invoke this.serializer unbound (getSerializer returns a stateless function)
       return this.serializer.call(null, model, paramNames);
-    } else if (this.route !== undefined) {
-      if (this.route.serialize) {
-        return this.route.serialize(model, paramNames);
+    } else {
+      let { manager, bucket } = this;
+      if (manager !== undefined && hasClassicInterop(manager) && bucket !== undefined) {
+        return manager.serializeContext(bucket, this, model) as Dict<unknown> | undefined;
       }
     }
 
diff --git a/packages/router_js/lib/route-manager.ts b/packages/router_js/lib/route-manager.ts
new file mode 100644
index 00000000000..bccd77f2a3c
--- /dev/null
+++ b/packages/router_js/lib/route-manager.ts
@@ -0,0 +1,524 @@
+/**
+  Route Manager contract. Defines the interface the router uses to drive route
+  base classes, plus the navigation-state shapes and capability helpers.
+
+  This lives in `router_js` (rather than the `@ember` layer) because `router_js`
+  is what calls this contract. Keeping it here means the dispatch types
+  reference `router_js`'s own `RouteInfo`/`Transition` directly, with no upward
+  dependency on `@ember/routing`.
+
+  Apps and addons author managers against the public re-export from
+  `@ember/routing`.
+*/
+
+import type { RouteInfo, BaseRoute } from './route-info';
+import type { default as InternalRouteInfo } from './route-info';
+import type { PublicTransition as Transition } from './transition';
+
+// -- RouteStateBucket ---------------------------------------------------------
+
+/**
+  Marker interface for the opaque state object a `RouteManager` returns from
+  `createRoute`. Its shape and contents are defined entirely by the specific
+  manager implementation, the router holds the bucket and passes it back to
+  the manager without inspecting it.
+
+  The bucket carries stable identity for a route definition. Per-navigation
+  state (e.g. the resolved model, the in-flight enter promise) lives on the
+  matching `RouteInfo`, keeping the bucket free to back multiple concurrent
+  renders.
+ */
+export type RouteStateBucket = object;
+
+// -- Capabilities -------------------------------------------------------------
+
+/**
+  Versioned capability schema for `RouteManager`. New versions can opt routes
+  into new behaviour while keeping older managers working.
+ */
+export interface RouteCapabilitiesVersions {
+  '1.0': {
+    /**
+      When `true`, the router will provide the per-navigation `Transition`
+      to manager hooks via the `ClassicInteropArgs` mix-in, and the manager
+      must implement the methods on `RouteManagerWithClassicInterop`.
+
+      This capability exists to bridge the classic router to the new manager
+      surface. It is not intended to be used by managers outside the
+      framework-provided `ClassicRouteManager`.
+     */
+    classicInterop?: boolean;
+  };
+}
+
+/**
+  The capabilities object stored on a `RouteManager`. Always created
+  via `routeCapabilities`.
+ */
+export interface RouteCapabilities {
+  classicInterop: boolean;
+}
+
+/**
+  Produces a `RouteCapabilities` object for a `RouteManager`. The result must
+  be assigned to `manager.capabilities`.
+
+  ```ts
+  capabilities = routeCapabilities('1.0', { classicInterop: true });
+  ```
+
+  @param _managerAPI The version of the manager API the route manager targets.
+  @param options Optional capability flags for that version.
+ */
+export function routeCapabilities<Version extends keyof RouteCapabilitiesVersions>(
+  _managerAPI: Version,
+  options: RouteCapabilitiesVersions[Version] = {}
+): RouteCapabilities {
+  return {
+    classicInterop: Boolean(options.classicInterop),
+  };
+}
+
+// -- Route-management association --------------------------------------------------
+
+const ROUTE_MANAGEMENT = new WeakMap<object, RouteManagement>();
+
+export interface RouteManagement {
+  manager: RouteManager;
+  bucket: RouteStateBucket;
+}
+
+/**
+  Associates a route object with the manager and bucket that produced it.
+  Called by the framework router when it resolves a route through a manager;
+  `InternalRouteInfo` reads the association back to dispatch lifecycle hooks.
+  Managers themselves never need to call this.
+
+  Not to be confused with `setRouteManager`/`getRouteManager` (the registry
+  in the `@ember` layer): the registry is keyed by the route **class** and
+  holds the manager *factory* route authors registered — configuration. This
+  association is keyed by a route **instance** and holds the *instantiated*
+  manager plus that instance's bucket — the memoized result of applying the
+  registry, kept here so router_js dispatch can reach it without access to
+  owners or the registry.
+ */
+export function associateRouteManagement(
+  route: object,
+  manager: RouteManager,
+  bucket: RouteStateBucket
+): void {
+  ROUTE_MANAGEMENT.set(route, { manager, bucket });
+}
+
+export function getRouteManagement(route: object): RouteManagement | undefined {
+  return ROUTE_MANAGEMENT.get(route);
+}
+
+// -- Navigation state ---------------------------------------------------------
+
+/**
+  Common navigation context passed to the manager lifecycle hooks, as
+  specified by the RFC. Both route infos are transition-level: `from` is the
+  leaf route info of the state being navigated away from (`undefined` on the
+  initial transition) and `to` is the leaf route info of the destination.
+  Both are populated from the transition before any lifecycle hook runs.
+ */
+export interface NavigationState {
+  from?: RouteInfo;
+  to: RouteInfo;
+}
+
+/**
+  Actions the router lends to certain hooks. Currently only `cancel`, which
+  aborts the active navigation.
+ */
+export interface NavigationActions {
+  /** Cancels the current navigation. */
+  cancel(): void;
+}
+
+/**
+  Extra state available inside `enter`, used to coordinate asynchronous work
+  with the active transition.
+ */
+export interface AsyncNavigationState {
+  /**
+    Aborts when the navigation is no longer the active one, e.g. because it
+    was cancelled or superseded by a newer transition.
+   */
+  signal: AbortSignal;
+
+  /**
+    Returns a promise that resolves with an ancestor route's context once that
+    ancestor's `enter` has settled. Resolves with `undefined` if the named
+    route is not an ancestor in the active transition.
+
+    A `RouteInfo` for the desired ancestor must always be passed explicitly.
+   */
+  getAncestorContext(routeInfo: RouteInfo): Promise<unknown>;
+}
+
+/**
+  Classic-interop additions on the navigation state, provided **only** when
+  the manager declares the `classicInterop: true` capability. Holds the raw
+  `router_js` `Transition` (so the manager can drive the legacy event system)
+  and the internal route info the hook fires for (so the manager can reach
+  internal operations such as `getModel` and the resolved `context`).
+ */
+export interface ClassicInteropArgs {
+  transition: Transition;
+  internalRouteInfo: InternalRouteInfo<BaseRoute>;
+}
+
+// -- Hook argument shapes -----------------------------------------------------
+//
+// The base state interfaces match the RFC: `NavigationState` (+ actions/async
+// where specified) and nothing else. Managers with the `classicInterop`
+// capability receive the widened `Classic*` shapes below instead — the
+// interop fields are genuinely capability-gated at every dispatch site.
+
+export interface WillEnterState extends NavigationState, NavigationActions {}
+
+export interface EnterState extends NavigationState, NavigationActions, AsyncNavigationState {}
+
+export type DidEnterState = NavigationState;
+
+export interface WillExitState extends NavigationState, NavigationActions {}
+
+/**
+  State for the `exit` hook. A normal exit happens during a navigation and
+  provides `from`/`to`, but an exit can also happen during router teardown
+  (`reset`), where there is no navigation at all — hence, unlike the RFC's
+  `NavigationState`, everything here is optional.
+ */
+export interface ExitState {
+  from?: RouteInfo;
+  to?: RouteInfo;
+}
+
+export type DidExitState = NavigationState;
+
+// -- Classic-interop hook argument shapes -------------------------------------
+//
+// What a `classicInterop: true` manager receives instead of the base shapes.
+// Beyond `ClassicInteropArgs`, the enter/exit flags encode the classic
+// "update" distinction (re-entering the route you are already on): the RFC
+// treats that as a manager-internal concern, so it only exists on the
+// interop side. Likewise, the router only dispatches the update-flavoured
+// calls (`willExit` with `isExiting: false`, `didEnter` with `enter: false`,
+// intermediate-transition `didEnter`) to interop managers at all.
+
+export type ClassicWillEnterState = WillEnterState & ClassicInteropArgs;
+
+export type ClassicEnterState = EnterState & ClassicInteropArgs;
+
+export type ClassicDidEnterState = DidEnterState &
+  ClassicInteropArgs & {
+    /**
+      `true` if this hook is firing for a fresh entry into the route, `false`
+      if the route stayed mounted and only its context changed (a classic
+      "update").
+     */
+    enter: boolean;
+  };
+
+export type ClassicWillExitState = WillExitState &
+  ClassicInteropArgs & {
+    /**
+      `true` if the route is leaving the hierarchy entirely, `false` if it is
+      staying mounted but its context is being reset (the classic
+      "context updated" path).
+     */
+    isExiting: boolean;
+  };
+
+export type ClassicExitState = ExitState & {
+  /** Absent during router teardown (`reset`). */
+  transition?: Transition;
+};
+
+export type ClassicDidExitState = DidExitState & ClassicInteropArgs;
+
+/**
+  Arguments object passed to `createRoute`. Wrapped in an object for symmetry
+  with the other hooks.
+ */
+export interface CreateRouteArgs {
+  /**
+    The dot-separated route name (e.g. `posts.show`). Stable for the lifetime
+    of the bucket.
+   */
+  name: string;
+}
+
+// -- RouteManager -------------------------------------------------------------
+
+/**
+  The contract every route base class implements via its manager. The router
+  drives this interface; nothing else in user code should.
+
+  @template Bucket The shape of the bucket the manager returns from
+    `createRoute`. Defaults to the empty marker, override for a concrete
+    manager implementation.
+ */
+export interface RouteManager<Bucket extends RouteStateBucket = RouteStateBucket> {
+  /**
+    Capability descriptor for this manager. Must be the result of calling
+    `routeCapabilities`.
+   */
+  capabilities: RouteCapabilities;
+
+  /**
+    Returns a stable bucket the router will pass back to every other hook on
+    this manager. Whether `factory` is instantiated now or later is up to the
+    manager.
+   */
+  createRoute(factory: object, args: CreateRouteArgs): Bucket;
+
+  /**
+    Returns a route associated with a bucket
+   */
+  getRoute(bucket: Bucket): unknown;
+
+  /**
+    Returns the destroyable (if any) associated with the bucket. When a
+    manager creates route state that is not otherwise owner-managed, the
+    framework associates the returned destroyable with the owner so it is
+    destroyed at teardown. Return `null` when the state is already managed
+    elsewhere (e.g. container-owned), to avoid double management.
+   */
+  getDestroyable(bucket: Bucket): object | null;
+
+  /**
+    Synchronous hook called when a route is about to be entered, before any
+    asynchronous work begins.
+   */
+  willEnter(bucket: Bucket, state: WillEnterState): void;
+
+  /**
+    Asynchronous entry point. The returned promise resolves with the route's
+    context. The router stores the promise on the matching `RouteInfo` so
+    descendant routes can await it via `getAncestorContext`.
+   */
+  enter(bucket: Bucket, state: EnterState): Promise<unknown>;
+
+  /**
+    Fires once every entering route in the transition has resolved. Classic
+    routes use this to run `activate` and `setupController`.
+   */
+  didEnter(bucket: Bucket, state: DidEnterState): void;
+
+  /**
+    Synchronous hook called when the route is about to be exited. May be
+    cancelled via `state.cancel()`.
+   */
+  willExit(bucket: Bucket, state: WillExitState): void;
+
+  /**
+    Called when the route is exited. Classic routes run `deactivate` and
+    `resetController` here. `state` is omitted during router teardown
+    (`reset`), where there is no destination or active transition.
+   */
+  exit(bucket: Bucket, state?: ExitState): void;
+
+  /**
+    Called once every exiting route in the transition has finished its `exit`
+    phase. Used for cleanup that depends on the whole branch being gone.
+   */
+  didExit(bucket: Bucket, state: DidExitState): void;
+
+  /**
+    Optional. Returns a module-stable wrapper component: the same value for
+    every call, across all buckets. The outlet invokes it with `@Component`
+    (the per-bucket invokable from the render state), `@context` (the live
+    model), and `@bucket`; route identity for the rendering layer's stability
+    check is carried by the invokable, so the wrapper itself carries no
+    per-route state.
+
+    A wrapper is an argument-forwarding policy, and it costs one extra
+    component boundary per outlet level per transition (measured at roughly
+    8–10µs per level). Managers whose route components can consume `@context`
+    directly should omit it (and leave `wrapper` undefined in their render
+    state); the outlet then invokes the invokable directly.
+   */
+  getRouteWrapper?(): object;
+
+  /**
+    Returns the renderable for the route. Async to absorb dynamic imports of
+    lazy-loaded route modules. The returned promise resolves with the
+    component the wrapper should render, or `undefined` to render nothing.
+
+    The router passes the in-flight `enterPromise` so the manager can choose
+    whether to await data before resolving.
+   */
+  getInvokable(bucket: Bucket, enterPromise?: Promise<unknown>): Promise<object | undefined>;
+
+  getRenderState(bucket: Bucket): RenderStateLike;
+}
+
+type RenderStateLike = {
+  owner: any;
+  name: string;
+  controller: unknown;
+  model: unknown;
+  invokable: object | undefined;
+  /** Optional argument-forwarding wrapper; see `getRouteWrapper`. */
+  wrapper: object | undefined;
+  /** Curried onto the wrapper as `@bucket` by the outlet. */
+  bucket?: RouteStateBucket;
+};
+
+/**
+  Additional methods a manager must implement when `capabilities.classicInterop`
+  is `true`. These cross the manager boundary in ways the new router will not
+  need and exist solely to keep the classic router behaviour reachable. They
+  will be deprecated together with classic interop.
+ */
+export interface RouteManagerWithClassicInterop<
+  Bucket extends RouteStateBucket = RouteStateBucket,
+> extends RouteManager<Bucket> {
+  // Lifecycle hooks, widened with the capability-gated interop state. The
+  // router narrows via `hasClassicInterop` before dispatching these shapes.
+  willEnter(bucket: Bucket, state: ClassicWillEnterState): void;
+  enter(bucket: Bucket, state: ClassicEnterState): Promise<unknown>;
+  didEnter(bucket: Bucket, state: ClassicDidEnterState): void;
+  willExit(bucket: Bucket, state: ClassicWillExitState): void;
+  exit(bucket: Bucket, state?: ClassicExitState): void;
+  didExit(bucket: Bucket, state: ClassicDidExitState): void;
+
+  /**
+    Returns the query-param meta for the route. Backs the classic protected
+    `_qp` getter; the router reads it to assemble the query-param state for a
+    route hierarchy. Typed as `unknown` here because the concrete
+    `QueryParamMeta` shape is a classic-`@ember` concern that `router_js` never
+    inspects; the `@ember` layer narrows the result.
+   */
+  qp(bucket: Bucket): unknown;
+
+  /**
+    Stashes the dynamic-segment names onto the route's query-param meta so
+    `model`-scoped query params resolve to the right path. Called by the
+    router while walking the active route hierarchy.
+   */
+  stashNames(
+    bucket: Bucket,
+    routeInfo: InternalRouteInfo<BaseRoute>,
+    dynamicParent: InternalRouteInfo<BaseRoute>
+  ): void;
+
+  /**
+    Serializes a single query-param value for the URL. Mirrors the classic
+    `Route.serializeQueryParam`.
+   */
+  serializeQueryParam(
+    bucket: Bucket,
+    value: unknown,
+    urlKey: string,
+    defaultValueType: string
+  ): unknown;
+
+  /**
+    Deserializes a single query-param value from the URL. Mirrors the classic
+    `Route.deserializeQueryParam`.
+   */
+  deserializeQueryParam(
+    bucket: Bucket,
+    value: unknown,
+    urlKey: string,
+    defaultValueType: string
+  ): unknown;
+
+  /**
+    Serializes the route's context (model) into the dynamic URL segments.
+    Backs the classic `Route.serialize` hook.
+   */
+  serializeContext(
+    bucket: Bucket,
+    routeInfo: InternalRouteInfo<BaseRoute>,
+    value: unknown
+  ): Record<string, unknown> | undefined;
+
+  /**
+    Classic `queryParamsDidChange` event handler. Returns `true` to let the
+    event keep bubbling through the route hierarchy.
+   */
+  queryParamsDidChange(
+    bucket: Bucket,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    changed: {},
+    totalPresent: unknown,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    removed: {}
+  ): boolean | void;
+
+  /**
+    Classic `finalizeQueryParamChange` event handler. Reconciles controller
+    query-param state with the URL at the end of a transition.
+   */
+  finalizeQueryParamChange(
+    bucket: Bucket,
+    params: Record<string, string | null | undefined>,
+    // eslint-disable-next-line @typescript-eslint/no-empty-object-type
+    finalParams: {}[],
+    transition: Transition
+  ): boolean | void;
+
+  /**
+    Resolves the route's context from URL params, backing the classic
+    `model`/`deserialize` hooks. Called by the router for param-based
+    transitions (not when a model object was supplied to the transition).
+   */
+  getContext(bucket: Bucket, params: Record<string, unknown>, transition: Transition): unknown;
+
+  /**
+    Classic `Route.redirect` hook. Called once the route's context has
+    resolved.
+   */
+  redirect(bucket: Bucket, routeInfo: RouteInfo, context: unknown, transition: Transition): void;
+
+  /**
+    Enters the classic `loading` substate for a slow transition: looks up
+    the nearest `*.loading`/`*_loading` route (stopping at the transition's
+    pivot) and intermediate-transitions into it. Called by the router's
+    default `loading` action handler once the loading event has bubbled
+    unhandled above the application route.
+
+    `originRoute` is the route whose model is slow, or `undefined` when that
+    route was never created; typed `unknown` because router_js never
+    inspects route shapes.
+   */
+  enterLoadingSubstate(bucket: Bucket, transition: Transition, originRoute: unknown): void;
+
+  /**
+    Enters the classic `error` substate for an error that bubbled unhandled
+    above the application route: looks up the nearest `*.error`/`*_error`
+    route and intermediate-transitions into it, passing the error as its
+    model. Returns `true` when a substate was entered and the error should
+    be treated as handled.
+
+    `originRoute` is the route whose `enter` failed, or `undefined` when
+    that route was never created (e.g. across an engine's async boundary);
+    typed `unknown` because router_js never inspects route shapes.
+   */
+  enterErrorSubstate(
+    bucket: Bucket,
+    transition: Transition,
+    error: Error,
+    originRoute: unknown
+  ): boolean;
+
+  /**
+    Returns the route-provided `RouteInfo` metadata, backing the classic
+    `Route.buildRouteInfoMetadata` hook.
+   */
+  getRouteInfoMetadata(bucket: Bucket): unknown;
+}
+
+/**
+  Type guard for narrowing a `RouteManager` to its classic-interop shape.
+ */
+export function hasClassicInterop<Bucket extends RouteStateBucket>(
+  manager: RouteManager<Bucket>
+): manager is RouteManagerWithClassicInterop<Bucket> {
+  return manager.capabilities.classicInterop === true;
+}
diff --git a/packages/router_js/lib/router.ts b/packages/router_js/lib/router.ts
index 0dd1300ae8c..3feef485843 100644
--- a/packages/router_js/lib/router.ts
+++ b/packages/router_js/lib/router.ts
@@ -3,12 +3,13 @@ import type { MatchCallback, Params, QueryParams } from 'route-recognizer';
 import RouteRecognizer from 'route-recognizer';
 import { Promise } from 'rsvp';
 import type { Dict, Maybe, Option } from './core';
-import type { ModelFor, Route, RouteInfo, RouteInfoWithAttributes } from './route-info';
+import type { ModelFor, BaseRoute, RouteInfo, RouteInfoWithAttributes } from './route-info';
 import type InternalRouteInfo from './route-info';
 import { toReadOnlyRouteInfo } from './route-info';
 import type { OpaqueTransition, PublicTransition as Transition } from './transition';
 import InternalTransition, { logAbort, QUERY_PARAMS_SYMBOL, STATE_SYMBOL } from './transition';
-import { throwIfAborted, isTransitionAborted } from './transition-aborted-error';
+import type { DidEnterState, DidExitState, ExitState, WillExitState } from './route-manager';
+import { hasClassicInterop } from './route-manager';
 import type { TransitionIntent } from './transition-intent';
 import NamedTransitionIntent from './transition-intent/named-transition-intent';
 import URLTransitionIntent from './transition-intent/url-transition-intent';
@@ -26,7 +27,7 @@ export interface ParsedHandler {
   names: string[];
 }
 
-export default abstract class Router<R extends Route> {
+export default abstract class Router<R extends BaseRoute> {
   private _lastQueryParams = {};
   log?: (message: string) => void;
   state?: TransitionState<R> = undefined;
@@ -64,6 +65,293 @@ export default abstract class Router<R extends Route> {
   abstract routeDidChange(transition: Transition): void;
   abstract transitionDidError(error: TransitionError, transition: Transition): Transition | Error;
 
+  // -- Manager-driven transition lifecycle -------------------------------------
+  //
+  // The three `on*` methods below drive the RouteManager lifecycle for every
+  // router. Host routers (EmberRouter's microlib, the test router) customize
+  // behaviour through the small protected hooks rather than re-implementing
+  // the orchestration.
+
+  /**
+    Whether the host application is tearing down. A destroyed router skips
+    the post-settle lifecycle (didEnter/didExit, URL update, events).
+   */
+  protected isRouterDestroyed(): boolean {
+    return false;
+  }
+
+  /**
+    Host hook: schedule a render-tree update because `currentRouteInfos`
+    changed. EmberRouter renders by scheduling `_setOutlets`; the default is
+    a no-op for hosts that don't render.
+
+    Called with `immediate: true` when the update must render right away for
+    correctness — the transition settled, or a loading/error substate was
+    entered.
+
+    Called with `immediate: false` for the incremental updates fired as each
+    route in an in-flight transition becomes ready. These are an optimization
+    (render parent routes while a child's model is still loading), and a host
+    is free to delay or batch them. Batching matters: each readiness event
+    arrives in its own run loop, so rendering one pass per event walks the
+    outlet tree once per route — 12 renders for a single 9-route transition,
+    measured, where 2 suffice.
+   */
+  protected scheduleOutletUpdate(_immediate = false): void {}
+
+  /**
+    Handles an error thrown synchronously by a `didEnter` hook (classic
+    `activate`/`setupController`). The default routes it through
+    `transitionDidError` — so it reaches error actions/substates the same way
+    `enter` rejections do — and throws the resulting reason so the transition
+    promise rejects.
+   */
+  protected handleDidEnterError(
+    error: unknown,
+    activeTransition: InternalTransition<R>,
+    newState: TransitionState<R>,
+    _preTransitionState: TransitionState<R> | undefined
+  ): never {
+    const errorRoute = newState.routeInfos[newState.routeInfos.length - 1]?.route;
+    const reason = this.transitionDidError(
+      { error, route: errorRoute, wasAborted: false } as unknown as TransitionError,
+      activeTransition
+    );
+    throw reason;
+  }
+
+  // Called once per route in parent-to-child order as each route's
+  // `getInvokable` resolves. Writes the route into `currentRouteInfos` at its
+  // slot and schedules a render so the outlet tree builds up incrementally
+  // instead of waiting for the whole transition to settle.
+  onRouteInvokableReady(
+    routeInfo: InternalRouteInfo<R>,
+    _transition: InternalTransition<R>,
+    routeIndex: number
+  ): void {
+    const currentRouteInfos = this.currentRouteInfos ?? [];
+    currentRouteInfos[routeIndex] = routeInfo;
+    this.currentRouteInfos = currentRouteInfos;
+    this.scheduleOutletUpdate(false);
+  }
+
+  // Called when `intermediateTransitionTo` fires (a classic loading or error
+  // substate). Splices the substate into `currentRouteInfos` without
+  // disturbing already-rendering ancestor routes and fires `didEnter` so
+  // classic activate/setup runs. Substates are classic machinery, so the
+  // didEnter only goes to classic-interop managers.
+  onIntermediateTransition(newState: TransitionState<R>, transition: InternalTransition<R>): void {
+    const partition = this.partitionRoutes(this.state!, newState);
+    this.currentRouteInfos = [...partition.unchanged, ...partition.entered];
+
+    this.oldState = this.state;
+    this.state = newState;
+
+    const navFrom = (transition.from ?? undefined) as RouteInfo | undefined;
+    const navTo = transition.to as RouteInfo;
+
+    const fireDidEnter = (routeInfo: InternalRouteInfo<R>) => {
+      const { manager, bucket } = routeInfo;
+      if (manager === undefined || bucket === undefined || !hasClassicInterop(manager)) {
+        return;
+      }
+      manager.didEnter(bucket, {
+        from: navFrom,
+        to: navTo,
+        transition,
+        internalRouteInfo: routeInfo,
+        enter: true,
+      });
+    };
+
+    for (const routeInfo of partition.entered) {
+      if (routeInfo.route !== undefined) {
+        fireDidEnter(routeInfo);
+      } else {
+        // Async route (e.g. across an engine boundary): fire once it resolves.
+        void routeInfo.routePromise.then(() => fireDidEnter(routeInfo));
+      }
+    }
+
+    this.scheduleOutletUpdate(true);
+  }
+
+  // Called once every route in the transition has resolved. Runs the rest of
+  // the lifecycle through the RouteManager API:
+  //
+  //   1. `willExit` + `exit` on routes leaving the hierarchy
+  //   2. classic-interop `willExit(isExiting=false)` on updated routes
+  //   3. awaits every entering/updating route's `enterPromise`
+  //   4. `didEnter` on entered routes (and, interop-only, updated routes)
+  //   5. `didExit` on exited routes
+  //   6. query-param finalisation, URL update, didTransition events
+  //
+  // Resolves the transition's promise with the leaf route, preserving the
+  // classic `finalizeTransition` contract.
+  onTransitionSettled(
+    activeTransition: InternalTransition<R>,
+    newState: TransitionState<R>
+  ): Promise<unknown> {
+    const partition = this.partitionRoutes(this.state!, newState);
+    const preTransitionState = this.state;
+
+    this.oldState = this.state;
+    this.state = newState;
+
+    const navFrom = (activeTransition.from ?? undefined) as RouteInfo | undefined;
+    const navTo = activeTransition.to as RouteInfo;
+    const cancel = () => activeTransition.abort();
+
+    // Leaving the hierarchy: willExit + exit, leaf-first.
+    for (const exitingRouteInfo of partition.exited) {
+      const { manager, bucket } = exitingRouteInfo;
+      if (manager !== undefined && bucket !== undefined) {
+        const willExitState: WillExitState = { from: navFrom, to: navTo, cancel };
+        const exitState: ExitState = { from: navFrom, to: navTo };
+        if (hasClassicInterop(manager)) {
+          Object.assign(willExitState, {
+            transition: activeTransition,
+            internalRouteInfo: exitingRouteInfo,
+            isExiting: true,
+          });
+          Object.assign(exitState, { transition: activeTransition });
+        }
+        manager.willExit(bucket, willExitState);
+        manager.exit(bucket, exitState);
+      }
+    }
+
+    // Filter exited routes out of currentRouteInfos. Truncating to
+    // `unchanged.length` would lose entering routes that
+    // `onRouteInvokableReady` already wrote at higher indices.
+    const exitedRouteObjects = new Set(partition.exited.map((ri) => ri.route));
+    if (this.currentRouteInfos) {
+      this.currentRouteInfos = this.currentRouteInfos.filter(
+        (cri) => !exitedRouteObjects.has(cri.route)
+      );
+    }
+
+    // "Context updated while staying mounted" is the classic update path; the
+    // RFC treats updates as a manager-internal concern, so only interop
+    // managers receive this willExit.
+    for (const resetRouteInfo of partition.reset) {
+      const { manager, bucket } = resetRouteInfo;
+      if (manager !== undefined && bucket !== undefined && hasClassicInterop(manager)) {
+        manager.willExit(bucket, {
+          from: navFrom,
+          to: navTo,
+          cancel,
+          transition: activeTransition,
+          internalRouteInfo: resetRouteInfo,
+          isExiting: false,
+        });
+      }
+    }
+
+    // Await all entering/updating routes' enter promises. Swallow rejections
+    // here: a rejected enterPromise has already been routed through
+    // `transitionDidError`; rethrowing would fire the global unhandled
+    // rejection handler on subsequent transitions.
+    const enteringRouteInfos = [...partition.entered, ...partition.updatedContext];
+    const enterPromises = enteringRouteInfos.map((routeInfo) => {
+      const p = routeInfo.enterPromise ?? Promise.resolve(undefined);
+      return p.catch(() => undefined);
+    });
+
+    return Promise.all(enterPromises).then(() => {
+      if (this.isRouterDestroyed()) {
+        return;
+      }
+      if (activeTransition.isAborted) {
+        return;
+      }
+
+      try {
+        for (const enteredRouteInfo of partition.entered) {
+          const { manager, bucket } = enteredRouteInfo;
+          if (manager !== undefined && bucket !== undefined) {
+            const didEnterState: DidEnterState = { from: navFrom, to: navTo };
+            if (hasClassicInterop(manager)) {
+              Object.assign(didEnterState, {
+                transition: activeTransition,
+                internalRouteInfo: enteredRouteInfo,
+                enter: true,
+              });
+            }
+            manager.didEnter(bucket, didEnterState);
+          }
+        }
+
+        // The `enter: false` didEnter is the classic update path (see the
+        // reset loop above); only interop managers receive it.
+        for (const updatedRouteInfo of partition.updatedContext) {
+          const { manager, bucket } = updatedRouteInfo;
+          if (manager !== undefined && bucket !== undefined && hasClassicInterop(manager)) {
+            manager.didEnter(bucket, {
+              from: navFrom,
+              to: navTo,
+              transition: activeTransition,
+              internalRouteInfo: updatedRouteInfo,
+              enter: false,
+            });
+          }
+        }
+      } catch (error) {
+        return this.handleDidEnterError(error, activeTransition, newState, preTransitionState);
+      }
+
+      // A didEnter hook may have redirected (classic `transitionTo` inside
+      // `setupController`); reject with the abort so the transition promise
+      // settles the way classic callers expect.
+      if (activeTransition.isAborted) {
+        throw logAbort(activeTransition);
+      }
+
+      for (const exitedRouteInfo of partition.exited) {
+        const { manager, bucket } = exitedRouteInfo;
+        if (manager !== undefined && bucket !== undefined) {
+          const didExitState: DidExitState = { from: navFrom, to: navTo };
+          if (hasClassicInterop(manager)) {
+            Object.assign(didExitState, {
+              transition: activeTransition,
+              internalRouteInfo: exitedRouteInfo,
+            });
+          }
+          manager.didExit(bucket, didExitState);
+        }
+      }
+
+      // Snap currentRouteInfos to the authoritative settled list.
+      this.currentRouteInfos = newState.routeInfos.slice();
+
+      this.state!.queryParams = this.finalizeQueryParamChange(
+        this.currentRouteInfos,
+        newState.queryParams,
+        activeTransition
+      );
+
+      this._updateURL(activeTransition, newState);
+
+      activeTransition.isActive = false;
+      // Only clear `activeTransition` if it's still us; a newer transition
+      // may already have replaced it.
+      if (this.activeTransition === activeTransition) {
+        this.activeTransition = undefined;
+      }
+
+      this.scheduleOutletUpdate(true);
+
+      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, preserving the
+      // classic finalizeTransition contract.
+      return newState.routeInfos[newState.routeInfos.length - 1]?.route;
+    });
+  }
+
   /**
     The main entry point into the router. The API is essentially
     the same as the `map` method in `route-recognizer`.
@@ -124,7 +412,7 @@ export default abstract class Router<R extends Route> {
       this.routeWillChange(newTransition);
 
       newTransition.promise = newTransition.promise!.then(
-        (result: TransitionState<R> | Route | Error | undefined) => {
+        (result: TransitionState<R> | BaseRoute | Error | undefined) => {
           if (!newTransition.isAborted) {
             this._updateURL(newTransition, oldState);
             this.didTransition(this.currentRouteInfos!);
@@ -227,7 +515,7 @@ export default abstract class Router<R extends Route> {
       let transition = new InternalTransition(this, undefined, newState);
       transition.isIntermediate = true;
       this.toReadOnlyInfos(transition, newState);
-      this.setupContexts(newState, transition);
+      this.onIntermediateTransition(newState, transition);
 
       this.routeWillChange(transition);
       return this.activeTransition!;
@@ -260,7 +548,7 @@ export default abstract class Router<R extends Route> {
     // after the transition has been finalized.
     newTransition.promise = newTransition.promise!.then(
       (result: TransitionState<R>) => {
-        return this.finalizeTransition(newTransition, result);
+        return this.onTransitionSettled(newTransition, result);
       },
       null,
       promiseLabel('Settle transition promise when transition is finalized')
@@ -336,159 +624,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 +645,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 +683,9 @@ export default abstract class Router<R extends Route> {
 
   @return {Partition}
 */
-  private partitionRoutes(oldState: TransitionState<R>, newState: TransitionState<R>) {
+  // Exposed so manager-driven routers (e.g. EmberRouter) can compute
+  // partitions when orchestrating their own lifecycle.
+  partitionRoutes(oldState: TransitionState<R>, newState: TransitionState<R>) {
     let oldRouteInfos = oldState.routeInfos;
     let newRouteInfos = newState.routeInfos;
 
@@ -646,7 +733,9 @@ export default abstract class Router<R extends Route> {
     return routes;
   }
 
-  private _updateURL(transition: OpaqueTransition, state: TransitionState<R>) {
+  // Exposed so manager-driven routers can update the URL after awaiting
+  // their async lifecycle.
+  _updateURL(transition: OpaqueTransition, state: TransitionState<R>) {
     let urlMethod: string | null = transition.urlMethod;
 
     if (!urlMethod) {
@@ -709,7 +798,9 @@ export default abstract class Router<R extends Route> {
     }
   }
 
-  private finalizeQueryParamChange(
+  // Exposed so manager-driven routers can finalize QPs as part of their
+  // own transition settlement.
+  finalizeQueryParamChange(
     resolvedHandlers: InternalRouteInfo<R>[],
     newQueryParams: Dict<unknown>,
     transition: OpaqueTransition
@@ -825,11 +916,9 @@ export default abstract class Router<R extends Route> {
   reset() {
     if (this.state) {
       forEach<InternalRouteInfo<R>>(this.state.routeInfos.slice().reverse(), function (routeInfo) {
-        let route = routeInfo.route;
-        if (route !== undefined) {
-          if (route.exit !== undefined) {
-            route.exit();
-          }
+        let { manager, bucket } = routeInfo;
+        if (manager !== undefined && bucket !== undefined) {
+          manager.exit(bucket);
         }
         return true;
       });
@@ -1031,7 +1120,7 @@ export default abstract class Router<R extends Route> {
   }
 }
 
-function routeInfosEqual<R1 extends Route, R2 extends Route>(
+function routeInfosEqual<R1 extends BaseRoute, R2 extends BaseRoute>(
   routeInfos: InternalRouteInfo<R1>[],
   otherRouteInfos: InternalRouteInfo<R2>[]
 ) {
@@ -1048,7 +1137,7 @@ function routeInfosEqual<R1 extends Route, R2 extends Route>(
   return true;
 }
 
-function routeInfosSameExceptQueryParams<R1 extends Route, R2 extends Route>(
+function routeInfosSameExceptQueryParams<R1 extends BaseRoute, R2 extends BaseRoute>(
   routeInfos: InternalRouteInfo<R1>[],
   otherRouteInfos: InternalRouteInfo<R2>[]
 ) {
@@ -1097,7 +1186,7 @@ function paramsEqual(params: Dict<unknown> | undefined, otherParams: Dict<unknow
   return true;
 }
 
-export interface RoutePartition<R extends Route> {
+export interface RoutePartition<R extends BaseRoute> {
   updatedContext: InternalRouteInfo<R>[];
   exited: InternalRouteInfo<R>[];
   entered: InternalRouteInfo<R>[];
diff --git a/packages/router_js/lib/transition-intent.ts b/packages/router_js/lib/transition-intent.ts
index d3c2595fdf2..a2707b156f8 100644
--- a/packages/router_js/lib/transition-intent.ts
+++ b/packages/router_js/lib/transition-intent.ts
@@ -1,10 +1,10 @@
-import type { Route } from './route-info';
+import type { BaseRoute } from './route-info';
 import type Router from './router';
 import type TransitionState from './transition-state';
 
 export type OpaqueIntent = TransitionIntent<any>;
 
-export abstract class TransitionIntent<R extends Route> {
+export abstract class TransitionIntent<R extends BaseRoute> {
   data: object;
   router: Router<R>;
   constructor(router: Router<R>, data: object = {}) {
diff --git a/packages/router_js/lib/transition-intent/named-transition-intent.ts b/packages/router_js/lib/transition-intent/named-transition-intent.ts
index c99cf319797..34286abd7dd 100644
--- a/packages/router_js/lib/transition-intent/named-transition-intent.ts
+++ b/packages/router_js/lib/transition-intent/named-transition-intent.ts
@@ -1,6 +1,6 @@
 /* eslint-disable no-prototype-builtins */
 import type { Dict } from '../core';
-import type { ModelFor, ResolvedRouteInfo, Route } from '../route-info';
+import type { ModelFor, ResolvedRouteInfo, BaseRoute } from '../route-info';
 import type InternalRouteInfo from '../route-info';
 import { UnresolvedRouteInfoByObject, UnresolvedRouteInfoByParam } from '../route-info';
 import type { ParsedHandler } from '../router';
@@ -9,9 +9,9 @@ import { TransitionIntent } from '../transition-intent';
 import TransitionState from '../transition-state';
 import { isParam, merge } from '../utils';
 
-export default class NamedTransitionIntent<R extends Route> extends TransitionIntent<R> {
+export default class NamedTransitionIntent<R extends BaseRoute> extends TransitionIntent<R> {
   name: string;
-  pivotHandler?: Route;
+  pivotHandler?: BaseRoute;
   contexts: ModelFor<R>[];
   queryParams: Dict<unknown>;
   preTransitionState?: TransitionState<R> = undefined;
@@ -19,7 +19,7 @@ export default class NamedTransitionIntent<R extends Route> extends TransitionIn
   constructor(
     router: Router<R>,
     name: string,
-    pivotHandler: Route | undefined,
+    pivotHandler: BaseRoute | undefined,
     contexts: ModelFor<R>[] = [],
     queryParams: Dict<unknown> = {},
     data?: object
diff --git a/packages/router_js/lib/transition-intent/url-transition-intent.ts b/packages/router_js/lib/transition-intent/url-transition-intent.ts
index ff5cfde36f7..d04c0706cc5 100644
--- a/packages/router_js/lib/transition-intent/url-transition-intent.ts
+++ b/packages/router_js/lib/transition-intent/url-transition-intent.ts
@@ -1,4 +1,4 @@
-import type { Route } from '../route-info';
+import type { BaseRoute } from '../route-info';
 import { UnresolvedRouteInfoByParam } from '../route-info';
 import type Router from '../router';
 import { TransitionIntent } from '../transition-intent';
@@ -6,7 +6,7 @@ import TransitionState from '../transition-state';
 import UnrecognizedURLError from '../unrecognized-url-error';
 import { merge } from '../utils';
 
-export default class URLTransitionIntent<R extends Route> extends TransitionIntent<R> {
+export default class URLTransitionIntent<R extends BaseRoute> extends TransitionIntent<R> {
   preTransitionState?: TransitionState<R>;
   url: string;
   constructor(router: Router<R>, url: string, data?: object) {
diff --git a/packages/router_js/lib/transition-state.ts b/packages/router_js/lib/transition-state.ts
index e10c7c7361c..056a2125703 100644
--- a/packages/router_js/lib/transition-state.ts
+++ b/packages/router_js/lib/transition-state.ts
@@ -1,16 +1,17 @@
 import { Promise } from 'rsvp';
 import type { Dict } from './core';
-import type { Route, ResolvedRouteInfo } from './route-info';
+import type { BaseRoute, ResolvedRouteInfo, RouteInfo } from './route-info';
 import type InternalRouteInfo from './route-info';
 import type Transition from './transition';
 import { forEach, promiseLabel } from './utils';
 import { throwIfAborted } from './transition-aborted-error';
+import { hasClassicInterop } from './route-manager';
 
 interface IParams {
   [key: string]: unknown;
 }
 
-function handleError<R extends Route>(
+function handleError<R extends BaseRoute>(
   currentState: TransitionState<R>,
   transition: Transition<R>,
   error: Error
@@ -31,7 +32,7 @@ function handleError<R extends Route>(
   );
 }
 
-function resolveOneRouteInfo<R extends Route>(
+function resolveOneRouteInfo<R extends BaseRoute>(
   currentState: TransitionState<R>,
   transition: Transition<R>
 ): void | Promise<void> {
@@ -50,13 +51,13 @@ function resolveOneRouteInfo<R extends Route>(
   return routeInfo.resolve(transition).then(callback, null, currentState.promiseLabel('Proceed'));
 }
 
-function proceed<R extends Route>(
+function proceed<R extends BaseRoute>(
   currentState: TransitionState<R>,
   transition: Transition<R>,
   resolvedRouteInfo: ResolvedRouteInfo<R>
 ): void | Promise<void> {
   let wasAlreadyResolved = currentState.routeInfos[transition.resolveIndex]!.isResolved;
-
+  const routeIndex = transition.resolveIndex;
   // Swap the previously unresolved routeInfo with
   // the resolved routeInfo
   currentState.routeInfos[transition.resolveIndex++] = resolvedRouteInfo;
@@ -66,14 +67,22 @@ function proceed<R extends Route>(
     // 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);
-      }
+    let { manager, bucket } = resolvedRouteInfo;
+    if (manager !== undefined && hasClassicInterop(manager) && bucket !== undefined) {
+      manager.redirect(
+        bucket,
+        resolvedRouteInfo as unknown as RouteInfo,
+        resolvedRouteInfo.context,
+        transition
+      );
     }
   }
 
+  // a couple of tests have no router instance
+  // so we use optional chaining here to avoid
+  // throwing an error in those tests
+  transition.router?.onRouteInvokableReady(resolvedRouteInfo, transition, routeIndex);
+
   // Proceed after ensuring that the redirect hook
   // didn't abort this transition by transitioning elsewhere.
   throwIfAborted(transition);
@@ -81,7 +90,7 @@ function proceed<R extends Route>(
   return resolveOneRouteInfo(currentState, transition);
 }
 
-export default class TransitionState<R extends Route> {
+export default class TransitionState<R extends BaseRoute> {
   routeInfos: InternalRouteInfo<R>[] = [];
   queryParams: Dict<unknown> = {};
   params: IParams = {};
@@ -123,7 +132,7 @@ export default class TransitionState<R extends Route> {
 export class TransitionError {
   constructor(
     public error: Error,
-    public route: Route,
+    public route: BaseRoute,
     public wasAborted: boolean,
     public state: TransitionState<any>
   ) {}
diff --git a/packages/router_js/lib/transition.ts b/packages/router_js/lib/transition.ts
index 3bca750fca5..129b486c810 100644
--- a/packages/router_js/lib/transition.ts
+++ b/packages/router_js/lib/transition.ts
@@ -1,6 +1,6 @@
 import { Promise } from 'rsvp';
 import type { Dict, Maybe, Option } from './core';
-import type { ModelFor, Route, RouteInfo, RouteInfoWithAttributes } from './route-info';
+import type { ModelFor, BaseRoute, RouteInfo, RouteInfoWithAttributes } from './route-info';
 import type InternalRouteInfo from './route-info';
 import type Router from './router';
 import type { TransitionAbortedError } from './transition-aborted-error';
@@ -43,7 +43,7 @@ export const REDIRECT_DESTINATION_SYMBOL = `__RDS__-2619863929824844-32323`;
   @param {Object} error
   @private
  */
-export default class Transition<R extends Route> implements Partial<Promise<R>> {
+export default class Transition<R extends BaseRoute> implements Partial<Promise<R>> {
   [STATE_SYMBOL]: TransitionState<R>;
   from: Maybe<RouteInfoWithAttributes> = null;
   to?: RouteInfo | RouteInfoWithAttributes = undefined;
@@ -72,6 +72,14 @@ export default class Transition<R extends Route> implements Partial<Promise<R>>
   isIntermediate = false;
   [REDIRECT_DESTINATION_SYMBOL]?: Transition<R>;
 
+  // AbortController for the navigation. Managers receive its `signal` via
+  // `AsyncNavigationState` and can pass it to `fetch()` or any other
+  // AbortSignal consumer. The signal aborts whenever the transition is no
+  // longer the active one (explicit cancel or superseded by a newer
+  // transition).
+  abortController = new AbortController();
+  signal: AbortSignal = this.abortController.signal;
+
   /**
     In non-production builds, this function will return the stack that this Transition was
     created within. In production builds, this function will not be present.
@@ -292,6 +300,7 @@ export default class Transition<R extends Route> implements Partial<Promise<R>>
   rollback() {
     if (!this.isAborted) {
       log(this.router, this.sequence, this.targetName + ': transition was aborted');
+      this.abortController.abort();
 
       if (DEBUG) {
         let error = new Error(`Transition aborted stack`);
@@ -375,7 +384,7 @@ export default class Transition<R extends Route> implements Partial<Promise<R>>
     _name: string,
     err?: Error,
     transition?: Transition<R>,
-    handler?: Route
+    handler?: BaseRoute
   ) {
     this.trigger(ignoreFailure, _name, err, transition, handler);
   }
diff --git a/packages/router_js/package.json b/packages/router_js/package.json
index 68628f0ac24..7d735386cc2 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:*"
   },
diff --git a/packages/router_js/tests/async_get_handler_test.ts b/packages/router_js/tests/async_get_handler_test.ts
index 73637c8610a..fc0ebb9afc2 100644
--- a/packages/router_js/tests/async_get_handler_test.ts
+++ b/packages/router_js/tests/async_get_handler_test.ts
@@ -1,4 +1,4 @@
-import type { Route } from '../index';
+import type { BaseRoute } from '../index';
 import type { Dict } from '../lib/core';
 import { Promise } from 'rsvp';
 import { createHandler, TestRouter } from './test_helpers';
@@ -16,7 +16,7 @@ function map(router: TestRouter) {
 // Intentionally use QUnit.module instead of module from test_helpers
 // so that we avoid using Backburner to handle the async portions of
 // the test suite
-let routes: Dict<Route>;
+let routes: Dict<BaseRoute>;
 let router: TestRouter;
 QUnit.module('Async Get Handler', {
   beforeEach: function () {
diff --git a/packages/router_js/tests/query_params_test.ts b/packages/router_js/tests/query_params_test.ts
index d816289fa9a..f1eccf2013d 100644
--- a/packages/router_js/tests/query_params_test.ts
+++ b/packages/router_js/tests/query_params_test.ts
@@ -1,13 +1,14 @@
 /* eslint-disable qunit/no-conditional-assertions */
 import type { MatchCallback } from 'route-recognizer';
-import type { Route, Transition } from '../index';
+import type { BaseRoute, Transition } from '../index';
 import type Router from '../index';
 import type { Dict, Maybe } from '../lib/core';
 import type RouteInfo from '../lib/route-info';
+import type { ClassicRoute } from '../lib/route-info';
 import { Promise } from 'rsvp';
 import { createHandler, TestRouter, trigger, ignoreTransitionError } from './test_helpers';
 
-let router: Router<Route>, handlers: Dict<Route>, expectedUrl: Maybe<string>;
+let router: Router<BaseRoute>, handlers: Dict<BaseRoute>, expectedUrl: Maybe<string>;
 let scenarios = [
   {
     name: 'Sync Get Handler',
@@ -46,7 +47,7 @@ scenarios.forEach(function (scenario) {
       didTransition() {}
       willTransition() {}
       triggerEvent(
-        handlerInfos: RouteInfo<Route>[],
+        handlerInfos: RouteInfo<ClassicRoute>[],
         ignoreFailure: boolean,
         name: string,
         args: any[]
@@ -319,7 +320,7 @@ scenarios.forEach(function (scenario) {
             if (count === 0) {
               assert.ok(false, "shouldn't fire on first trans");
             } else {
-              router.refresh(this as Route);
+              router.refresh(this as ClassicRoute);
             }
           },
           finalizeQueryParamChange: consumeAllFinalQueryParams,
@@ -492,7 +493,7 @@ scenarios.forEach(function (scenario) {
         },
         events: {
           queryParamsDidChange: function () {
-            router.refresh(this as Route);
+            router.refresh(this as ClassicRoute);
           },
         },
       });
@@ -531,7 +532,7 @@ scenarios.forEach(function (scenario) {
         queryParamsDidChange: function () {
           assert.ok(true, 'index#queryParamsDidChange');
           redirect = causeRedirect;
-          router.refresh(this as Route);
+          router.refresh(this as ClassicRoute);
         },
         finalizeQueryParamChange: function (params: Dict<unknown>, finalParams: Dict<unknown>[]) {
           (finalParams as any).foo = params['foo']; // TODO wat
diff --git a/packages/router_js/tests/route_info_test.ts b/packages/router_js/tests/route_info_test.ts
index 31ba500e7b7..605c754af80 100644
--- a/packages/router_js/tests/route_info_test.ts
+++ b/packages/router_js/tests/route_info_test.ts
@@ -1,13 +1,14 @@
 import type { Transition } from '../index';
 import type { Dict } from '../lib/core';
-import type { IModel, Route } from '../lib/route-info';
+import type { IModel, ClassicRoute } from '../lib/route-info';
 import {
   ResolvedRouteInfo,
   toReadOnlyRouteInfo,
   UnresolvedRouteInfoByObject,
   UnresolvedRouteInfoByParam,
 } from '../lib/route-info';
-import InternalTransition from '../lib/transition';
+import InternalTransition, { STATE_SYMBOL } from '../lib/transition';
+import { associateRouteManagement } from '../lib/route-manager';
 import URLTransitionIntent from '../lib/transition-intent/url-transition-intent';
 import { resolve } from 'rsvp';
 import { createHandler, createHandlerInfo, TestRouter } from './test_helpers';
@@ -165,9 +166,9 @@ QUnit.test('UnresolvedRouteInfoByObject does NOT get its model hook called', fun
 
   assert.expect(1);
 
-  class TestRouteInfo extends UnresolvedRouteInfoByObject<Route<Dorkleton>> {
-    __routeHandler?: Route<Dorkleton>;
-    get route(): Route<Dorkleton> {
+  class TestRouteInfo extends UnresolvedRouteInfoByObject<ClassicRoute<Dorkleton>> {
+    __routeHandler?: ClassicRoute<Dorkleton>;
+    get route(): ClassicRoute<Dorkleton> {
       if (this.__routeHandler) {
         return this.__routeHandler;
       }
@@ -234,3 +235,168 @@ QUnit.test('RouteInfo.find returns matched', function (assert) {
   });
   assert.equal(childInfo!.name, 'child');
 });
+
+QUnit.module('RouteInfo - non-gating manager');
+
+// Builds a handler whose manager mimics a manager that does not gate
+// getInvokable on enterPromise, so a route becomes resolved and renders
+// (e.g. a loading substate) before its `enter` settles with the context.
+// The `enter` hook is supplied per test.
+function createNonGatingHandler(
+  name: string,
+  enter: (bucket: any, args: any) => Promise<unknown>
+): ClassicRoute {
+  let manager = {
+    capabilities: { classicInterop: false },
+    willEnter() {},
+    enter,
+    // Resolves immediately, without awaiting enterPromise. This is the
+    // behaviour that makes the context unavailable at becomeResolved time.
+    getInvokable() {
+      return resolve(undefined);
+    },
+  };
+
+  let handler = createHandler(name);
+  associateRouteManagement(handler, manager as never, { route: handler, invokable: undefined });
+  return handler;
+}
+
+QUnit.test(
+  'resolved routeInfo.context syncs with the enter result when getInvokable does not gate on enterPromise',
+  async function (assert) {
+    assert.expect(3);
+
+    let router = new TestRouter();
+    let model = { id: 'real-model' };
+
+    let resolveEnter!: (value: unknown) => void;
+    let enterPromise = new Promise<unknown>((res) => {
+      resolveEnter = res;
+    });
+
+    let handler = createNonGatingHandler('async-parent', () => enterPromise);
+    let routeInfo = new UnresolvedRouteInfoByParam(router, 'async-parent', [], {}, handler);
+
+    let transition = { isAborted: false } as unknown as InternalTransition<ClassicRoute>;
+
+    let resolved = await routeInfo.resolve(transition);
+
+    // becomeResolved ran before `enter` settled, so the snapshot is empty.
+    assert.equal(resolved.context, undefined, 'context is undefined until enter settles');
+
+    resolveEnter(model);
+    await enterPromise;
+    await resolve();
+
+    assert.equal(resolved.context, model, 'resolved context syncs once enter settles');
+    assert.equal(
+      transition.resolvedModels!['async-parent'],
+      model,
+      'transition.resolvedModels is kept in sync for modelFor'
+    );
+  }
+);
+
+QUnit.test('getAncestorContext resolves with the ancestor enter result', async function (assert) {
+  assert.expect(1);
+
+  let router = new TestRouter();
+  let ancestorModel = { id: 'ancestor-model' };
+
+  // The ancestor's enter resolved with the model, but its `context` property
+  // was never populated.
+  let ancestorInfo = {
+    name: 'parent',
+    enterPromise: resolve(ancestorModel),
+    context: undefined,
+  };
+
+  let captured: ((routeInfo: any) => Promise<unknown>) | undefined;
+  let handler = createNonGatingHandler('parent.child', (_bucket, args) => {
+    captured = args.getAncestorContext;
+    return resolve(undefined);
+  });
+  let childInfo = new UnresolvedRouteInfoByParam(router, 'parent.child', [], {}, handler);
+
+  let transition = { isAborted: false } as unknown as InternalTransition<ClassicRoute>;
+  // Seed the transition state so getAncestorContext can find the ancestor.
+  transition[STATE_SYMBOL] = { routeInfos: [ancestorInfo] } as never;
+
+  await childInfo.resolve(transition);
+
+  let result = await captured!({ name: 'parent' });
+  assert.equal(result, ancestorModel, 'getAncestorContext resolves with the ancestor enter result');
+});
+
+QUnit.test(
+  'resolving a by-param route info does not give it an own `context`',
+  async function (assert) {
+    assert.expect(3);
+
+    let router = new TestRouter();
+    let model = { id: 'the-model' };
+    let handler = createNonGatingHandler('thing', () => resolve(model));
+    let routeInfo = new UnresolvedRouteInfoByParam(router, 'thing', [], {}, handler);
+
+    assert.false('context' in routeInfo, 'a fresh by-param route info has no own context');
+
+    let transition = { isAborted: false } as unknown as InternalTransition<ClassicRoute>;
+    let resolved = await routeInfo.resolve(transition);
+    await resolve();
+
+    assert.equal(resolved.context, model, 'the resolved info still receives the entered context');
+    // `shouldSupersede` treats `'context' in routeInfo` as meaningful when
+    // route infos are reused across transitions; the enter-promise plumbing
+    // must not fabricate an own context the info never had (main parity).
+    assert.false(
+      'context' in routeInfo,
+      'resolution does not write a context onto the unresolved info'
+    );
+  }
+);
+
+QUnit.test('getAncestorContext only matches true ancestors', async function (assert) {
+  assert.expect(2);
+
+  let router = new TestRouter();
+  let ancestorModel = { id: 'ancestor-model' };
+
+  let ancestorInfo = {
+    name: 'parent',
+    enterPromise: resolve(ancestorModel),
+    context: undefined,
+  };
+  // A pending descendant: handing out its enter promise would deadlock a
+  // manager that awaited it.
+  let descendantInfo = {
+    name: 'parent.child.grand',
+    enterPromise: new Promise(() => {}),
+    context: undefined,
+  };
+
+  let captured: ((routeInfo: any) => Promise<unknown>) | undefined;
+  let handler = createNonGatingHandler('parent.child', (_bucket, args) => {
+    captured = args.getAncestorContext;
+    return resolve(undefined);
+  });
+  let childInfo = new UnresolvedRouteInfoByParam(router, 'parent.child', [], {}, handler);
+
+  let transition = { isAborted: false } as unknown as InternalTransition<ClassicRoute>;
+  // Seed the transition state with the child itself in place, so the walk
+  // can distinguish ancestors from descendants.
+  transition[STATE_SYMBOL] = { routeInfos: [ancestorInfo, childInfo, descendantInfo] } as never;
+
+  await childInfo.resolve(transition);
+
+  assert.equal(
+    await captured!({ name: 'parent' }),
+    ancestorModel,
+    'an ancestor request resolves with its entered context'
+  );
+  assert.equal(
+    await captured!({ name: 'parent.child.grand' }),
+    undefined,
+    'a descendant request resolves with undefined rather than its pending enter promise'
+  );
+});
diff --git a/packages/router_js/tests/router_test.ts b/packages/router_js/tests/router_test.ts
index 2f8d320a751..bc66df81d94 100644
--- a/packages/router_js/tests/router_test.ts
+++ b/packages/router_js/tests/router_test.ts
@@ -1,9 +1,10 @@
 /* eslint-disable qunit/no-conditional-assertions, qunit/no-assert-logical-expression, qunit/no-early-return, no-console, no-throw-literal */
 import type { MatchCallback } from 'route-recognizer';
-import type { Route, Transition } from '../index';
+import type { Transition } from '../index';
 import type Router from '../index';
 import type { Dict, Maybe } from '../lib/core';
 import type {
+  ClassicRoute,
   IModel,
   RouteInfo as PublicRouteInfo,
   RouteInfoWithAttributes,
@@ -25,9 +26,9 @@ import {
   ignoreTransitionError,
 } from './test_helpers';
 
-let router: Router<Route>;
+let router: Router<ClassicRoute>;
 let url: string | undefined;
-let routes: Dict<Route>;
+let routes: Dict<ClassicRoute>;
 
 function isPresent(maybe: Maybe<PublicRouteInfo>): maybe is PublicRouteInfo {
   return maybe !== undefined && maybe !== null;
@@ -104,7 +105,7 @@ scenarios.forEach(function (scenario) {
         this.updateURL(name);
       }
       triggerEvent(
-        handlerInfos: RouteInfo<Route>[],
+        handlerInfos: RouteInfo<ClassicRoute>[],
         ignoreFailure: boolean,
         name: string,
         args: any[]
@@ -157,7 +158,7 @@ scenarios.forEach(function (scenario) {
     });
   });
 
-  function routePath(infos: RouteInfo<Route>[]) {
+  function routePath(infos: RouteInfo<ClassicRoute>[]) {
     let path = [];
 
     for (let i = 0, l = infos.length; i < l; i++) {
@@ -2313,7 +2314,7 @@ scenarios.forEach(function (scenario) {
         },
 
         setup: function (posts: Dict<unknown>, transition: Transition) {
-          assert.notOk(isExiting(this as unknown as Route, transition.routeInfos));
+          assert.notOk(isExiting(this as unknown as ClassicRoute, transition.routeInfos));
           assert.equal(
             posts,
             allPosts,
@@ -2323,7 +2324,7 @@ scenarios.forEach(function (scenario) {
         },
 
         exit: function (transition: Transition) {
-          assert.ok(isExiting(this as unknown as Route, transition.routeInfos));
+          assert.ok(isExiting(this as unknown as ClassicRoute, transition.routeInfos));
         },
       }),
 
@@ -2749,7 +2750,7 @@ scenarios.forEach(function (scenario) {
       }),
     };
     router.triggerEvent = function (
-      handlerInfos: RouteInfo<Route>[],
+      handlerInfos: RouteInfo<ClassicRoute>[],
       ignoreFailure: boolean,
       name: string,
       args: any[]
@@ -4445,7 +4446,7 @@ scenarios.forEach(function (scenario) {
 
     router
       .handleURL('/index')
-      .then(function (route: Route) {
+      .then(function (route: ClassicRoute) {
         assert.ok((route as any)['borfIndex'], 'resolved to index handler');
         return router.transitionTo('about');
       }, shouldNotHappen(assert))
@@ -4830,7 +4831,7 @@ scenarios.forEach(function (scenario) {
       router
         .transitionTo('/index')
         .followRedirects()
-        .then(function (handler: Route) {
+        .then(function (handler: ClassicRoute) {
           assert.equal(
             handler,
             routes['index'],
@@ -4839,14 +4840,14 @@ scenarios.forEach(function (scenario) {
 
           return router.transitionTo('about').followRedirects();
         })
-        .then(function (handler: Route) {
+        .then(function (handler: ClassicRoute) {
           assert.equal(
             handler,
             routes['faq'],
             'followRedirects promise resolved with redirected faq handler'
           );
 
-          (routes['about'] as Route).beforeModel = function (transition: Transition) {
+          (routes['about'] as ClassicRoute).beforeModel = function (transition: Transition) {
             transition.abort();
             return undefined;
           };
@@ -4882,7 +4883,7 @@ scenarios.forEach(function (scenario) {
       router
         .transitionTo('/index')
         .followRedirects()
-        .then(function (handler: Route) {
+        .then(function (handler: ClassicRoute) {
           assert.equal(
             handler,
             routes['about'],
@@ -5183,7 +5184,9 @@ scenarios.forEach(function (scenario) {
       router.getRoute = function (name) {
         count++;
 
-        return Promise.resolve(scenario.getRoute.call(null, name)).then(function (handler: Route) {
+        return Promise.resolve(scenario.getRoute.call(null, name)).then(function (
+          handler: ClassicRoute
+        ) {
           assert.equal(count, handlerCount);
           return handler;
         });
@@ -5728,7 +5731,7 @@ scenarios.forEach(function (scenario) {
       assert.expect(11);
 
       let counter = 1,
-        willResolves: Route[],
+        willResolves: ClassicRoute[],
         appModel = {},
         fooModel = {};
 
@@ -5747,7 +5750,7 @@ scenarios.forEach(function (scenario) {
             assert.equal(obj, appModel, 'application#setup is passed the return value from model');
           },
           events: {
-            willResolveModel: function (_transition: Transition, handler: Route) {
+            willResolveModel: function (_transition: Transition, handler: ClassicRoute) {
               assert.equal(
                 willResolves.shift(),
                 handler,
diff --git a/packages/router_js/tests/test_helpers.ts b/packages/router_js/tests/test_helpers.ts
index 38f0f938dca..6b9bd5f58e1 100644
--- a/packages/router_js/tests/test_helpers.ts
+++ b/packages/router_js/tests/test_helpers.ts
@@ -1,13 +1,14 @@
-import type { Route, Transition } from '../index';
-import Router from '../index';
+import type { RouteManager, RouteStateBucket, Transition } from '../index';
+import Router, { associateRouteManagement } from '../index';
 import type { Dict } from '../lib/core';
-import type { IModel } from '../lib/route-info';
+import type { ClassicRoute, IModel } from '../lib/route-info';
 import RouteInfo, { UnresolvedRouteInfoByParam } from '../lib/route-info';
 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) {
@@ -24,11 +25,11 @@ function assertAbort(assert: Assert) {
   };
 }
 
-function transitionToWithAbort(assert: Assert, router: Router<Route>, path: string) {
+function transitionToWithAbort(assert: Assert, router: Router<ClassicRoute>, path: string) {
   return router.transitionTo(path).then(shouldNotHappen(assert), assertAbort(assert));
 }
 
-function replaceWith(router: Router<Route>, path: string) {
+function replaceWith(router: Router<ClassicRoute>, path: string) {
   return router.transitionTo.apply(router, [path]).method('replace');
 }
 
@@ -41,7 +42,7 @@ function shouldNotHappen(assert: Assert, _message?: string) {
   };
 }
 
-export function isExiting(route: Route | string, routeInfos: RouteInfo<Route>[]) {
+export function isExiting(route: ClassicRoute | string, routeInfos: RouteInfo<ClassicRoute>[]) {
   for (let i = 0, len = routeInfos.length; i < len; ++i) {
     let routeInfo = routeInfos[i];
     if (routeInfo!.name === route || routeInfo!.route === route) {
@@ -65,15 +66,255 @@ export {
   assertAbort,
 };
 
-export function createHandler<T extends IModel>(name: string, options?: Dict<unknown>): Route<T> {
-  return Object.assign(
+// Minimal structural copies of the route manager types. The real interfaces
+// live in `@ember/-internals/routing/route-managers/api`; router_js stays
+// independent so we redeclare just the surface this manager satisfies.
+
+interface RouteCapabilities {
+  classicInterop: boolean;
+}
+
+interface NavigationArgs {
+  transition: any;
+  to: any;
+  internalRouteInfo?: any;
+  cancel: () => void;
+  signal?: AbortSignal;
+  getAncestorContext: (routeInfo: any) => Promise<unknown>;
+}
+
+interface RouteManagerLike {
+  capabilities: RouteCapabilities;
+  createRoute(definition: any, args: { name: string }): TestRouteBucket;
+  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(): object;
+  getInvokable(
+    bucket: TestRouteBucket,
+    enterPromise: Promise<unknown>
+  ): Promise<object | undefined>;
+  serializeContext(
+    bucket: TestRouteBucket,
+    routeInfo: any,
+    value: unknown
+  ): Dict<unknown> | undefined;
+  getContext(bucket: TestRouteBucket, params: Dict<unknown>, transition: any): unknown;
+  redirect(bucket: TestRouteBucket, routeInfo: any, context: unknown, transition: any): void;
+  getRouteInfoMetadata(bucket: TestRouteBucket): unknown;
+}
+
+// Stable per-route state. Per-render data (context, enterPromise) lives on
+// the routeInfo, not here.
+class TestRouteBucket {
+  route: ClassicRoute;
+  args: { name: string };
+  invokable: object | undefined = undefined;
+
+  constructor(route: ClassicRoute, args: { name: string }) {
+    this.route = route;
+    this.args = args;
+  }
+}
+
+const isTransitionLike = (value: unknown): boolean =>
+  typeof value === 'object' &&
+  value !== null &&
+  (value as { isTransition?: boolean }).isTransition === true;
+
+/**
+  Lightweight route manager used by `router_js`'s own tests. Routes in these
+  tests are plain object literals with `model`/`setup`/`enter`/`exit` hooks
+  (no EmberObject, no DI container) so the manager dispatches directly.
+ */
+class TestRouteManager implements RouteManagerLike {
+  capabilities: RouteCapabilities = { classicInterop: true };
+
+  createRoute(handler: ClassicRoute, args: { name: string }): TestRouteBucket {
+    const bucket = new TestRouteBucket(handler, args);
+    // Register the association the router_js dispatch path reads. The real
+    // framework router does this in EmberRouter.getRoute; the test manager
+    // has no framework router above it, so it registers directly.
+    associateRouteManagement(
+      handler,
+      this as unknown as RouteManager,
+      bucket as unknown as RouteStateBucket
+    );
+    return bucket;
+  }
+
+  willEnter(_bucket: TestRouteBucket, _args: NavigationArgs): void {}
+
+  enter(bucket: TestRouteBucket, args: NavigationArgs): Promise<unknown> {
+    const transition = args.transition;
+    // `to` is the public RouteInfo, which has no getModel. Classic-interop
+    // managers dispatch internal operations through internalRouteInfo.
+    const routeInfo = args.internalRouteInfo ?? args.to;
+    // routeInfo.route is the authoritative reference for this transition.
+    // Tests sometimes attach a handler to the routeInfo via prototype
+    // assignment that differs from the one the bucket was created with.
+    const route = routeInfo?.route ?? bucket.route;
+
+    if (transition && typeof transition.trigger === 'function') {
+      transition.trigger(true, 'willResolveModel', transition, route);
+    }
+
+    const name: string = routeInfo?.name ?? bucket.args.name;
+
+    const beforeModelResult = route?.beforeModel?.(transition);
+    return Promise.resolve(isTransitionLike(beforeModelResult) ? null : beforeModelResult)
+      .then(() => {
+        throwIfAborted(transition);
+        return routeInfo.getModel(transition);
+      })
+      .then((model: unknown) => {
+        throwIfAborted(transition);
+        // Stash the model BEFORE afterModel so afterModel can swap it out.
+        if (transition) {
+          transition.resolvedModels = transition.resolvedModels || {};
+          transition.resolvedModels[name] = model;
+        }
+        const afterModelResult = route?.afterModel?.(model as never, transition);
+        const safeAfterModel = isTransitionLike(afterModelResult) ? null : afterModelResult;
+        return Promise.resolve(safeAfterModel).then(() => {
+          // afterModel may have swapped the model; pick up the new value.
+          return transition?.resolvedModels?.[name] ?? model;
+        });
+      });
+  }
+
+  didEnter(bucket: TestRouteBucket, args: NavigationArgs & { enter?: boolean }): void {
+    const transition = args.transition;
+    const routeInfo = args.internalRouteInfo;
+    const route = routeInfo?.route ?? bucket.route;
+    const context = routeInfo?.context;
+
+    if (!route) return;
+
+    // Fire route.enter() on fresh entries (not context updates), mirroring
+    // the classic setupContexts gating.
+    if (args.enter !== false && route.enter) {
+      route.enter(transition);
+    }
+    // If enter triggered a redirect, the transition is now aborted; bail
+    // before calling setup so the outer loop stops too.
+    throwIfAborted(transition);
+    route.context = context as never;
+    if (route.setup) {
+      route.setup(context as never, transition);
+    }
+    throwIfAborted(transition);
+  }
+
+  willExit(_bucket: TestRouteBucket, _args: NavigationArgs & { isExiting?: boolean }): void {}
+
+  exit(bucket: TestRouteBucket, args?: NavigationArgs): void {
+    const route = bucket.route;
+    if (!route) return;
+    delete route.context;
+    if (route.exit) {
+      route.exit(args?.transition);
+    }
+  }
+
+  didExit(_bucket: TestRouteBucket, _args: NavigationArgs): void {}
+
+  // Classic-interop: serialize the model into the dynamic URL segments. The
+  // manager owns serialization, so this reproduces what route-info's default
+  // serialize would otherwise do once dispatch crosses the manager boundary:
+  // defer to the handler's own `serialize` when present, otherwise fall back
+  // to the single dynamic-segment default (the `_id` convention). Param-style
+  // models (string/number) are handled upstream before this is reached.
+  serializeContext(
+    bucket: TestRouteBucket,
+    routeInfo: any,
+    value: unknown
+  ): Dict<unknown> | undefined {
+    const route = bucket.route;
+    const paramNames: string[] = routeInfo?.paramNames ?? [];
+
+    if (route && typeof route.serialize === 'function') {
+      return route.serialize(value, paramNames);
+    }
+
+    if (paramNames.length !== 1) {
+      return undefined;
+    }
+
+    const object: Dict<unknown> = {};
+    const name = paramNames[0]!;
+    if (/_id$/.test(name)) {
+      object[name] = (value as IModel)?.id;
+    } else {
+      object[name] = value;
+    }
+    return object;
+  }
+
+  // Classic-interop: resolve the handler's context from URL params via its
+  // deserialize/model hook.
+  getContext(bucket: TestRouteBucket, params: Dict<unknown>, transition: any): unknown {
+    const route = bucket.route;
+    if (route.deserialize) {
+      return route.deserialize(params, transition);
+    }
+    if (route.model) {
+      return route.model(params, transition);
+    }
+    return undefined;
+  }
+
+  // Classic-interop: run the handler's redirect hook after its model resolves.
+  redirect(bucket: TestRouteBucket, _routeInfo: any, context: unknown, transition: any): void {
+    const route = bucket.route;
+    route.redirect?.(context, transition);
+  }
+
+  // Classic-interop: surface the handler's route-info metadata.
+  getRouteInfoMetadata(bucket: TestRouteBucket): unknown {
+    const route = bucket.route;
+    return route.buildRouteInfoMetadata ? route.buildRouteInfoMetadata() : null;
+  }
+
+  // Tests never actually render, so the wrapper identity is unused; we just
+  // need a stable reference to satisfy the manager contract.
+  getRouteWrapper(): object {
+    return TEST_WRAPPER_SENTINEL;
+  }
+
+  // Gate on enterPromise so resolution stays sequential, matching the
+  // classic expectation that a parent's model resolves before a child'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>
+): ClassicRoute<T> {
+  const handler = Object.assign(
     { name, routeName: name, context: {}, names: [], handler: name, _internalName: name },
     options
-  ) as unknown as Route<T>;
+  ) as unknown as ClassicRoute<T>;
+  // Attach the shared test manager + bucket so the resolve path has something
+  // to dispatch through.
+  SHARED_TEST_MANAGER.createRoute(handler as unknown as ClassicRoute, { name });
+  return handler;
 }
 
-export class TestRouter<R extends Route = Route> extends Router<R> {
-  didTransition() {}
+export class TestRouter<R extends ClassicRoute = ClassicRoute> extends Router<R> {
+  didTransition(_routeInfos?: RouteInfo<R>[]) {}
   willTransition() {}
   updateURL(_url: string): void {}
   replaceURL(_url: string): void {}
@@ -83,7 +324,7 @@ export class TestRouter<R extends Route = Route> extends Router<R> {
     _name: string,
     _args: any[]
   ) {}
-  routeDidChange() {}
+  routeDidChange(_transition?: PublicTransition) {}
   routeWillChange() {}
   transitionDidError(error: TransitionError, transition: PublicTransition) {
     if (error.wasAborted || transition.isAborted) {
@@ -94,17 +335,40 @@ export class TestRouter<R extends Route = Route> extends Router<R> {
       return error.error;
     }
   }
-  getRoute(_name: string): any {
-    return {};
+  getRoute(name: string): any {
+    return createHandler(name);
   }
   getSerializer(_name: string): any {
     return () => {};
   }
+
+  // The manager-driven lifecycle (onTransitionSettled and friends) is
+  // inherited from the base Router. The tests want one extra behaviour: when
+  // a didEnter hook throws, roll back to the pre-transition state so the
+  // next transition sees these routes as unentered and re-fires their enter
+  // hooks.
+  protected override handleDidEnterError(
+    error: unknown,
+    activeTransition: any,
+    newState: any,
+    preTransitionState: any
+  ): never {
+    this.state = preTransitionState;
+    // Copy routeInfos (don't alias) so later mutations don't corrupt the
+    // baseline used by partitionRoutes.
+    this.currentRouteInfos = preTransitionState
+      ? (preTransitionState.routeInfos.slice() as any)
+      : undefined;
+    return super.handleDidEnterError(error, activeTransition, newState, preTransitionState);
+  }
 }
 
-export function createHandlerInfo(name: string, options: Dict<unknown> = {}): RouteInfo<Route> {
-  class Stub extends RouteInfo<Route> {
-    constructor(name: string, router: Router<Route>, handler?: Route) {
+export function createHandlerInfo(
+  name: string,
+  options: Dict<unknown> = {}
+): RouteInfo<ClassicRoute> {
+  class Stub extends RouteInfo<ClassicRoute> {
+    constructor(name: string, router: Router<ClassicRoute>, handler?: ClassicRoute) {
       super(router, name, [], handler);
     }
     getModel(_transition: Transition) {
@@ -115,7 +379,7 @@ export function createHandlerInfo(name: string, options: Dict<unknown> = {}): Ro
     }
   }
 
-  let handler = (options['handler'] as Route) || createHandler('foo');
+  let handler = (options['handler'] as ClassicRoute) || createHandler('foo');
   delete options['handler'];
 
   Object.assign(Stub.prototype, options);
@@ -124,7 +388,7 @@ export function createHandlerInfo(name: string, options: Dict<unknown> = {}): Ro
 }
 
 export function trigger(
-  handlerInfos: RouteInfo<Route>[],
+  handlerInfos: RouteInfo<ClassicRoute>[],
   ignoreFailure: boolean,
   name: string,
   ...args: any[]
diff --git a/packages/router_js/tests/transition_intent_test.ts b/packages/router_js/tests/transition_intent_test.ts
index 028c1e70001..ed0c4c3d738 100644
--- a/packages/router_js/tests/transition_intent_test.ts
+++ b/packages/router_js/tests/transition_intent_test.ts
@@ -3,7 +3,7 @@ import URLTransitionIntent from '../lib/transition-intent/url-transition-intent'
 import TransitionState from '../lib/transition-state';
 import { createHandler, TestRouter } from './test_helpers';
 
-import type { default as Router, Route } from '../index';
+import type { default as Router, BaseRoute } from '../index';
 import type { Dict } from '../lib/core';
 import {
   type default as InternalRouteInfo,
@@ -13,7 +13,7 @@ import {
 } from '../lib/route-info';
 import { Promise } from 'rsvp';
 
-let handlers: Dict<Route>, recognizer: any;
+let handlers: Dict<BaseRoute>, recognizer: any;
 
 let scenarios = [
   {
@@ -39,14 +39,14 @@ scenarios.forEach(function (scenario) {
     }
   }
 
-  let router: Router<Route>;
+  let router: Router<BaseRoute>;
 
   // Asserts that a handler from a handlerInfo equals an expected valued.
   // Returns a promise during async scenarios to wait until the handler is ready.
   function assertHandlerEquals(
     assert: Assert,
-    handlerInfo: InternalRouteInfo<Route>,
-    expected: Route
+    handlerInfo: InternalRouteInfo<BaseRoute>,
+    expected: BaseRoute
   ) {
     if (!scenario.async) {
       return assert.equal(handlerInfo.route, expected);
@@ -120,7 +120,7 @@ scenarios.forEach(function (scenario) {
         },
       };
 
-      router = new TransitionRouter();
+      router = new TransitionRouter() as Router<BaseRoute>;
       router.recognizer = recognizer;
     },
   });
diff --git a/packages/router_js/tests/transition_state_test.ts b/packages/router_js/tests/transition_state_test.ts
index 099d3e0f40a..f090fd62d7b 100644
--- a/packages/router_js/tests/transition_state_test.ts
+++ b/packages/router_js/tests/transition_state_test.ts
@@ -1,7 +1,7 @@
 import type { Transition } from '../index';
 import type { Dict } from '../lib/core';
 import {
-  type Route,
+  type BaseRoute,
   UnresolvedRouteInfoByObject,
   UnresolvedRouteInfoByParam,
 } from '../lib/route-info';
@@ -42,7 +42,7 @@ QUnit.test("#resolve delegates to handleInfo objects' resolve()", function (asse
     }),
   ];
 
-  state.resolve({} as Transition).then(function (result: TransitionState<Route>) {
+  state.resolve({} as Transition).then(function (result: TransitionState<BaseRoute>) {
     assert.deepEqual(result.routeInfos, resolvedHandlerInfos);
   });
 });
@@ -99,7 +99,7 @@ QUnit.test('Integration w/ HandlerInfos', function (assert) {
 
   state
     .resolve(transition as Transition)
-    .then(function (result: TransitionState<Route>) {
+    .then(function (result: TransitionState<BaseRoute>) {
       let models = [];
       for (let i = 0; i < result.routeInfos.length; i++) {
         models.push(result.routeInfos[i]!.context);
diff --git a/smoke-tests/scenarios/basic-test.ts b/smoke-tests/scenarios/basic-test.ts
index dbe3ac0effd..4a18435fd07 100644
--- a/smoke-tests/scenarios/basic-test.ts
+++ b/smoke-tests/scenarios/basic-test.ts
@@ -18,10 +18,39 @@ function basicTest(scenarios: Scenarios, appName: string) {
             }
 
             Router.map(function () {
-              this.route('example-gjs-route')
+              this.route('example-gjs-route');
+              this.route('a', function () {
+                this.route('b');
+                this.route('c');
+              });
+              this.route('d', function () {
+                this.route('e');
+              });
+              this.route('f');
+              this.route('item', { path: '/item/:item_id' });
+              this.route('g', function () {
+                this.route('h', function () {
+                  this.route('i');
+                });
+              });
             });
           `,
           components: {
+            'model-probe.gjs': `
+              import Component from '@glimmer/component';
+
+              const destroyedModels = [];
+              export function getDestroyedModels() { return destroyedModels; }
+              export function clearDestroyedModels() { destroyedModels.length = 0; }
+
+              export default class ModelProbe extends Component {
+                willDestroy() {
+                  super.willDestroy();
+                  destroyedModels.push(this.args.model);
+                }
+                <template>{{@model}}</template>
+              }
+            `,
             'interactive-example.js': `
               import { template } from '@ember/template-compiler';
               import Component from '@glimmer/component';
@@ -66,6 +95,54 @@ function basicTest(scenarios: Scenarios, appName: string) {
                 }
               }
             `,
+            'a.js': `
+              import Route from '@ember/routing/route';
+              export default class extends Route { model() { return 'a'; } }
+            `,
+            a: {
+              'b.js': `
+                import Route from '@ember/routing/route';
+                export default class extends Route { model() { return 'b'; } }
+              `,
+              'c.js': `
+                import Route from '@ember/routing/route';
+                export default class extends Route { model() { return 'c'; } }
+              `,
+            },
+            'd.js': `
+              import Route from '@ember/routing/route';
+              export default class extends Route { model() { return 'd'; } }
+            `,
+            d: {
+              'e.js': `
+                import Route from '@ember/routing/route';
+                export default class extends Route { model() { return 'e'; } }
+              `,
+            },
+            'f.js': `
+              import Route from '@ember/routing/route';
+              export default class extends Route { model() { return 'f'; } }
+            `,
+            'item.js': `
+              import Route from '@ember/routing/route';
+              export default class extends Route { model(params) { return params.item_id; } }
+            `,
+            'g.js': `
+              import Route from '@ember/routing/route';
+              export default class extends Route { model() { return 'g'; } }
+            `,
+            g: {
+              'h.js': `
+                import Route from '@ember/routing/route';
+                export default class extends Route { model() { return 'h'; } }
+              `,
+              h: {
+                'i.js': `
+                  import Route from '@ember/routing/route';
+                  export default class extends Route { model() { return 'i'; } }
+                `,
+              },
+            },
           },
           templates: {
             'example-gjs-route.gjs': `
@@ -83,6 +160,27 @@ function basicTest(scenarios: Scenarios, appName: string) {
                 </template>
               }
             `,
+            'a.gjs': `<template>{{outlet}}</template>`,
+            a: {
+              'b.gjs': `
+                import ModelProbe from '${appName}/components/model-probe';
+                <template><ModelProbe @model={{@model}} /></template>
+              `,
+            },
+            'item.gjs': `
+              import ModelProbe from '${appName}/components/model-probe';
+              <template><ModelProbe @model={{@model}} /></template>
+            `,
+            'g.gjs': `<template>{{outlet}}</template>`,
+            g: {
+              'h.gjs': `<template>{{outlet}}</template>`,
+              h: {
+                'i.gjs': `
+                  import ModelProbe from '${appName}/components/model-probe';
+                  <template><ModelProbe @model={{@model}} /></template>
+                `,
+              },
+            },
           },
         },
         tests: {
@@ -118,6 +216,71 @@ function basicTest(scenarios: Scenarios, appName: string) {
                 });
               });
             `,
+            'model-stability-test.js': `
+              import { module, test } from 'qunit';
+              import { visit } from '@ember/test-helpers';
+              import { setupApplicationTest } from '${appName}/tests/helpers';
+              import { getDestroyedModels, clearDestroyedModels } from '${appName}/components/model-probe';
+
+              module('Acceptance | @model stability during route transitions', function (hooks) {
+                setupApplicationTest(hooks);
+                hooks.beforeEach(function () { clearDestroyedModels(); });
+
+                test('@model should be stable when transitioning out of the route', async function (assert) {
+                  await visit('/a/b');
+                  await visit('/a');
+
+                  await visit('/a/b');
+                  await visit('/a/c');
+
+                  await visit('/a/b');
+                  await visit('/d');
+
+                  await visit('/a/b');
+                  await visit('/d/e');
+
+                  await visit('/a/b');
+                  await visit('/f');
+
+                  assert.deepEqual(
+                    getDestroyedModels(),
+                    ['b', 'b', 'b', 'b', 'b'],
+                    'The @model value should remain stable in willDestroy for all transition types'
+                  );
+                });
+
+                test('@model should update when the model changes on the same route', async function (assert) {
+                  await visit('/item/first');
+                  assert.dom().containsText('first');
+
+                  await visit('/item/second');
+                  assert.dom().containsText('second');
+
+                  await visit('/item/third');
+                  assert.dom().containsText('third');
+
+                  // Leave the route entirely — the destroyed model should be the latest one
+                  await visit('/f');
+
+                  assert.deepEqual(
+                    getDestroyedModels(),
+                    ['third'],
+                    'The @model value should be the latest model when finally destroyed'
+                  );
+                });
+
+                test('@model should be stable when grandparent outlet tears down', async function (assert) {
+                  await visit('/g/h/i');
+                  await visit('/f');
+
+                  assert.deepEqual(
+                    getDestroyedModels(),
+                    ['i'],
+                    'The @model value should remain stable when grandparent outlet tears down'
+                  );
+                });
+              });
+            `,
           },
           integration: {
             'tracked-built-ins-macro-test.gjs': `
diff --git a/tests/docs/expected.cjs b/tests/docs/expected.cjs
index db1994ff30a..adeec128729 100644
--- a/tests/docs/expected.cjs
+++ b/tests/docs/expected.cjs
@@ -26,6 +26,7 @@ module.exports = {
     '_getObjectsOnNamespaces',
     '_getQPMeta',
     '_hydrateUnsuppliedQueryParams',
+    '_initController',
     '_initializersRan',
     '_internalReset',
     '_lazyInjections',
@@ -179,7 +180,6 @@ module.exports = {
     'endPropertyChanges',
     'engine',
     'ensureInitializers',
-    'enter',
     'eq',
     'equal',
     'error',
@@ -187,7 +187,6 @@ module.exports = {
     'events',
     'every',
     'exception',
-    'exit',
     'expandProperties',
     'extend',
     'factoryFor',
@@ -483,7 +482,6 @@ module.exports = {
     'templateOnly',
     'textarea',
     'then',
-    'this[RENDER]',
     'throttle',
     'to',
     'toArray',
diff --git a/tests/node-vitest/tree-shakability.test.js b/tests/node-vitest/tree-shakability.test.js
index 2eb4a63c60e..a26056a90ee 100644
--- a/tests/node-vitest/tree-shakability.test.js
+++ b/tests/node-vitest/tree-shakability.test.js
@@ -27,6 +27,7 @@ it('[dev] source modules with side effects', () => {
       "@ember/-internals/glimmer/lib/environment.js",
       "@ember/-internals/runtime/lib/ext/rsvp.js",
       "@ember/debug/index.js",
+      "@ember/routing/route.js",
       "@glimmer/runtime/lib/compiled/opcodes/component.js",
       "@glimmer/runtime/lib/compiled/opcodes/content.js",
       "@glimmer/runtime/lib/compiled/opcodes/debugger.js",
@@ -52,6 +53,7 @@ it('[prod] source modules with side effects', () => {
       "@ember/-internals/glimmer/lib/components/input.js",
       "@ember/-internals/glimmer/lib/environment.js",
       "@ember/-internals/runtime/lib/ext/rsvp.js",
+      "@ember/routing/route.js",
       "@glimmer/runtime/lib/compiled/opcodes/component.js",
       "@glimmer/runtime/lib/compiled/opcodes/content.js",
       "@glimmer/runtime/lib/compiled/opcodes/debugger.js",