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

package/dist/ember.prod.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   6.3.0-alpha.2
+ * @version   6.3.0-alpha.3
  */
 /* eslint-disable no-var */
 /* globals global globalThis self */
@@ -2620,7 +2620,7 @@ var define, require;
           }, Symbol.toStringTag, { value: 'Module' });
 
           // 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';
 
           const emberVersion = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,
@@ -4327,7 +4327,7 @@ var define, require;
           function hasInternalModifierManager(definition) {
             return void 0 !== getManager(MODIFIER_MANAGERS, definition);
           }
-          const CAPABILITIES$4 = {
+          const CAPABILITIES$5 = {
             dynamicLayout: !1,
             dynamicTag: !1,
             prepareArgs: !1,
@@ -4461,7 +4461,7 @@ var define, require;
               return null;
             }
             getCapabilities() {
-              return CAPABILITIES$4;
+              return CAPABILITIES$5;
             }
           }
 
@@ -18300,7 +18300,7 @@ var define, require;
             let item = vm.stack.peek().next();
             null !== item ? vm.registerItem(vm.enterItem(item)) : vm.goto(breaks);
           });
-          const CAPABILITIES$3 = {
+          const CAPABILITIES$4 = {
             dynamicLayout: !1,
             dynamicTag: !1,
             prepareArgs: !1,
@@ -18317,7 +18317,7 @@ var define, require;
           };
           class TemplateOnlyComponentManager {
             getCapabilities() {
-              return CAPABILITIES$3;
+              return CAPABILITIES$4;
             }
             getDebugName({
               name: name
@@ -20339,7 +20339,7 @@ var define, require;
             let constructor = OPAQUE_CONSTRUCTOR_MAP.get(opaque);
             return constructor;
           }
-          const CAPABILITIES$2 = {
+          const CAPABILITIES$3 = {
             dynamicLayout: false,
             dynamicTag: false,
             prepareArgs: false,
@@ -20356,7 +20356,7 @@ var define, require;
           };
           class InternalManager {
             getCapabilities() {
-              return CAPABILITIES$2;
+              return CAPABILITIES$3;
             }
             create(owner, definition, args, _env, _dynamicScope, caller) {
               let ComponentClass = deopaquify(definition);
@@ -25579,7 +25579,7 @@ var define, require;
               object: `${def.name}:main`
             };
           }
-          const CAPABILITIES$1 = {
+          const CAPABILITIES$2 = {
             dynamicLayout: false,
             dynamicTag: false,
             prepareArgs: false,
@@ -25594,26 +25594,33 @@ var define, require;
             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),
                 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) {
-                  let mountPoint = currentOwner.mountPoint;
-                  state.engine = currentOwner;
+                  let {
+                    mountPoint
+                  } = currentOwner;
                   if (mountPoint) {
-                    state.engineBucket = {
-                      mountPoint
+                    state.engine = {
+                      mountPoint,
+                      instance: currentOwner
                     };
                   }
                 }
@@ -25623,12 +25630,12 @@ var define, require;
             getDebugName({
               name
             }) {
-              return name;
+              return `{{outlet}} for ${name}`;
             }
-            getDebugCustomRenderTree(definition, state, args) {
+            getDebugCustomRenderTree(_definition, state) {
               let nodes = [];
               nodes.push({
-                bucket: state.outletBucket,
+                bucket: state,
                 type: 'outlet',
                 // "main" used to be the outlet name, keeping it around for compatibility
                 name: 'main',
@@ -25636,33 +25643,23 @@ var define, require;
                 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() {}
@@ -25675,23 +25672,30 @@ var define, require;
             }
           }
           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 {
@@ -34969,13 +34973,40 @@ var define, require;
             let name = route.routeName;
             let controller = owner.lookup(`controller:${route.controllerName || name}`);
             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 {
+                template = templateFactoryOrComponent(owner);
+              }
+            } else {
+              // default `{{outlet}}`
+              template = route._topLevelViewTemplate(owner);
+            }
             let render = {
               owner,
               name,
               controller,
               model,
-              template: template?.(owner) ?? route._topLevelViewTemplate(owner)
+              template
             };
             return render;
           }
@@ -37340,7 +37371,7 @@ var define, require;
                     prefixRouteNameArg
           }, Symbol.toStringTag, { value: 'Module' });
 
-          const CAPABILITIES = {
+          const CAPABILITIES$1 = {
             dynamicLayout: true,
             dynamicTag: false,
             prepareArgs: false,
@@ -37361,7 +37392,7 @@ var define, require;
               return unwrapTemplate(templateFactory(state.engine)).asLayout();
             }
             getCapabilities() {
-              return CAPABILITIES;
+              return CAPABILITIES$1;
             }
             getOwner(state) {
               return state.engine;
@@ -37457,7 +37488,7 @@ var define, require;
             state;
             manager = MOUNT_MANAGER;
             compilable = null;
-            capabilities = capabilityFlagsFrom(CAPABILITIES);
+            capabilities = capabilityFlagsFrom(CAPABILITIES$1);
             constructor(resolvedName) {
               this.resolvedName = resolvedName;
               this.state = {
@@ -37533,6 +37564,107 @@ var define, require;
             });
           });
 
+          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');
+              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
@@ -37563,15 +37695,49 @@ var define, require;
               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 {
+                    component = makeRouteTemplate(outletOwner, state.name, template);
+                  }
+
+                  // Component is stable for the lifetime of the outlet
+                  named['Component'] = createConstRef(component);
+
+                  // Controller is stable for the lifetime of the outlet
+                  named['controller'] = createConstRef(state.controller);
+
                   // Create a ref for the model
                   let modelRef = childRefFromParts(outletRef, ['render', 'model']);
 
@@ -37591,12 +37757,14 @@ var define, require;
                     return 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) {
@@ -37604,20 +37772,19 @@ var define, require;
             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;
@@ -37856,8 +38023,7 @@ var define, require;
                 ref,
                 name: TOP_LEVEL_NAME,
                 template,
-                controller: undefined,
-                model: undefined
+                controller: undefined
               };
             }
             appendTo(selector) {
@@ -38084,8 +38250,31 @@ var define, require;
             // 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));
+
+              // 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/@ember/-internals/glimmer/index.js

@@ -1,7 +1,7 @@
 export { templateFactory as template, templateCacheCounters } from '../../../@glimmer/opcode-compiler/index.js';
-export { C as Component, H as Helper, I as Input, L as LinkTo, O as OutletView, b as Renderer, R as RootTemplate, S as SafeString, T as Textarea, _ as _resetRenderers, e as escapeExpression, h as helper, a as htmlSafe, i as isHTMLSafe, r as renderSettled, u as uniqueId } from '../../../shared-chunks/index-C7oKNWrX.js';
+export { C as Component, H as Helper, I as Input, L as LinkTo, O as OutletView, b as Renderer, R as RootTemplate, S as SafeString, T as Textarea, _ as _resetRenderers, e as escapeExpression, h as helper, a as htmlSafe, i as isHTMLSafe, r as renderSettled, u as uniqueId } from '../../../shared-chunks/index-4KqgXTKl.js';
 export { g as getTemplate, a as getTemplates, h as hasTemplate, s as setTemplate, b as setTemplates } from '../../../shared-chunks/template_registry-DigcUg9m.js';
-export { a as setupApplicationRegistry, s as setupEngineRegistry } from '../../../shared-chunks/setup-registry-CFRLjlg1.js';
+export { a as setupApplicationRegistry, s as setupEngineRegistry } from '../../../shared-chunks/setup-registry-ziuiqoKc.js';
 export { DOMChanges, DOMTreeConstruction, isSerializationFirstNode } from '../../../@glimmer/runtime/index.js';
 export { NodeDOMTreeConstruction } from '../../../@glimmer/node/index.js';
 export { s as setComponentManager } from '../../../shared-chunks/managers-CbMgnSoo.js';

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

@@ -47,8 +47,8 @@ import ApplicationInstance from './instance.js';
 import Engine, { buildInitializerMethod } from '../engine/index.js';
 import { p as privatize } from '../../shared-chunks/registry-B8WARvkP.js';
 import '../../@glimmer/opcode-compiler/index.js';
-import '../../shared-chunks/index-C7oKNWrX.js';
-import { a as setupApplicationRegistry } from '../../shared-chunks/setup-registry-CFRLjlg1.js';
+import '../../shared-chunks/index-4KqgXTKl.js';
+import { a as setupApplicationRegistry } from '../../shared-chunks/setup-registry-ziuiqoKc.js';
 import '../../@glimmer/runtime/index.js';
 import '../../@glimmer/reference/index.js';
 import RouterService from '../routing/router-service.js';

package/dist/packages/@ember/application/instance.js

@@ -2,7 +2,7 @@ import '../object/index.js';
 import { h as hasDOM, e as environment } from '../../shared-chunks/index-BGP1rw3B.js';
 import EngineInstance from '../engine/instance.js';
 import '../../@glimmer/opcode-compiler/index.js';
-import { r as renderSettled } from '../../shared-chunks/index-C7oKNWrX.js';
+import { r as renderSettled } 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/component/helper.js

@@ -1,5 +1,5 @@
 import '../../@glimmer/opcode-compiler/index.js';
-export { H as default, h as helper } from '../../shared-chunks/index-C7oKNWrX.js';
+export { H as default, h as helper } 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/component/index.js

@@ -1,6 +1,6 @@
 export { componentCapabilities as capabilities, getComponentTemplate, setComponentTemplate } from '../../@glimmer/manager/index.js';
 import '../../@glimmer/opcode-compiler/index.js';
-export { I as Input, T as Textarea, C as default } from '../../shared-chunks/index-C7oKNWrX.js';
+export { I as Input, T as Textarea, C as default } 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/engine/index.js

@@ -30,8 +30,8 @@ import '../-internals/views/lib/mixins/view_state_support.js';
 import '../-internals/views/lib/mixins/view_support.js';
 import '../-internals/views/lib/mixins/action_support.js';
 import '../../@glimmer/opcode-compiler/index.js';
-import '../../shared-chunks/index-C7oKNWrX.js';
-import { s as setupEngineRegistry } from '../../shared-chunks/setup-registry-CFRLjlg1.js';
+import '../../shared-chunks/index-4KqgXTKl.js';
+import { s as setupEngineRegistry } from '../../shared-chunks/setup-registry-ziuiqoKc.js';
 import '../../@glimmer/runtime/index.js';
 import '../runloop/index.js';
 import '../../@glimmer/reference/index.js';

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

@@ -1,7 +1,7 @@
 import { helperCapabilities, setHelperManager as setHelperManager$1 } from '../../@glimmer/manager/index.js';
 import { invokeHelper as invokeHelper$1, hash as hash$1, array as array$1, concat as concat$1, get as get$1, fn as fn$1 } from '../../@glimmer/runtime/index.js';
 import '../../@glimmer/opcode-compiler/index.js';
-import { u as uniqueId$1 } from '../../shared-chunks/index-C7oKNWrX.js';
+import { u as uniqueId$1 } from '../../shared-chunks/index-4KqgXTKl.js';
 import '../../shared-chunks/registry-B8WARvkP.js';
 import '../debug/index.js';
 import '../runloop/index.js';

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

@@ -2,7 +2,7 @@ import { setModifierManager as setModifierManager$1 } from '../../@glimmer/manag
 export { modifierCapabilities as capabilities } from '../../@glimmer/manager/index.js';
 export { on } from './on.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 '../debug/index.js';
 import '../../@glimmer/runtime/index.js';

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

@@ -1,5 +1,5 @@
 import '../../@glimmer/opcode-compiler/index.js';
-export { r as renderSettled } from '../../shared-chunks/index-C7oKNWrX.js';
+export { r as renderSettled } 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/routing/index.js

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