don't use resolver to instantiate route classes

Author: evoactivity

packages/@ember/-internals/container/lib/container.ts

@@ -6,12 +6,13 @@ import type {
   FactoryManager,
   FullName,
 } from '@ember/-internals/owner';
-import { setOwner } from '@ember/-internals/owner';
+import { getOwner, setOwner } from '@ember/-internals/owner';
 import { dictionary } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import type { DebugRegistry } from './registry';
 import type Registry from './registry';
+import EmberRouter from '@ember/routing/router';
 
 interface LeakTracking {
   hasContainers(): boolean;
@@ -282,6 +283,23 @@ function lookup(
 ): InternalFactory<object> | object | undefined {
   let normalizedName = fullName;
 
+  if (normalizedName.startsWith('route:') && container.owner) {
+    let router = container.owner.lookup('router:main') as EmberRouter;
+    let routeName = normalizedName.split('route:')[1];
+    if (routeName !== undefined) {
+      // For the main app container, pass the name directly — EmberRouter.getRoute
+      // resolves engine vs app routes internally via _engineInfoByRoute.
+      // For engine containers (owner !== router's owner), pass the engine owner
+      // explicitly so EmberRouter.getRoute uses it directly without a name lookup.
+      const isEngineContainer = getOwner(router) !== container.owner;
+      const engineOwner = isEngineContainer ? container.owner : undefined;
+      return router.getRoute(routeName, engineOwner) as
+        | InternalFactory<object>
+        | object
+        | undefined;
+    }
+  }
+
   if (
     options.singleton === true ||
     (options.singleton === undefined && isSingleton(container, fullName))

packages/@ember/-internals/routing/route-managers/classic-route-manager.ts

@@ -1,4 +1,4 @@
-import { getOwner } from '@ember/-internals/owner';
+import { getOwner, setOwner } from '@ember/-internals/owner';
 import { assert, info } from '@ember/debug';
 import { get } from '@ember/-internals/metal';
 import { DEBUG } from '@glimmer/env';
@@ -10,6 +10,7 @@ import { createCapturedArgs, curry, EMPTY_POSITIONAL } from '@glimmer/runtime';
 import { dict } from '@glimmer/util';
 import { tracked } from '@glimmer/tracking';
 import { makeRouteTemplate } from '@ember/-internals/glimmer/lib/component-managers/route-template';
+import type Owner from '@ember/owner';
 import type Route from '@ember/routing/route';
 import type {
   RouteManager,
@@ -69,8 +70,16 @@ export interface ClassicInteropArgs {
 export class ClassicRouteManager implements RouteManager<ClassicRouteBucket> {
   capabilities: RouteCapabilities = routeCapabilities('1.0', { classicInterop: true });
 
-  createRoute(routeInstance: object, args: CreateRouteArgs): ClassicRouteBucket {
-    let route = routeInstance as Route;
+  #owner: Owner;
+
+  constructor(owner: Owner) {
+    this.#owner = owner;
+  }
+
+  createRoute(RouteClass: typeof Route, args: CreateRouteArgs): ClassicRouteBucket {
+    let props = {};
+    setOwner(props, this.#owner);
+    let route = RouteClass.create(props);
     route._setRouteName(args.name);
 
     return new ClassicRouteBucket(route, args);

packages/@ember/-internals/routing/route-managers/utils.ts

@@ -1,12 +1,14 @@
-import type { Owner } from '@glimmer/interfaces';
 import type { ManagerFactory, RouteManager } from './route-manager';
+import { DEBUG } from '@glimmer/env';
+import { debugAssert } from '@glimmer/global-context';
 
 export interface RouteStateBucket {
+  invokable?: object;
   instance?: unknown;
   args: object;
 }
 
-const ROUTE_MANAGERS = new WeakMap<object, RouteManager<RouteStateBucket>>();
+const ROUTE_MANAGERS = new WeakMap<object, ManagerFactory<any, RouteManager<any>>>();
 
 /**
  * There is also Reflect.getPrototypeOf,
@@ -22,14 +24,31 @@ function setManager<Def extends object>(
   manager: object,
   obj: Def
 ): Def {
+  if (DEBUG) {
+    debugAssert(
+      obj !== null && (typeof obj === 'object' || typeof obj === 'function'),
+
+      `Attempted to set a manager on a non-object value. Managers can only be associated with objects or functions. Value was ${
+        obj
+      }`
+    );
+
+    debugAssert(
+      !map.has(obj),
+      `Attempted to set the same type of manager multiple times on a value. You can only associate one manager of each type with a given value. Value was ${
+        obj
+      }`
+    );
+  }
+
   map.set(obj, manager);
   return obj;
 }
 
-function getManager<M extends RouteManager<RouteStateBucket>>(
+function getManager<M extends ManagerFactory<any, RouteManager<RouteStateBucket>>>(
   map: WeakMap<object, M>,
   obj: object
-): M | undefined {
+): ManagerFactory<any, RouteManager<RouteStateBucket>> | undefined {
   let pointer: object | null = obj;
   while (pointer !== null) {
     const manager = map.get(pointer);
@@ -44,22 +63,30 @@ function getManager<M extends RouteManager<RouteStateBucket>>(
   return undefined;
 }
 
-export function setRouteManager<O extends Owner, T extends object | Function>(
-  factory: ManagerFactory<O | undefined, RouteManager<RouteStateBucket>>,
+export function setRouteManager<T extends object>(
+  factory: ManagerFactory<any, RouteManager<RouteStateBucket>>,
   definition: T
 ): T {
-  let manager = factory(undefined);
-  setManager(ROUTE_MANAGERS, manager, definition);
+  setManager(ROUTE_MANAGERS, factory, definition);
 
   return definition;
 }
 
 export function getRouteManager<T extends object>(
   definition: T
-): RouteManager<RouteStateBucket> | undefined {
-  if (!definition) {
-    return undefined;
+): ManagerFactory<any, RouteManager<RouteStateBucket>> | undefined {
+  let factory = getManager(ROUTE_MANAGERS, definition);
+
+  if (factory === undefined) {
+    if (DEBUG) {
+      debugAssert(
+        false,
+        `Attempted to load a route, but there wasn't a route manager associated with the definition. The definition was: ${
+          definition
+        }`
+      );
+    }
   }
 
-  return getManager(ROUTE_MANAGERS, definition);
+  return factory;
 }

packages/@ember/routing/index.ts

@@ -1 +1,9 @@
 export { LinkTo } from '@ember/-internals/glimmer';
+export { setRouteManager } from '@ember/-internals/routing/route-managers/utils';
+export { ClassicRouteManager } from '@ember/-internals/routing/route-managers/classic-route-manager';
+export { routeCapabilities } from '@ember/-internals/routing/route-managers/route-manager';
+
+import type { RouteStateBucket } from '@ember/-internals/routing';
+import type { RouteManager as InternalRouteManager } from '@ember/-internals/routing/route-managers/route-manager';
+
+export type RouteManager = InternalRouteManager<RouteStateBucket>;

packages/@ember/routing/route.ts

@@ -2121,4 +2121,4 @@ export default Route;
 import { setRouteManager } from '@ember/-internals/routing/route-managers/utils';
 import { ClassicRouteManager } from '@ember/-internals/routing/route-managers/classic-route-manager';
 
-setRouteManager(() => new ClassicRouteManager(), Route);
+setRouteManager((owner) => new ClassicRouteManager(owner), Route);

packages/@ember/routing/router.ts

@@ -34,7 +34,7 @@ import {
   getFullQueryParams,
   hasDefaultSerialize,
 } from '@ember/routing/route';
-import { getRouteManager } from '@ember/-internals/routing/route-managers/utils';
+import { getRouteManager, RouteStateBucket } from '@ember/-internals/routing/route-managers/utils';
 import type {
   InternalRouteInfo,
   ModelFor,
@@ -51,6 +51,7 @@ import type { QueryParams } from 'route-recognizer';
 import type { AnyFn, MethodNamesOf, OmitFirst } from '@ember/-internals/utility-types';
 import type { Template } from '@glimmer/interfaces';
 import type ApplicationInstance from '@ember/application/instance';
+import { RouteManager } from '@ember/-internals/routing/route-managers/route-manager';
 
 /**
 @module @ember/routing/router
@@ -312,71 +313,112 @@ 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);
+  // Both routes and manager instances are keyed first by owner so that engine routes
+  // (which share local names like 'application' with the main app) are isolated.
+  #routes = new WeakMap<object, Map<string, RouteStateBucket>>();
+  #routeManagerInstances = new WeakMap<object, WeakMap<Function, RouteManager<RouteStateBucket>>>();
 
-    class PrivateRouter extends Router<Route> {
-      getRoute(name: string): Route {
-        let routeName = name;
-        let routeOwner = owner;
-        let engineInfo = router._engineInfoByRoute[routeName];
+  getRoute(name: string, engineOwner?: Owner) {
+    if (name === 'undefined') {
+      return;
+    }
 
-        if (engineInfo) {
-          let engineInstance = router._getEngineInstance(engineInfo);
+    assert('Name should not start with "route:"', !name.startsWith('route:'));
 
-          routeOwner = engineInstance;
-          routeName = engineInfo.localFullName;
-        }
+    // Resolve the owner and local route name.
+    // If engineOwner is provided (from the container bypass for an engine container),
+    // use it directly — the name is already the local route name within that engine.
+    // Otherwise, check _engineInfoByRoute to resolve engine routes by fully-qualified name.
+    let routeName = name;
+    let routeOwner: Owner;
 
-        let fullRouteName = `route:${routeName}` as const;
-
-        assert('Route is unexpectedly missing an owner', routeOwner);
+    if (engineOwner) {
+      routeOwner = engineOwner;
+    } else {
+      routeOwner = getOwner(this)!;
+      assert('BUG: Missing owner', routeOwner);
 
-        let route = routeOwner.lookup(fullRouteName) as Route | undefined;
+      const engineInfo = this._engineInfoByRoute[routeName];
+      if (engineInfo) {
+        routeOwner = this._getEngineInstance(engineInfo);
+        routeName = engineInfo.localFullName;
+      }
+    }
 
-        if (seen[name]) {
-          assert('seen routes should exist', route);
-          return route;
-        }
+    // Per-owner route cache.
+    let ownerRoutes = this.#routes.get(routeOwner);
+    if (!ownerRoutes) {
+      ownerRoutes = new Map();
+      this.#routes.set(routeOwner, ownerRoutes);
+    }
 
-        seen[name] = true;
+    if (!ownerRoutes.has(routeName)) {
+      let fullRouteName = `route:${routeName}` as const;
+      let factoryManager = routeOwner.factoryFor(fullRouteName);
 
-        if (!route) {
-          // SAFETY: this is configured in `commonSetupRegistry` in the
-          // `@ember/application/lib` package.
-          let DefaultRoute: any = routeOwner.factoryFor('route:basic')!.class;
-          routeOwner.register(fullRouteName, class extends DefaultRoute {});
-          route = routeOwner.lookup(fullRouteName) as Route;
+      // Auto-generate a default route if none is registered.
+      if (!factoryManager) {
+        let DefaultRoute: any = routeOwner.factoryFor('route:basic')!.class;
+        routeOwner.register(fullRouteName, class extends DefaultRoute {});
+        factoryManager = routeOwner.factoryFor(fullRouteName);
 
-          if (DEBUG) {
-            if (router.namespace.LOG_ACTIVE_GENERATION) {
-              info(`generated -> ${fullRouteName}`, { fullName: fullRouteName });
-            }
+        if (DEBUG) {
+          if (this.namespace.LOG_ACTIVE_GENERATION) {
+            info(`generated -> ${fullRouteName}`, { fullName: fullRouteName });
           }
         }
+      }
 
-        // Look up the route manager and create a bucket.
-        // This activates the manager-driven code paths in router_js.
-        let manager = getRouteManager(route.constructor);
-        assert(`Route ${fullRouteName} does not have a manager`, manager);
+      assert('BUG: Missing factory for route', factoryManager);
+      let RouteClass = factoryManager.class;
 
-        let bucket = manager.createRoute(route, { name: routeName });
-        route.manager = manager;
+      // Engine routes must not define a custom serialize method.
+      const isEngineRoute = routeOwner !== getOwner(this);
+      if (isEngineRoute && !hasDefaultSerialize(RouteClass.prototype as any)) {
+        throw new Error(
+          'Defining a custom serialize method on an Engine route is not supported.'
+        );
+      }
 
-        assert('Route manager should return a bucket', bucket);
-        route.bucket = bucket;
+      // Look up the manager factory function via prototype walk on the class.
+      let managerFactory = getRouteManager(RouteClass);
+      assert('Route manager needs to be defined', managerFactory !== undefined);
+
+      // Instantiate the manager once per owner. Keyed first by owner so engine routes
+      // get their own manager instances, then by factory function so all subclasses
+      // sharing the same factory share one manager instance within that owner.
+      let ownerManagerInstances = this.#routeManagerInstances.get(routeOwner);
+      if (!ownerManagerInstances) {
+        ownerManagerInstances = new WeakMap();
+        this.#routeManagerInstances.set(routeOwner, ownerManagerInstances);
+      }
+      if (!ownerManagerInstances.has(managerFactory)) {
+        ownerManagerInstances.set(managerFactory, managerFactory(routeOwner));
+      }
+      let routeManagerInstance = ownerManagerInstances.get(managerFactory)!;
 
-        if (engineInfo && !hasDefaultSerialize(route)) {
-          throw new Error(
-            'Defining a custom serialize method on an Engine route is not supported.'
-          );
-        }
+      // Pass the concrete class to createRoute — the manager is responsible for instantiation.
+      let routeStateBucket = routeManagerInstance.createRoute(RouteClass, { name: routeName });
+
+      assert('Failed to create Route instance', routeStateBucket.instance);
+      (routeStateBucket.instance as any).bucket = routeStateBucket;
+      (routeStateBucket.instance as any).manager = routeManagerInstance;
+      ownerRoutes.set(routeName, routeStateBucket as RouteStateBucket);
+    }
 
-        return route;
+    return ownerRoutes.get(routeName)!.instance;
+  }
+
+  _initRouterJs(): void {
+    let location = get(this, 'location') as EmberLocation;
+    let router = this;
+    const owner = getOwner(this);
+    assert('Router is unexpectedly missing an owner', owner);
+    class PrivateRouter extends Router<Route> {
+      getRoute(name: string): Route {
+        // All route instantiation and caching is owned by EmberRouter.getRoute,
+        // which resolves engine vs main-app owner internally.
+        return router.getRoute(name) as Route;
       }
 
       getSerializer(name: string) {