ember-source 6.3.0-alpha.2 → 6.3.0-alpha.3

package/dist/packages/@ember/routing/route.js

@@ -7,7 +7,7 @@ import { l as lookupDescriptor } from '../../shared-chunks/mandatory-setter-BiXq
 import { isDevelopingApp } from '@embroider/macros';
 import { i as isProxy } from '../../shared-chunks/is_proxy-DjvCKvd5.js';
 import '../../@glimmer/destroyable/index.js';
-import '../../@glimmer/manager/index.js';
+import { hasInternalComponentManager } from '../../@glimmer/manager/index.js';
 import { s as set } from '../../shared-chunks/property_set-4etrFh8A.js';
 import { g as getProperties, s as setProperties } from '../../shared-chunks/set_properties-BQFOCF2x.js';
 import { E as ENV } from '../../shared-chunks/env-mInZ1DuF.js';
@@ -1324,17 +1324,59 @@ function buildRenderState(route) {
   let controller = owner.lookup(`controller:${route.controllerName || name}`);
   (isDevelopingApp() && !(controller instanceof Controller) && assert('Expected an instance of controller', controller instanceof Controller));
   let model = route.currentModel;
-  let template = owner.lookup(`template:${route.templateName || name}`);
+  let templateFactoryOrComponent = owner.lookup(`template:${route.templateName || name}`);
+
+  // 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;
+  if (templateFactoryOrComponent) {
+    if (hasInternalComponentManager(templateFactoryOrComponent)) {
+      template = templateFactoryOrComponent;
+    } else {
+      if (isDevelopingApp() && typeof templateFactoryOrComponent !== 'function') {
+        let label;
+        try {
+          label = `\`${String(templateFactoryOrComponent)}\``;
+        } catch {
+          label = 'an unknown object';
+        }
+        (isDevelopingApp() && !(false) && 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(owner);
+    }
+  } else {
+    // default `{{outlet}}`
+    template = route._topLevelViewTemplate(owner);
+  }
   let render = {
     owner,
     name,
     controller,
     model,
-    template: template?.(owner) ?? route._topLevelViewTemplate(owner)
+    template
   };
   if (isDevelopingApp()) {
     let LOG_VIEW_LOOKUPS = get(route._router, 'namespace.LOG_VIEW_LOOKUPS');
-    if (LOG_VIEW_LOOKUPS && !template) {
+    // 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}`
       });

package/dist/packages/@ember/template/index.js

@@ -1,5 +1,5 @@
 import '../../@glimmer/opcode-compiler/index.js';
-export { a as htmlSafe, i as isHTMLSafe } from '../../shared-chunks/index-C7oKNWrX.js';
+export { a as htmlSafe, i as isHTMLSafe } from '../../shared-chunks/index-4KqgXTKl.js';
 import '../../shared-chunks/registry-B8WARvkP.js';
 import '../debug/index.js';
 import '../../@glimmer/runtime/index.js';

package/dist/packages/ember/barrel.js

@@ -39,7 +39,7 @@ import MutableEnumerable from '../@ember/enumerable/mutable.js';
 import '../@ember/-internals/runtime/lib/mixins/target_action_support.js';
 import '../@ember/-internals/runtime/lib/ext/rsvp.js';
 import { templateFactory } from '../@glimmer/opcode-compiler/index.js';
-import { I as Input, C as Component, H as Helper, e as escapeExpression } from '../shared-chunks/index-C7oKNWrX.js';
+import { I as Input, C as Component, H as Helper, e as escapeExpression } from '../shared-chunks/index-4KqgXTKl.js';
 import { a as getTemplates, b as setTemplates } from '../shared-chunks/template_registry-DigcUg9m.js';
 import { isSerializationFirstNode, templateOnlyComponent, invokeHelper, hash, array, concat, get as get$1, on as on$1, fn } from '../@glimmer/runtime/index.js';
 import { run } from '../@ember/runloop/index.js';

package/dist/packages/ember/version.js

@@ -1,4 +1,4 @@
 // this file gets replaced with the real value during the build
-const Version = '6.3.0-alpha.2';
+const Version = '6.3.0-alpha.3';
 
 export { Version as default };

package/dist/packages/ember-testing/lib/initializers.js

@@ -36,7 +36,7 @@ import '../../shared-chunks/unrecognized-url-error-zpz-JEoG.js';
 import '../../@ember/routing/lib/routing-service.js';
 import '../../@ember/controller/index.js';
 import '../../@glimmer/opcode-compiler/index.js';
-import '../../shared-chunks/index-C7oKNWrX.js';
+import '../../shared-chunks/index-4KqgXTKl.js';
 import '../../shared-chunks/registry-B8WARvkP.js';
 import '../../@glimmer/runtime/index.js';
 import '../../@glimmer/reference/index.js';

package/dist/packages/shared-chunks/{index-C7oKNWrX.js → index-4KqgXTKl.js}

@@ -3,10 +3,10 @@ import { g as getFactoryFor, p as privatize } from './registry-B8WARvkP.js';
 import { warn, debugFreeze, deprecate } from '../@ember/debug/index.js';
 import { reifyPositional, normalizeProperty, EMPTY_ARGS, createCapturedArgs, EMPTY_POSITIONAL, curry, hash, array, concat, fn, get as get$1, templateOnlyComponent, TEMPLATE_ONLY_COMPONENT_MANAGER, on as on$1, runtimeContext, DOMTreeConstruction, DOMChanges, clientBuilder, inTransaction, renderMain } from '../@glimmer/runtime/index.js';
 import { join, _backburner, schedule, _getCurrentRunLoop } from '../@ember/runloop/index.js';
-import { valueForRef, isConstRef, createConstRef, isUpdatableRef, updateRef, createPrimitiveRef, childRefFor, createComputeRef, childRefFromParts, isInvokableRef, createUnboundRef, createInvokableRef, createReadOnlyRef, createDebugAliasRef, UNDEFINED_REFERENCE } from '../@glimmer/reference/index.js';
+import { valueForRef, isConstRef, createConstRef, isUpdatableRef, updateRef, createPrimitiveRef, childRefFor, createComputeRef, childRefFromParts, isInvokableRef, createUnboundRef, UNDEFINED_REFERENCE, createInvokableRef, createReadOnlyRef, createDebugAliasRef } from '../@glimmer/reference/index.js';
 import { untrack, consumeTag, tagFor, createCache, getValue, valueForTag, beginUntrackFrame, endUntrackFrame, beginTrackFrame, endTrackFrame, validateTag, createTag, dirtyTag as DIRTY_TAG$1, CONSTANT_TAG, isTracking, debug, createUpdatableTag, CURRENT_TAG } from '../@glimmer/validator/index.js';
 import { isDevelopingApp } from '@embroider/macros';
-import { setInternalComponentManager, setComponentTemplate, setInternalHelperManager, setHelperManager, getInternalHelperManager, helperCapabilities, capabilityFlagsFrom, setInternalModifierManager, getInternalComponentManager, getComponentTemplate } from '../@glimmer/manager/index.js';
+import { setInternalComponentManager, setComponentTemplate, setInternalHelperManager, setHelperManager, getInternalHelperManager, helperCapabilities, capabilityFlagsFrom, setInternalModifierManager, hasInternalComponentManager, getInternalComponentManager, getComponentTemplate } from '../@glimmer/manager/index.js';
 import { h as hasDOM } from './index-BGP1rw3B.js';
 import { action as action$1 } from '../@ember/object/index.js';
 import { on } from '../@ember/modifier/on.js';
@@ -188,7 +188,7 @@ function deopaquify(opaque) {
   (isDevelopingApp() && !(constructor) && assert(`[BUG] Invalid internal component constructor: ${opaque}`, constructor));
   return constructor;
 }
-const CAPABILITIES$2 = {
+const CAPABILITIES$3 = {
   dynamicLayout: false,
   dynamicTag: false,
   prepareArgs: false,
@@ -205,7 +205,7 @@ const CAPABILITIES$2 = {
 };
 class InternalManager {
   getCapabilities() {
-    return CAPABILITIES$2;
+    return CAPABILITIES$3;
   }
   create(owner, definition, args, _env, _dynamicScope, caller) {
     (isDevelopingApp() && !(isConstRef(caller)) && assert('caller must be const', isConstRef(caller)));
@@ -3571,7 +3571,7 @@ function instrumentationPayload$1(def) {
     object: `${def.name}:main`
   };
 }
-const CAPABILITIES$1 = {
+const CAPABILITIES$2 = {
   dynamicLayout: false,
   dynamicTag: false,
   prepareArgs: false,
@@ -3586,27 +3586,34 @@ const CAPABILITIES$1 = {
   willDestroy: false,
   hasSubOwner: false
 };
+const CAPABILITIES_MASK$1 = capabilityFlagsFrom(CAPABILITIES$2);
 class OutletComponentManager {
   create(_owner, definition, _args, env, dynamicScope) {
     let parentStateRef = dynamicScope.get('outletState');
     let currentStateRef = definition.ref;
+
+    // This is the actual primary responsibility of the outlet component –
+    // it represents the switching from one route component/template into
+    // the next. The rest only exists to support the debug render tree and
+    // the old-school (and unreliable) instrumentation.
     dynamicScope.set('outletState', currentStateRef);
     let state = {
-      self: createConstRef(definition.controller, 'this'),
       finalize: _instrumentStart('render.outlet', instrumentationPayload$1, definition)
     };
     if (env.debugRenderTree !== undefined) {
-      state.outletBucket = {};
       let parentState = valueForRef(parentStateRef);
-      let parentOwner = parentState && parentState.render && parentState.render.owner;
-      let currentOwner = valueForRef(currentStateRef).render.owner;
+      let parentOwner = parentState?.render?.owner;
+      let currentState = valueForRef(currentStateRef);
+      let currentOwner = currentState?.render?.owner;
       if (parentOwner && parentOwner !== currentOwner) {
         (isDevelopingApp() && !(currentOwner instanceof EngineInstance) && assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance));
-        let mountPoint = currentOwner.mountPoint;
-        state.engine = currentOwner;
+        let {
+          mountPoint
+        } = currentOwner;
         if (mountPoint) {
-          state.engineBucket = {
-            mountPoint
+          state.engine = {
+            mountPoint,
+            instance: currentOwner
           };
         }
       }
@@ -3616,13 +3623,12 @@ class OutletComponentManager {
   getDebugName({
     name
   }) {
-    return name;
+    return `{{outlet}} for ${name}`;
   }
-  getDebugCustomRenderTree(definition, state, args) {
+  getDebugCustomRenderTree(_definition, state) {
     let nodes = [];
-    (isDevelopingApp() && !(state.outletBucket) && assert('[BUG] outletBucket must be set', state.outletBucket));
     nodes.push({
-      bucket: state.outletBucket,
+      bucket: state,
       type: 'outlet',
       // "main" used to be the outlet name, keeping it around for compatibility
       name: 'main',
@@ -3630,33 +3636,23 @@ class OutletComponentManager {
       instance: undefined,
       template: undefined
     });
-    if (state.engineBucket) {
+    if (state.engine) {
       nodes.push({
-        bucket: state.engineBucket,
+        bucket: state.engine,
         type: 'engine',
-        name: state.engineBucket.mountPoint,
+        name: state.engine.mountPoint,
         args: EMPTY_ARGS,
-        instance: state.engine,
+        instance: state.engine.instance,
         template: undefined
       });
     }
-    nodes.push({
-      bucket: state,
-      type: 'route-template',
-      name: definition.name,
-      args: args,
-      instance: definition.controller,
-      template: unwrapTemplate(definition.template).moduleName
-    });
     return nodes;
   }
   getCapabilities() {
-    return CAPABILITIES$1;
+    return CAPABILITIES$2;
   }
-  getSelf({
-    self
-  }) {
-    return self;
+  getSelf() {
+    return UNDEFINED_REFERENCE;
   }
   didCreate() {}
   didUpdate() {}
@@ -3669,23 +3665,30 @@ class OutletComponentManager {
   }
 }
 const OUTLET_MANAGER = new OutletComponentManager();
-class OutletComponentDefinition {
+const OUTLET_COMPONENT_TEMPLATE = templateFactory(
+/*
+  <@Component @controller={{@controller}} @model={{@model}} />
+*/
+{
+  "id": "tiv/fOHO",
+  "block": "[[[8,[30,1],null,[[\"@controller\",\"@model\"],[[30,2],[30,3]]],null]],[\"@Component\",\"@controller\",\"@model\"],false,[]]",
+  "moduleName": "/home/runner/work/ember.js/ember.js/packages/@ember/-internals/glimmer/lib/component-managers/outlet.ts",
+  "isStrictMode": true
+});
+class OutletComponent {
   // handle is not used by this custom definition
   handle = -1;
-  resolvedName;
+  resolvedName = null;
+  manager = OUTLET_MANAGER;
+  capabilities = CAPABILITIES_MASK$1;
   compilable;
-  capabilities;
-  constructor(state, manager = OUTLET_MANAGER) {
+  constructor(owner, state) {
     this.state = state;
-    this.manager = manager;
-    let capabilities = manager.getCapabilities();
-    this.capabilities = capabilityFlagsFrom(capabilities);
-    this.compilable = capabilities.wrapped ? unwrapTemplate(state.template).asWrappedLayout() : unwrapTemplate(state.template).asLayout();
-    this.resolvedName = state.name;
+    this.compilable = unwrapTemplate(OUTLET_COMPONENT_TEMPLATE(owner)).asLayout();
   }
 }
 function createRootOutlet(outletView) {
-  return new OutletComponentDefinition(outletView.state);
+  return new OutletComponent(outletView.owner, outletView.state);
 }
 
 class RootComponentManager extends CurlyComponentManager {
@@ -4511,7 +4514,7 @@ class ActionModifierManager {
 const ACTION_MODIFIER_MANAGER = new ActionModifierManager();
 const actionModifier = setInternalModifierManager(ACTION_MODIFIER_MANAGER, {});
 
-const CAPABILITIES = {
+const CAPABILITIES$1 = {
   dynamicLayout: true,
   dynamicTag: false,
   prepareArgs: false,
@@ -4532,7 +4535,7 @@ class MountManager {
     return unwrapTemplate(templateFactory(state.engine)).asLayout();
   }
   getCapabilities() {
-    return CAPABILITIES;
+    return CAPABILITIES$1;
   }
   getOwner(state) {
     return state.engine;
@@ -4633,7 +4636,7 @@ class MountDefinition {
   state;
   manager = MOUNT_MANAGER;
   compilable = null;
-  capabilities = capabilityFlagsFrom(CAPABILITIES);
+  capabilities = capabilityFlagsFrom(CAPABILITIES$1);
   constructor(resolvedName) {
     this.resolvedName = resolvedName;
     this.state = {
@@ -4677,6 +4680,110 @@ const mountHelper = internalHelper((args, owner) => {
   });
 });
 
+const CAPABILITIES = {
+  dynamicLayout: false,
+  dynamicTag: false,
+  prepareArgs: false,
+  createArgs: true,
+  attributeHook: false,
+  elementHook: false,
+  createCaller: false,
+  dynamicScope: false,
+  updateHook: false,
+  createInstance: true,
+  wrapped: false,
+  willDestroy: false,
+  hasSubOwner: false
+};
+const CAPABILITIES_MASK = capabilityFlagsFrom(CAPABILITIES);
+class RouteTemplateManager {
+  create(_owner, _definition, args) {
+    let self = args.named.get('controller');
+    if (isDevelopingApp()) {
+      self = createDebugAliasRef('this', self);
+    }
+    let controller = valueForRef(self);
+    return {
+      self,
+      controller
+    };
+  }
+  getSelf({
+    self
+  }) {
+    return self;
+  }
+  getDebugName({
+    name
+  }) {
+    return `route-template (${name})`;
+  }
+  getDebugCustomRenderTree({
+    name,
+    templateName
+  }, state, args) {
+    return [{
+      bucket: state,
+      type: 'route-template',
+      name,
+      args,
+      instance: state.controller,
+      template: templateName
+    }];
+  }
+  getCapabilities() {
+    return CAPABILITIES;
+  }
+  didRenderLayout() {}
+  didUpdateLayout() {}
+  didCreate() {}
+  didUpdate() {}
+  getDestroyable() {
+    return null;
+  }
+}
+const ROUTE_TEMPLATE_MANAGER = new RouteTemplateManager();
+
+/**
+ * This "upgrades" a route template into a invocable 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.
+ */
+class RouteTemplate {
+  // handle is not used by this custom definition
+  handle = -1;
+  resolvedName;
+  state;
+  manager = ROUTE_TEMPLATE_MANAGER;
+  capabilities = CAPABILITIES_MASK;
+  compilable;
+  constructor(name, template) {
+    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,
+      templateName: unwrapped.moduleName
+    };
+    this.compilable = unwrapped.asLayout();
+  }
+}
+
+// TODO a lot these fields are copied from the adjacent existing components
+// implementation, haven't looked into who cares about `ComponentDefinition`
+// and if it is appropriate here. It seems like this version is intended to
+// be used with `curry` which probably isn't necessary here. It could be the
+// case that we just want to do something more similar to `InternalComponent`
+// (the one we used to implement `Input` and `LinkTo`). For now it follows
+// the same pattern to get things going.
+function makeRouteTemplate(owner, name, template) {
+  let routeTemplate = new RouteTemplate(name, template);
+  return curry(CurriedTypes.Component, routeTemplate, owner, null, true);
+}
+
 /**
   The `{{outlet}}` helper lets you specify where a child route will render in
   your template. An important use of the `{{outlet}}` helper is in your
@@ -4709,15 +4816,77 @@ const outletHelper = internalHelper((_args, owner, scope) => {
     return state?.outlets?.main;
   });
   let lastState = null;
-  let definition = null;
+  let outlet = null;
   return createComputeRef(() => {
     let outletState = valueForRef(outletRef);
     let state = stateFor(outletRef, outletState);
-    if (!validate(state, lastState)) {
+
+    // This code is deliberately using the behavior in glimmer-vm where in
+    // <@Component />, the component is considered stabled via `===`, and
+    // will continue to re-render in-place as long as the `===` holds, but
+    // when it changes to a different object, it teardown the old component
+    // (running destructors, etc), and render the component in its place (or
+    // nothing if the new value is nullish. Here we are carefully exploiting
+    // that fact, and returns the same stable object so long as it is the
+    // 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();
 
+        // 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;
+        if (hasInternalComponentManager(template)) {
+          component = template;
+        } else {
+          if (isDevelopingApp()) {
+            // 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 => {
+              if (template === null || typeof template !== 'object') {
+                return false;
+              } else {
+                let t = 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;
+              try {
+                label = `\`${String(template)}\``;
+              } catch {
+                label = 'an unknown object';
+              }
+              (isDevelopingApp() && !(false) && assert(`Failed to render the \`${state.name}\` route: expected ` + `a component or Template object, but got ${label}.`));
+            }
+          }
+          component = makeRouteTemplate(outletOwner, state.name, 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']);
 
@@ -4740,12 +4909,14 @@ const outletHelper = internalHelper((_args, owner, scope) => {
           named['model'] = createDebugAliasRef('@model', named['model']);
         }
         let args = createCapturedArgs(named, EMPTY_POSITIONAL);
-        definition = curry(CurriedTypes.Component, new OutletComponentDefinition(state), outletState?.render?.owner ?? owner, args, true);
+
+        // Package up everything
+        outlet = curry(CurriedTypes.Component, new OutletComponent(owner, state), outletOwner, args, true);
       } else {
-        definition = null;
+        outlet = null;
       }
     }
-    return definition;
+    return outlet;
   });
 });
 function stateFor(ref, outlet) {
@@ -4753,20 +4924,19 @@ function stateFor(ref, outlet) {
   let render = outlet.render;
   if (render === undefined) return null;
   let template = render.template;
-  if (template === undefined) return null;
+  // 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;
   return {
     ref,
     name: render.name,
     template,
-    controller: render.controller,
-    model: render.model
+    controller: render.controller
   };
 }
-function validate(state, lastState) {
-  if (state === null) {
-    return lastState === null;
-  }
-  if (lastState === null) {
+function isStable(state, lastState) {
+  if (state === null || lastState === null) {
     return false;
   }
   return state.template === lastState.template && state.controller === lastState.controller;
@@ -5020,8 +5190,7 @@ class OutletView {
       ref,
       name: TOP_LEVEL_NAME,
       template,
-      controller: undefined,
-      model: undefined
+      controller: undefined
     };
   }
   appendTo(selector) {
@@ -5272,8 +5441,31 @@ class Renderer {
   // renderer HOOKS
 
   appendOutletView(view, target) {
-    let definition = createRootOutlet(view);
-    this._appendDefinition(view, curry(CurriedTypes.Component, definition, view.owner, null, true), target);
+    // 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 named = dict();
+    named['Component'] = createConstRef(makeRouteTemplate(view.owner, name, 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;
+    let args = createCapturedArgs(named, EMPTY_POSITIONAL);
+    this._appendDefinition(view, curry(CurriedTypes.Component, outlet, view.owner, args, true), target);
   }
   appendTo(view, target) {
     let definition = new RootComponentDefinition(view);

package/dist/packages/shared-chunks/{setup-registry-CFRLjlg1.js → setup-registry-ziuiqoKc.js}

@@ -1,7 +1,7 @@
 import { p as privatize } from './registry-B8WARvkP.js';
 import { getOwner } from '../@ember/-internals/owner/index.js';
 import '../@ember/debug/index.js';
-import { R as RootTemplate, b as Renderer, O as OutletView, c as OutletTemplate, I as Input, L as LinkTo, T as Textarea } from './index-C7oKNWrX.js';
+import { R as RootTemplate, b as Renderer, O as OutletView, c as OutletTemplate, I as Input, L as LinkTo, T as Textarea } from './index-4KqgXTKl.js';
 import { clientBuilder, rehydrationBuilder } from '../@glimmer/runtime/index.js';
 import { serializeBuilder } from '../@glimmer/node/index.js';
 import { isDevelopingApp } from '@embroider/macros';