ember-source 7.2.0-alpha.4 → 7.3.0-alpha.1

package/dist/dev/packages/shared-chunks/{index-dyv6rcBf.js → index-CCyXUNBa.js}

@@ -1,252 +1,160 @@
-import { privatize } from '../@ember/-internals/container/index.js';
 import { E as ENV } from './env-g-kaAFLN.js';
-import { isFactory, getOwner } from '../@ember/-internals/owner/index.js';
-import { a as guidFor } from './guid-PO2v9BaN.js';
-import { constructStyleDeprecationMessage, getViewId, getViewElement } from '../@ember/-internals/views/lib/system/utils.js';
 import { deprecate, warn } from '../@ember/debug/index.js';
 import { schedule, _backburner, _getCurrentRunLoop } from '../@ember/runloop/index.js';
-import { associateDestroyableChild, isDestroyed, destroy, registerDestructor, isDestroying } from '../@glimmer/destroyable/index.js';
+import { associateDestroyableChild, destroy, registerDestructor, isDestroyed, isDestroying } from '../@glimmer/destroyable/index.js';
 import { artifacts } from '../@glimmer/program/index.js';
-import { R as RuntimeOpImpl } from './program-CPXeXWVB.js';
-import { v as valueForRef, U as UNDEFINED_REFERENCE, b as createComputeRef, j as isConstRef, d as createConstRef, l as isUpdatableRef, f as createInvokableRef, h as createReadOnlyRef, i as createUnboundRef, e as createDebugAliasRef, a as childRefFromParts, u as updateRef } from './reference-C-OXd_kp.js';
-import { e as clientBuilder } from './element-builder-Cl1kHFJE.js';
-import { E as EMPTY_ARGS, g as createCapturedArgs, c as EMPTY_POSITIONAL, h as curry } from './untouchable-this-BHdAERUu.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-Dz3OWqXy.js';
-import { d as dict } from './collections-DEt-i-8B.js';
-import { u as unwrapTemplate, b as CurlyComponentManager, i as initialRenderInstrumentDetails, p as processComponentInitializationAssertions, a as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-YoYS2vXw.js';
-import { b as CONSTANT_TAG, k as consumeTag, u as isTracking, o as debug, D as DIRTY_TAG$1, m as createTag, B as valueForTag, c as CURRENT_TAG, z as validateTag } from './cache-CeWOBNQg.js';
-import { a as RSVP } from './rsvp-C6j8G1D1.js';
-import { h as hasDOM } from './index-DX90CU4L.js';
-import EngineInstance from '../@ember/engine/instance.js';
-import { _instrumentStart } from '../@ember/instrumentation/index.js';
-import { c as capabilityFlagsFrom } from './capabilities-CZkuOqqC.js';
-import { h as templateFactory } from './index-DkwVSPP5.js';
-import { assert } from '../@ember/debug/lib/assert.js';
-import { g as getFactoryFor } from './container-BzzHmCNj.js';
-import { g as get, a as _getProp } from './property_get-BjbsrgpU.js';
-import { _ as _setProp, s as set } from './property_set-LJskl202.js';
+import { R as RuntimeOpImpl } from './program-DlgjqLa6.js';
+import { c as clientBuilder } from './api-C0PAtEgQ.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1 } from './render-87_sKZ_k.js';
+import { c as consumeTag, z as isTracking, e as debug, a as valueForTag, k as CURRENT_TAG, v as validateTag } from './cache-DGDPVCpC.js';
+import { h as hasDOM } from './index-BGP1rw3B.js';
+import { g as get$1, b as _getProp } from './property_get-CRP7MFz_.js';
+import { _ as _setProp, s as set } from './property_set-qCUylPEK.js';
 import { g as getDebugName } from './get-debug-name-CSniHBsn.js';
+import { constructStyleDeprecationMessage } from '../@ember/-internals/views/lib/system/utils.js';
 import setGlobalContext from '../@glimmer/global-context/index.js';
-import { t as tagForObject, o as objectAt, b as tagForProperty } from './chain-tags-DfmU63mS.js';
+import { a as tagForProperty, t as tagForObject, o as objectAt } from './chain-tags-uWSImHzB.js';
 import { isEmberArray } from '../@ember/array/-internals.js';
 import { i as isObject } from './spec-BXl1reqK.js';
-import { t as tagFor } from './meta-Cjo3zQJq.js';
+import { t as tagFor } from './meta-BqC7f9Ia.js';
 import { contentFor } from '../@ember/-internals/runtime/lib/mixins/-proxy.js';
 import { i as isProxy } from './is_proxy-Bzg0d4m4.js';
-import { i as internalHelper } from './internal-helper-IC87S6iZ.js';
+import { v as valueForRef, c as createComputeRef, i as isConstRef, a as createConstRef, d as isUpdatableRef, j as createInvokableRef, k as createReadOnlyRef, l as createUnboundRef } from './reference-BqOLhKFy.js';
+import { i as internalHelper } from './internal-helper-CKrni0b_.js';
+import { assert } from '../@ember/debug/lib/assert.js';
 import { i as isHTMLSafe } from './index-D-xTBV4B.js';
-import { isArray } from '../@ember/array/index.js';
+import isArray from '../@ember/array/lib/is-array.js';
+import { isFactory } from '../@ember/-internals/owner/index.js';
+import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { g as getComponentTemplate } from './template-R_5UMHhb.js';
-import { c as hasInternalComponentManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DG5kRT-o.js';
-import { h as hash, f as fn, a as array } from './hash-2-93qikL.js';
-import { g as get$1, c as concat } from './get-CO3EIWsm.js';
-import { o as on } from './on-Ch_lyozr.js';
-import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-BxYzSEnC.js';
-import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-Bm6EhgSW.js';
+import { a as getInternalHelperManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-DuLOZMO_.js';
+import { h as hash, f as fn, a as array } from './hash-6NDs_5_f.js';
+import { g as get, c as concat } from './get-6I3sjd-I.js';
+import { o as on } from './on-DlF0Wy7P.js';
+import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-Cu639ICT.js';
+import { i as isCurlyManager } from './curly-brand-B_F79Dep.js';
+import { i as isClassicHelper } from './helper-brand-C9_8vvOf.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
-import { a as uniqueId } from './unique-id-Hd96VZlE.js';
-import '../route-recognizer/index.js';
-import './unrecognized-url-error-BQdkjTtZ.js';
-import '../@ember/routing/lib/routing-service.js';
-import { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
-import { E as EvaluationContextImpl } from './program-context-BaYVr5GA.js';
-
-function instrumentationPayload$1(def) {
-  // "main" used to be the outlet name, keeping it around for compatibility
-  return {
-    object: `${def.name}:main`
-  };
-}
-const CAPABILITIES$2 = {
-  dynamicLayout: false,
-  dynamicTag: false,
-  prepareArgs: false,
-  createArgs: false,
-  attributeHook: false,
-  elementHook: false,
-  createCaller: false,
-  dynamicScope: true,
-  updateHook: false,
-  createInstance: true,
-  wrapped: false,
-  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 = {
-      finalize: _instrumentStart('render.outlet', instrumentationPayload$1, definition)
-    };
-    if (env.debugRenderTree !== undefined) {
-      let parentState = valueForRef(parentStateRef);
-      let parentOwner = parentState?.render?.owner;
-      let currentState = valueForRef(currentStateRef);
-      let currentOwner = currentState?.render?.owner;
-      if (parentOwner && parentOwner !== currentOwner) {
-        (!(currentOwner instanceof EngineInstance) && assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance));
-        let {
-          mountPoint
-        } = currentOwner;
-        if (mountPoint) {
-          state.engine = {
-            mountPoint,
-            instance: currentOwner
-          };
-        }
-      }
-    }
-    return state;
-  }
-  getDebugName({
-    name
-  }) {
-    return `{{outlet}} for ${name}`;
-  }
-  getDebugCustomRenderTree(_definition, state) {
-    let nodes = [];
-    nodes.push({
-      bucket: state,
-      type: 'outlet',
-      // "main" used to be the outlet name, keeping it around for compatibility
-      name: 'main',
-      args: EMPTY_ARGS,
-      instance: undefined
-    });
-    if (state.engine) {
-      nodes.push({
-        bucket: state.engine,
-        type: 'engine',
-        name: state.engine.mountPoint,
-        args: EMPTY_ARGS,
-        instance: state.engine.instance
-      });
-    }
-    return nodes;
-  }
-  getCapabilities() {
-    return CAPABILITIES$2;
-  }
-  getSelf() {
-    return UNDEFINED_REFERENCE;
-  }
-  didCreate() {}
-  didUpdate() {}
-  didRenderLayout(state) {
-    state.finalize();
-  }
-  didUpdateLayout() {}
-  getDestroyable() {
-    return null;
-  }
-}
-const OUTLET_MANAGER = new OutletComponentManager();
-const OUTLET_COMPONENT_TEMPLATE = templateFactory(
-/*
-  <@Component @controller={{@controller}} @model={{@model}} />
+import { a as uniqueId } from './unique-id-DQOhouG1.js';
+import { E as EvaluationContextImpl } from './program-context-Dq8xN2HI.js';
+
+/**
+@module ember
 */
-{
-  "id": null,
-  "block": "[[[8,[30,1],null,[[\"@controller\",\"@model\"],[[30,2],[30,3]]],null]],[\"@Component\",\"@controller\",\"@model\"],[]]",
-  "moduleName": "(unknown template module)",
-  "isStrictMode": true
+const disallowDynamicResolution = internalHelper(({
+  positional,
+  named
+}) => {
+  const nameOrValueRef = positional[0];
+  (!(positional.length === 1 && nameOrValueRef) && assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1 && nameOrValueRef));
+  let typeRef = named['type'];
+  let locRef = named['loc'];
+  let originalRef = named['original'];
+  (!(typeRef) && assert(`[BUG] expecting \`type\` named argument`, typeRef));
+  (!(locRef) && assert(`[BUG] expecting \`loc\` named argument`, locRef));
+  (!(originalRef) && assert(`[BUG] expecting \`original\` named argument`, originalRef)); // Bug: why do these fail?
+  // assert('[BUG] expecting a string literal for the `type` argument', isConstRef(typeRef));
+  // assert('[BUG] expecting a string literal for the `loc` argument', isConstRef(locRef));
+  // assert('[BUG] expecting a string literal for the `original` argument', isConstRef(originalRef));
+  const type = valueForRef(typeRef);
+  const loc = valueForRef(locRef);
+  const original = valueForRef(originalRef);
+  (!(typeof type === 'string') && assert('[BUG] expecting a string literal for the `type` argument', typeof type === 'string'));
+  (!(typeof loc === 'string') && assert('[BUG] expecting a string literal for the `loc` argument', typeof loc === 'string'));
+  (!(typeof original === 'string') && assert('[BUG] expecting a string literal for the `original` argument', typeof original === 'string'));
+  return createComputeRef(() => {
+    let nameOrValue = valueForRef(nameOrValueRef);
+    (!(typeof nameOrValue !== 'string') && assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them directly. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string'));
+    return nameOrValue;
+  });
 });
-class OutletComponent {
-  // handle is not used by this custom definition
-  handle = -1;
-  resolvedName = null;
-  manager = OUTLET_MANAGER;
-  capabilities = CAPABILITIES_MASK$1;
-  compilable;
-  constructor(owner, state) {
-    this.state = state;
-    this.compilable = unwrapTemplate(OUTLET_COMPONENT_TEMPLATE(owner)).asLayout();
-  }
-}
-function createRootOutlet(outletView) {
-  return new OutletComponent(outletView.owner, outletView.state);
+
+let helper;
+{
+  helper = args => {
+    const inner = args.positional[0];
+    (!(inner) && assert('expected at least one positional arg', inner));
+    return createComputeRef(() => {
+      let value = valueForRef(inner);
+      (!(value !== null && value !== undefined) && assert('You cannot pass a null or undefined destination element to in-element', value !== null && value !== undefined));
+      return value;
+    });
+  };
 }
+const inElementNullCheckHelper = internalHelper(helper);
 
-class RootComponentManager extends CurlyComponentManager {
-  component;
-  constructor(component) {
-    super();
-    this.component = component;
-  }
-  create(_owner, _state, _args, {
-    isInteractive
-  }, dynamicScope) {
-    let component = this.component;
-    let finalizer = _instrumentStart('render.component', initialRenderInstrumentDetails, component);
-    dynamicScope.view = component;
-    let hasWrappedElement = component.tagName !== '';
-
-    // We usually do this in the `didCreateElement`, but that hook doesn't fire for tagless components
-    if (!hasWrappedElement) {
-      if (isInteractive) {
-        component.trigger('willRender');
-      }
-      component._transitionTo('hasElement');
-      if (isInteractive) {
-        component.trigger('willInsertElement');
-      }
-    }
-    {
-      processComponentInitializationAssertions(component, {});
+const normalizeClassHelper = internalHelper(({
+  positional
+}) => {
+  return createComputeRef(() => {
+    let classNameArg = positional[0];
+    let valueArg = positional[1];
+    (!(classNameArg && valueArg) && assert('expected at least two positional args', classNameArg && valueArg));
+    let classNameParts = valueForRef(classNameArg).split('.');
+    let className = classNameParts[classNameParts.length - 1];
+    (!(className) && assert('has className', className)); // Always at least one split result
+    let value = valueForRef(valueArg);
+    if (value === true) {
+      return dasherize(className);
+    } else if (!value && value !== 0) {
+      return '';
+    } else {
+      return String(value);
     }
-    let bucket = new ComponentStateBucket(component, null, CONSTANT_TAG, finalizer, hasWrappedElement, isInteractive);
-    consumeTag(component[DIRTY_TAG]);
-    return bucket;
-  }
-}
+  });
+});
 
-// ROOT is the top-level template it has nothing but one yield.
-// it is supposed to have a dummy element
-const ROOT_CAPABILITIES = {
-  dynamicLayout: true,
-  dynamicTag: true,
-  prepareArgs: false,
-  createArgs: false,
-  attributeHook: true,
-  elementHook: true,
-  createCaller: true,
-  dynamicScope: true,
-  updateHook: true,
-  createInstance: true,
-  wrapped: true,
-  willDestroy: false,
-  hasSubOwner: false
-};
-class RootComponentDefinition {
-  // handle is not used by this custom definition
-  handle = -1;
-  resolvedName = '-top-level';
-  state;
-  manager;
-  capabilities = capabilityFlagsFrom(ROOT_CAPABILITIES);
-  compilable = null;
-  constructor(component) {
-    this.manager = new RootComponentManager(component);
-    let factory = getFactoryFor(component);
-    (!(factory !== undefined) && assert('missing factory for component', factory !== undefined));
-    this.state = factory;
+/**
+  @module ember
+*/
+
+const resolve = internalHelper(({
+  positional
+}, owner) => {
+  // why is this allowed to be undefined in the first place?
+  (!(owner) && assert('[BUG] missing owner', owner));
+  (!(positional.length === 1) && assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1));
+  let fullNameRef = positional[0];
+  (!(fullNameRef && isConstRef(fullNameRef)) && assert('[BUG] expecting a string literal as argument', fullNameRef && isConstRef(fullNameRef)));
+  let fullName = valueForRef(fullNameRef);
+  (!(typeof fullName === 'string') && assert('[BUG] expecting a string literal as argument', typeof fullName === 'string'));
+  (!((s => s.split(':').length === 2)(fullName)) && assert('[BUG] expecting a valid full name', (s => s.split(':').length === 2)(fullName)));
+  {
+    let [type, name] = fullName.split(':');
+    (!(owner.hasRegistration(fullName)) && assert(`Attempted to invoke \`(-resolve "${fullName}")\`, but ${name} was not a valid ${type} name.`, owner.hasRegistration(fullName)));
   }
-}
+  return createConstRef(owner.factoryFor(fullName)?.class, `(-resolve "${fullName}")`);
+});
+
+/**
+@module ember
+*/
+
+/**
+  This reference is used to get the `[]` tag of iterables, so we can trigger
+  updates to `{{each}}` when it changes. It is put into place by a template
+  transform at build time, similar to the (-each-in) helper
+*/
+const trackArray = internalHelper(({
+  positional
+}) => {
+  const inner = positional[0];
+  (!(inner) && assert('expected at least one positional arg', inner));
+  return createComputeRef(() => {
+    let iterable = valueForRef(inner);
+    if (isObject(iterable)) {
+      consumeTag(tagForProperty(iterable, '[]'));
+    }
+    return iterable;
+  });
+});
 
 /**
 @module ember
 */
 
 /**
-  The `{{#each}}` helper loops over elements in a collection. It is an extension
+  The `{{#each}}` keyword loops over elements in a collection. It is an extension
   of the base Handlebars `{{#each}}` helper.
 
   The default behavior of `{{#each}}` is to yield its inner block once for every
@@ -290,6 +198,8 @@ class RootComponentDefinition {
     {{/each}}
   </ul>
   ```
+    
+  `#each` is a keyword and does not need to be imported. 
 
   ### Specifying Keys
 
@@ -357,11 +267,11 @@ class RootComponentDefinition {
  */
 
 /**
-  The `{{each-in}}` helper loops over properties on an object.
+  The `{{#each-in}}` keyword loops over properties on an object.
 
   For example, given this component definition:
 
-  ```app/components/developer-details.js
+  ```app/components/developer-details.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
 
@@ -370,21 +280,19 @@ class RootComponentDefinition {
       "name": "Shelly Sails",
       "age": 42
     };
+    
+    <template>
+      <ul>
+        {{#each-in this.developer as |key value|}}
+          <li>{{key}}: {{value}}</li>
+        {{/each-in}}
+      </ul>
+    </template>
   }
   ```
 
   This template would display all properties on the `developer`
-  object in a list:
-
-  ```app/components/developer-details.hbs
-  <ul>
-    {{#each-in this.developer as |key value|}}
-      <li>{{key}}: {{value}}</li>
-    {{/each-in}}
-  </ul>
-  ```
-
-  Outputting their name and age:
+  object in a list, outputting their name and age:
 
   ```html
   <ul>
@@ -392,6 +300,8 @@ class RootComponentDefinition {
     <li>age: 42</li>
   </ul>
   ```
+ 
+  `#each-in` is a keyword and does not need to be imported.
 
   @method each-in
   @for Ember.Templates.helpers
@@ -420,575 +330,104 @@ const eachIn = internalHelper(({
   });
 });
 
-function toIterator(iterable) {
-  if (iterable instanceof EachInWrapper) {
-    return toEachInIterator(iterable.inner);
-  } else {
-    return toEachIterator(iterable);
-  }
-}
-function toEachInIterator(iterable) {
-  if (!isIndexable(iterable)) {
-    return null;
-  }
-  if (Array.isArray(iterable) || isEmberArray(iterable)) {
-    return ObjectIterator.fromIndexable(iterable);
-  } else if (isNativeIterable(iterable)) {
-    return MapLikeNativeIterator.from(iterable);
-  } else if (hasForEach(iterable)) {
-    return ObjectIterator.fromForEachable(iterable);
-  } else {
-    return ObjectIterator.fromIndexable(iterable);
+/**
+@module ember
+*/
+
+/**
+  The `mut` helper is a shortcut for updating for args.
+    
+  However, defining update functions on your backing class is preferable to using `mut`.
+    
+  More directly: Don't use `mut`. 
+
+  The `mut` helper, when used with `fn`, will return a function that
+  sets the value passed to `mut` to its first argument. As an example, we can create a
+  button that increments a value passing the value directly to the `fn`:
+
+  ```handlebars
+  <MyChild @childClickCount={{this.totalClicks}} @clickCountChange={{fn (mut this.totalClicks)}} />
+  ```
+
+  The child `Component` would invoke the function with the new click count:
+
+  ```app/components/my-child.gjs
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+    
+  export default class MyChild extends Component {
+    @action
+    update() {
+      this.args.clickCountChange(this.args.childClickCount + 1);
+    }
+    
+    <template>
+      <button {{on "click" this.update}}>
+        Click me!
+      </button>
+    </template>
   }
-}
-function toEachIterator(iterable) {
-  if (!isObject(iterable)) {
-    return null;
+  ```
+
+  The `mut` helper changes the `totalClicks` value to what was provided as the `fn` argument.
+
+  @method mut
+  @param {Object} [attr] the "two-way" attribute that can be modified.
+  @for Ember.Templates.helpers
+  @public
+*/
+
+const mut = internalHelper(({
+  positional
+}) => {
+  let ref = positional[0];
+  (!(ref) && assert('expected at least one positional arg', ref)); // TODO: Improve this error message. This covers at least two distinct
+  // cases:
+  //
+  // 1. (mut "not a path") – passing a literal, result from a helper
+  //    invocation, etc
+  //
+  // 2. (mut receivedValue) – passing a value received from the caller
+  //    that was originally derived from a literal, result from a helper
+  //    invocation, etc
+  //
+  // This message is alright for the first case, but could be quite
+  // confusing for the second case.
+  (!(isUpdatableRef(ref)) && assert('You can only pass a path to mut', isUpdatableRef(ref)));
+  return createInvokableRef(ref);
+});
+
+/**
+@module ember
+*/
+
+
+/**
+  The `readonly` helper let's you specify that a binding is one-way only,
+  instead of two-way.
+  
+  This is a vestigial helper from the days of `@ember/component` and does not apply to
+  components extending from `@glimmer/component`.
+    
+  When you pass a `readonly` binding from an outer context (e.g. parent component),
+  to to an inner context (e.g. child component), you are saying that changing that
+  property in the inner context does not change the value in the outer context.
+
+  To specify that a binding is read-only, when invoking the child `Component`:
+
+  ```app/components/my-parent.js
+  export default class MyParent extends Component {
+    totalClicks = 3;
   }
-  if (Array.isArray(iterable)) {
-    return ArrayIterator.from(iterable);
-  } else if (isEmberArray(iterable)) {
-    return EmberArrayIterator.from(iterable);
-  } else if (isNativeIterable(iterable)) {
-    return ArrayLikeNativeIterator.from(iterable);
-  } else if (hasForEach(iterable)) {
-    return ArrayIterator.fromForEachable(iterable);
-  } else {
-    return null;
-  }
-}
-class BoundedIterator {
-  position = 0;
-  constructor(length) {
-    this.length = length;
-  }
-  isEmpty() {
-    return false;
-  }
-  memoFor(position) {
-    return position;
-  }
-  next() {
-    let {
-      length,
-      position
-    } = this;
-    if (position >= length) {
-      return null;
-    }
-    let value = this.valueFor(position);
-    let memo = this.memoFor(position);
-    this.position++;
-    return {
-      value,
-      memo
-    };
-  }
-}
-class ArrayIterator extends BoundedIterator {
-  static from(iterable) {
-    return iterable.length > 0 ? new this(iterable) : null;
-  }
-  static fromForEachable(object) {
-    let array = [];
-    object.forEach(item => array.push(item));
-    return this.from(array);
-  }
-  constructor(array) {
-    super(array.length);
-    this.array = array;
-  }
-  valueFor(position) {
-    return this.array[position];
-  }
-}
-class EmberArrayIterator extends BoundedIterator {
-  static from(iterable) {
-    return iterable.length > 0 ? new this(iterable) : null;
-  }
-  constructor(array) {
-    super(array.length);
-    this.array = array;
-  }
-  valueFor(position) {
-    return objectAt(this.array, position);
-  }
-}
-class ObjectIterator extends BoundedIterator {
-  static fromIndexable(obj) {
-    let keys = Object.keys(obj);
-    if (keys.length === 0) {
-      return null;
-    } else {
-      let values = [];
-      for (let key of keys) {
-        let value;
-        value = obj[key];
-
-        // Add the tag of the returned value if it is an array, since arrays
-        // should always cause updates if they are consumed and then changed
-        if (isTracking()) {
-          consumeTag(tagFor(obj, key));
-          if (Array.isArray(value)) {
-            consumeTag(tagFor(value, '[]'));
-          }
-        }
-        values.push(value);
-      }
-      return new this(keys, values);
-    }
-  }
-  static fromForEachable(obj) {
-    let keys = [];
-    let values = [];
-    let length = 0;
-    let isMapLike = false;
-
-    // Not using an arrow function here so we can get an accurate `arguments`
-    obj.forEach(function (value, key) {
-      isMapLike = isMapLike || arguments.length >= 2;
-      if (isMapLike) {
-        keys.push(key);
-      }
-      values.push(value);
-      length++;
-    });
-    if (length === 0) {
-      return null;
-    } else if (isMapLike) {
-      return new this(keys, values);
-    } else {
-      return new ArrayIterator(values);
-    }
-  }
-  constructor(keys, values) {
-    super(values.length);
-    this.keys = keys;
-    this.values = values;
-  }
-  valueFor(position) {
-    return this.values[position];
-  }
-  memoFor(position) {
-    return this.keys[position];
-  }
-}
-class NativeIterator {
-  static from(iterable) {
-    let iterator = iterable[Symbol.iterator]();
-    let result = iterator.next();
-    let {
-      done
-    } = result;
-    if (done) {
-      return null;
-    } else {
-      return new this(iterator, result);
-    }
-  }
-  position = 0;
-  constructor(iterable, result) {
-    this.iterable = iterable;
-    this.result = result;
-  }
-  isEmpty() {
-    return false;
-  }
-  next() {
-    let {
-      iterable,
-      result,
-      position
-    } = this;
-    if (result.done) {
-      return null;
-    }
-    let value = this.valueFor(result, position);
-    let memo = this.memoFor(result, position);
-    this.position++;
-    this.result = iterable.next();
-    return {
-      value,
-      memo
-    };
-  }
-}
-class ArrayLikeNativeIterator extends NativeIterator {
-  valueFor(result) {
-    return result.value;
-  }
-  memoFor(_result, position) {
-    return position;
-  }
-}
-class MapLikeNativeIterator extends NativeIterator {
-  valueFor(result) {
-    return result.value[1];
-  }
-  memoFor(result) {
-    return result.value[0];
-  }
-}
-function hasForEach(value) {
-  return value != null && typeof value['forEach'] === 'function';
-}
-function isNativeIterable(value) {
-  return value != null && typeof value[Symbol.iterator] === 'function';
-}
-function isIndexable(value) {
-  return value !== null && (typeof value === 'object' || typeof value === 'function');
-}
-
-function toBool(predicate) {
-  if (isProxy(predicate)) {
-    consumeTag(tagForProperty(predicate, 'content'));
-    return Boolean(get(predicate, 'isTruthy'));
-  } else if (isArray(predicate)) {
-    consumeTag(tagForProperty(predicate, '[]'));
-    return predicate.length !== 0;
-  } else if (isHTMLSafe(predicate)) {
-    return Boolean(predicate.toString());
-  } else {
-    return Boolean(predicate);
-  }
-}
-
-///////////
-
-// Setup global context
-
-setGlobalContext({
-  scheduleRevalidate() {
-    _backburner.ensureInstance();
-  },
-  toBool,
-  toIterator,
-  getProp: _getProp,
-  setProp: _setProp,
-  getPath: get,
-  setPath: set,
-  scheduleDestroy(destroyable, destructor) {
-    schedule('actions', null, destructor, destroyable);
-  },
-  scheduleDestroyed(finalizeDestructor) {
-    schedule('destroy', null, finalizeDestructor);
-  },
-  warnIfStyleNotTrusted(value) {
-    (warn(constructStyleDeprecationMessage(String(value)), (() => {
-      if (value === null || value === undefined || isHTMLSafe(value)) {
-        return true;
-      }
-      return false;
-    })(), {
-      id: 'ember-htmlbars.style-xss-warning'
-    }));
-  },
-  assert(test, msg, options) {
-    {
-      let id = options?.id;
-      let override = VM_ASSERTION_OVERRIDES.filter(o => o.id === id)[0];
-      (!(test) && assert(override?.message ?? msg, test));
-    }
-  },
-  deprecate(msg, test, options) {
-    {
-      let {
-        id
-      } = options;
-      if (id === 'argument-less-helper-paren-less-invocation') {
-        throw new Error(`A resolved helper cannot be passed as a named argument as the syntax is ` + `ambiguously a pass-by-reference or invocation. Use the ` + `\`{{helper 'foo-helper}}\` helper to pass by reference or explicitly ` + `invoke the helper with parens: \`{{(fooHelper)}}\`.`);
-      }
-      let override = VM_DEPRECATION_OVERRIDES.filter(o => o.id === id)[0];
-      if (!override) throw new Error(`deprecation override for ${id} not found`);
-
-      // allow deprecations to be disabled in the VM_DEPRECATION_OVERRIDES array below
-      if (!override.disabled) {
-        (!(Boolean(test)) && deprecate(override.message ?? msg, Boolean(test), override));
-      }
-    }
-  }
-});
-{
-  debug?.setTrackingTransactionEnv?.({
-    debugMessage(obj, keyName) {
-      let dirtyString = keyName ? `\`${keyName}\` on \`${getDebugName?.(obj)}\`` : `\`${getDebugName?.(obj)}\``;
-      return `You attempted to update ${dirtyString}, but it had already been used previously in the same computation.  Attempting to update a value after using it in a computation can cause logical errors, infinite revalidation bugs, and performance issues, and is not supported.`;
-    }
-  });
-}
-
-///////////
-
-// VM Assertion/Deprecation overrides
-
-const VM_DEPRECATION_OVERRIDES = [{
-  id: 'setting-on-hash',
-  until: '4.4.0',
-  for: 'ember-source',
-  since: {
-    available: '3.28.0',
-    enabled: '3.28.0'
-  }
-}];
-const VM_ASSERTION_OVERRIDES = [];
-
-///////////
-
-// Define environment delegate
-
-class EmberEnvironmentDelegate {
-  enableDebugTooling = ENV._DEBUG_RENDER_TREE;
-  constructor(owner, isInteractive) {
-    this.owner = owner;
-    this.isInteractive = isInteractive;
-  }
-  onTransactionCommit() {}
-}
-
-/**
-@module ember
-*/
-const disallowDynamicResolution = internalHelper(({
-  positional,
-  named
-}) => {
-  const nameOrValueRef = positional[0];
-  (!(positional.length === 1 && nameOrValueRef) && assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1 && nameOrValueRef));
-  let typeRef = named['type'];
-  let locRef = named['loc'];
-  let originalRef = named['original'];
-  (!(typeRef) && assert(`[BUG] expecting \`type\` named argument`, typeRef));
-  (!(locRef) && assert(`[BUG] expecting \`loc\` named argument`, locRef));
-  (!(originalRef) && assert(`[BUG] expecting \`original\` named argument`, originalRef)); // Bug: why do these fail?
-  // assert('[BUG] expecting a string literal for the `type` argument', isConstRef(typeRef));
-  // assert('[BUG] expecting a string literal for the `loc` argument', isConstRef(locRef));
-  // assert('[BUG] expecting a string literal for the `original` argument', isConstRef(originalRef));
-  const type = valueForRef(typeRef);
-  const loc = valueForRef(locRef);
-  const original = valueForRef(originalRef);
-  (!(typeof type === 'string') && assert('[BUG] expecting a string literal for the `type` argument', typeof type === 'string'));
-  (!(typeof loc === 'string') && assert('[BUG] expecting a string literal for the `loc` argument', typeof loc === 'string'));
-  (!(typeof original === 'string') && assert('[BUG] expecting a string literal for the `original` argument', typeof original === 'string'));
-  return createComputeRef(() => {
-    let nameOrValue = valueForRef(nameOrValueRef);
-    (!(typeof nameOrValue !== 'string') && assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them directly. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string'));
-    return nameOrValue;
-  });
-});
-
-let helper;
-{
-  helper = args => {
-    const inner = args.positional[0];
-    (!(inner) && assert('expected at least one positional arg', inner));
-    return createComputeRef(() => {
-      let value = valueForRef(inner);
-      (!(value !== null && value !== undefined) && assert('You cannot pass a null or undefined destination element to in-element', value !== null && value !== undefined));
-      return value;
-    });
-  };
-}
-const inElementNullCheckHelper = internalHelper(helper);
-
-const normalizeClassHelper = internalHelper(({
-  positional
-}) => {
-  return createComputeRef(() => {
-    let classNameArg = positional[0];
-    let valueArg = positional[1];
-    (!(classNameArg && valueArg) && assert('expected at least two positional args', classNameArg && valueArg));
-    let classNameParts = valueForRef(classNameArg).split('.');
-    let className = classNameParts[classNameParts.length - 1];
-    (!(className) && assert('has className', className)); // Always at least one split result
-    let value = valueForRef(valueArg);
-    if (value === true) {
-      return dasherize(className);
-    } else if (!value && value !== 0) {
-      return '';
-    } else {
-      return String(value);
-    }
-  });
-});
-
-/**
-  @module ember
-*/
-
-const resolve = internalHelper(({
-  positional
-}, owner) => {
-  // why is this allowed to be undefined in the first place?
-  (!(owner) && assert('[BUG] missing owner', owner));
-  (!(positional.length === 1) && assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1));
-  let fullNameRef = positional[0];
-  (!(fullNameRef && isConstRef(fullNameRef)) && assert('[BUG] expecting a string literal as argument', fullNameRef && isConstRef(fullNameRef)));
-  let fullName = valueForRef(fullNameRef);
-  (!(typeof fullName === 'string') && assert('[BUG] expecting a string literal as argument', typeof fullName === 'string'));
-  (!((s => s.split(':').length === 2)(fullName)) && assert('[BUG] expecting a valid full name', (s => s.split(':').length === 2)(fullName)));
-  {
-    let [type, name] = fullName.split(':');
-    (!(owner.hasRegistration(fullName)) && assert(`Attempted to invoke \`(-resolve "${fullName}")\`, but ${name} was not a valid ${type} name.`, owner.hasRegistration(fullName)));
-  }
-  return createConstRef(owner.factoryFor(fullName)?.class, `(-resolve "${fullName}")`);
-});
-
-/**
-@module ember
-*/
-
-/**
-  This reference is used to get the `[]` tag of iterables, so we can trigger
-  updates to `{{each}}` when it changes. It is put into place by a template
-  transform at build time, similar to the (-each-in) helper
-*/
-const trackArray = internalHelper(({
-  positional
-}) => {
-  const inner = positional[0];
-  (!(inner) && assert('expected at least one positional arg', inner));
-  return createComputeRef(() => {
-    let iterable = valueForRef(inner);
-    if (isObject(iterable)) {
-      consumeTag(tagForProperty(iterable, '[]'));
-    }
-    return iterable;
-  });
-});
-
-/**
-@module ember
-*/
-
-/**
-  The `mut` helper lets you __clearly specify__ that a child `Component` can update the
-  (mutable) value passed to it, which will __change the value of the parent component__.
-
-  To specify that a parameter is mutable, when invoking the child `Component`:
-
-  ```handlebars
-  <MyChild @childClickCount={{fn (mut totalClicks)}} />
-  ```
-
-   or
-
-  ```handlebars
-  {{my-child childClickCount=(mut totalClicks)}}
-  ```
-
-  The child `Component` can then modify the parent's value just by modifying its own
-  property:
-
-  ```javascript
-  // my-child.js
-  export default class MyChild extends Component {
-    click() {
-      this.incrementProperty('childClickCount');
-    }
-  }
-  ```
-
-  Note that for curly components (`{{my-component}}`) the bindings are already mutable,
-  making the `mut` unnecessary.
-
-  Additionally, the `mut` helper can be combined with the `fn` helper to
-  mutate a value. For example:
-
-  ```handlebars
-  <MyChild @childClickCount={{this.totalClicks}} @click-count-change={{fn (mut totalClicks))}} />
-  ```
-
-  or
-
-  ```handlebars
-  {{my-child childClickCount=totalClicks click-count-change=(fn (mut totalClicks))}}
-  ```
-
-  The child `Component` would invoke the function with the new click value:
-
-  ```javascript
-  // my-child.js
-  export default class MyChild extends Component {
-    click() {
-      this.get('click-count-change')(this.get('childClickCount') + 1);
-    }
-  }
-  ```
-
-  The `mut` helper changes the `totalClicks` value to what was provided as the `fn` argument.
-
-  The `mut` helper, when used with `fn`, will return a function that
-  sets the value passed to `mut` to its first argument. As an example, we can create a
-  button that increments a value passing the value directly to the `fn`:
-
-  ```handlebars
-  {{! inc helper is not provided by Ember }}
-  <button onclick={{fn (mut count) (inc count)}}>
-    Increment count
-  </button>
-  ```
-
-  @method mut
-  @param {Object} [attr] the "two-way" attribute that can be modified.
-  @for Ember.Templates.helpers
-  @public
-*/
-
-const mut = internalHelper(({
-  positional
-}) => {
-  let ref = positional[0];
-  (!(ref) && assert('expected at least one positional arg', ref)); // TODO: Improve this error message. This covers at least two distinct
-  // cases:
-  //
-  // 1. (mut "not a path") – passing a literal, result from a helper
-  //    invocation, etc
-  //
-  // 2. (mut receivedValue) – passing a value received from the caller
-  //    that was originally derived from a literal, result from a helper
-  //    invocation, etc
-  //
-  // This message is alright for the first case, but could be quite
-  // confusing for the second case.
-  (!(isUpdatableRef(ref)) && assert('You can only pass a path to mut', isUpdatableRef(ref)));
-  return createInvokableRef(ref);
-});
-
-/**
-@module ember
-*/
-
-
-/**
-  The `readonly` helper let's you specify that a binding is one-way only,
-  instead of two-way.
-  When you pass a `readonly` binding from an outer context (e.g. parent component),
-  to to an inner context (e.g. child component), you are saying that changing that
-  property in the inner context does not change the value in the outer context.
-
-  To specify that a binding is read-only, when invoking the child `Component`:
-
-  ```app/components/my-parent.js
-  export default class MyParent extends Component {
-    totalClicks = 3;
-  }
-  ```
-
-  ```app/templates/components/my-parent.hbs
-  {{log totalClicks}} // -> 3
-  <MyChild @childClickCount={{readonly totalClicks}} />
-  ```
-  ```
-  {{my-child childClickCount=(readonly totalClicks)}}
-  ```
-
-  Now, when you update `childClickCount`:
-
-  ```app/components/my-child.js
-  export default class MyChild extends Component {
-    click() {
-      this.incrementProperty('childClickCount');
-    }
+  ```
+
+  Now, when you update `childClickCount`:
+
+  ```app/components/my-child.js
+  export default class MyChild extends Component {
+    click() {
+      this.incrementProperty('childClickCount');
+    }
   }
   ```
 
@@ -1077,516 +516,51 @@ const mut = internalHelper(({
 const readonly = internalHelper(({
   positional
 }) => {
-  let firstArg = positional[0];
-  (!(firstArg) && assert('has first arg', firstArg));
-  return createReadOnlyRef(firstArg);
-});
-
-/**
-@module ember
-*/
-
-
-/**
-  The `{{unbound}}` helper disconnects the one-way binding of a property,
-  essentially freezing its value at the moment of rendering. For example,
-  in this example the display of the variable `name` will not change even
-  if it is set with a new value:
-
-  ```handlebars
-  {{unbound this.name}}
-  ```
-
-  Like any helper, the `unbound` helper can accept a nested helper expression.
-  This allows for custom helpers to be rendered unbound:
-
-  ```handlebars
-  {{unbound (some-custom-helper)}}
-  {{unbound (capitalize this.name)}}
-  {{! You can use any helper, including unbound, in a nested expression }}
-  {{capitalize (unbound this.name)}}
-  ```
-
-  The `unbound` helper only accepts a single argument, and it return an
-  unbound value.
-
-  @method unbound
-  @for Ember.Templates.helpers
-  @public
-*/
-
-const unbound = internalHelper(({
-  positional,
-  named
-}) => {
-  (!(positional.length === 1 && Object.keys(named).length === 0) && assert('unbound helper cannot be called with multiple params or hash params', positional.length === 1 && Object.keys(named).length === 0));
-  return createUnboundRef(valueForRef(positional[0]), '(result of an `unbound` helper)');
-});
-
-const CAPABILITIES$1 = {
-  dynamicLayout: true,
-  dynamicTag: false,
-  prepareArgs: false,
-  createArgs: true,
-  attributeHook: false,
-  elementHook: false,
-  createCaller: true,
-  dynamicScope: true,
-  updateHook: true,
-  createInstance: true,
-  wrapped: false,
-  willDestroy: false,
-  hasSubOwner: true
-};
-class MountManager {
-  getDynamicLayout(state) {
-    let templateFactory = state.engine.lookup('template:application');
-    return unwrapTemplate(templateFactory(state.engine)).asLayout();
-  }
-  getCapabilities() {
-    return CAPABILITIES$1;
-  }
-  getOwner(state) {
-    return state.engine;
-  }
-  create(owner, {
-    name
-  }, args, env) {
-    // TODO
-    // mount is a runtime helper, this shouldn't use dynamic layout
-    // we should resolve the engine app template in the helper
-    // it also should use the owner that looked up the mount helper.
-    (!(owner instanceof EngineInstance) && assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance));
-    let engine = owner.buildChildEngineInstance(name);
-    engine.boot();
-    let applicationFactory = engine.factoryFor(`controller:application`);
-    let controllerFactory = applicationFactory || generateControllerFactory(engine, 'application');
-    let controller;
-    let self;
-    let bucket;
-    let modelRef;
-    if (args.named.has('model')) {
-      modelRef = args.named.get('model');
-    }
-    if (modelRef === undefined) {
-      controller = controllerFactory.create();
-      self = createConstRef(controller, 'this');
-      bucket = {
-        engine,
-        controller,
-        self,
-        modelRef
-      };
-    } else {
-      let model = valueForRef(modelRef);
-      controller = controllerFactory.create({
-        model
-      });
-      self = createConstRef(controller, 'this');
-      bucket = {
-        engine,
-        controller,
-        self,
-        modelRef
-      };
-    }
-    if (env.debugRenderTree) {
-      associateDestroyableChild(engine, controller);
-    }
-    return bucket;
-  }
-  getDebugName({
-    name
-  }) {
-    return name;
-  }
-  getDebugCustomRenderTree(definition, state, args) {
-    return [{
-      bucket: state.engine,
-      instance: state.engine,
-      type: 'engine',
-      name: definition.name,
-      args
-    }, {
-      bucket: state.controller,
-      instance: state.controller,
-      type: 'route-template',
-      name: 'application',
-      args
-    }];
-  }
-  getSelf({
-    self
-  }) {
-    return self;
-  }
-  getDestroyable(bucket) {
-    return bucket.engine;
-  }
-  didCreate() {}
-  didUpdate() {}
-  didRenderLayout() {}
-  didUpdateLayout() {}
-  update(bucket) {
-    let {
-      controller,
-      modelRef
-    } = bucket;
-    if (modelRef !== undefined) {
-      controller.set('model', valueForRef(modelRef));
-    }
-  }
-}
-const MOUNT_MANAGER = new MountManager();
-class MountDefinition {
-  // handle is not used by this custom definition
-  handle = -1;
-  state;
-  manager = MOUNT_MANAGER;
-  compilable = null;
-  capabilities = capabilityFlagsFrom(CAPABILITIES$1);
-  constructor(resolvedName) {
-    this.resolvedName = resolvedName;
-    this.state = {
-      name: resolvedName
-    };
-  }
-}
-
-/**
-@module ember
-*/
-
-
-/**
-  The `{{mount}}` helper lets you embed a routeless engine in a template.
-  Mounting an engine will cause an instance to be booted and its `application`
-  template to be rendered.
-
-  For example, the following template mounts the `ember-chat` engine:
-
-  ```handlebars
-  {{! application.hbs }}
-  {{mount "ember-chat"}}
-  ```
-
-  Additionally, you can also pass in a `model` argument that will be
-  set as the engines model. This can be an existing object:
-
-  ```
-  <div>
-    {{mount 'admin' model=userSettings}}
-  </div>
-  ```
-
-  Or an inline `hash`, and you can even pass components:
-
-  ```
-  <div>
-    <h1>Application template!</h1>
-    {{mount 'admin' model=(hash
-        title='Secret Admin'
-        signInButton=(component 'sign-in-button')
-    )}}
-  </div>
-  ```
-
-  @method mount
-  @param {String} name Name of the engine to mount.
-  @param {Object} [model] Object that will be set as
-                          the model of the engine.
-  @for Ember.Templates.helpers
-  @public
-*/
-const mountHelper = internalHelper((args, owner) => {
-  (!(owner) && assert('{{mount}} must be used within a component that has an owner', owner));
-  let nameRef = args.positional[0];
-  let captured;
-  (!(args.positional.length === 1) && assert('You can only pass a single positional argument to the {{mount}} helper, e.g. {{mount "chat-engine"}}.', args.positional.length === 1));
-  if (args.named) {
-    let keys = Object.keys(args.named);
-    let extra = keys.filter(k => k !== 'model');
-    (!(extra.length === 0) && assert('You can only pass a `model` argument to the {{mount}} helper, ' + 'e.g. {{mount "profile-engine" model=this.profile}}. ' + `You passed ${extra.join(',')}.`, extra.length === 0));
-  }
-  captured = createCapturedArgs(args.named, EMPTY_POSITIONAL);
-  let lastName, lastDef;
-  return createComputeRef(() => {
-    let name = valueForRef(nameRef);
-    if (typeof name === 'string') {
-      if (lastName === name) {
-        return lastDef;
-      }
-      (!(owner.hasRegistration(`engine:${name}`)) && assert(`You used \`{{mount '${name}'}}\`, but the engine '${name}' can not be found.`, owner.hasRegistration(`engine:${name}`)));
-      lastName = name;
-      lastDef = curry(0, new MountDefinition(name), owner, captured, true);
-      return lastDef;
-    } else {
-      (!(name === null || name === undefined) && assert(`Invalid engine name '${name}' specified, engine name must be either a string, null or undefined.`, name === null || name === undefined));
-      lastDef = null;
-      lastName = null;
-      return null;
-    }
-  });
-});
-
-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');
-    {
-      self = createDebugAliasRef('this', self);
-    }
-    let controller = valueForRef(self);
-    return {
-      self,
-      controller
-    };
-  }
-  getSelf({
-    self
-  }) {
-    return self;
-  }
-  getDebugName({
-    name
-  }) {
-    return `route-template (${name})`;
-  }
-  getDebugCustomRenderTree({
-    name
-  }, state, args) {
-    return [{
-      bucket: state,
-      type: 'route-template',
-      name,
-      args,
-      instance: state.controller
-    }];
-  }
-  getCapabilities() {
-    return CAPABILITIES;
-  }
-  didRenderLayout() {}
-  didUpdateLayout() {}
-  didCreate() {}
-  didUpdate() {}
-  getDestroyable() {
-    return null;
-  }
-}
-const ROUTE_TEMPLATE_MANAGER = new RouteTemplateManager();
+  let firstArg = positional[0];
+  (!(firstArg) && assert('has first arg', firstArg));
+  return createReadOnlyRef(firstArg);
+});
 
 /**
- * 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
-    };
-    this.compilable = unwrapped.asLayout();
-  }
-}
+@module ember
+*/
 
-// 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(0, 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
-  application's `application.hbs` file:
+  The `{{unbound}}` helper disconnects the one-way binding of a property,
+  essentially freezing its value at the moment of rendering. For example,
+  in this example the display of the variable `name` will not change even
+  if it is set with a new value:
 
-  ```app/templates/application.hbs
-  <MyHeader />
+  ```handlebars
+  {{unbound this.name}}
+  ```
 
-  <div class="my-dynamic-content">
-    <!-- this content will change based on the current route, which depends on the current URL -->
-    {{outlet}}
-  </div>
+  Like any helper, the `unbound` helper can accept a nested helper expression.
+  This allows for custom helpers to be rendered unbound:
 
-  <MyFooter />
+  ```handlebars
+  {{unbound (some-custom-helper)}}
+  {{unbound (capitalize this.name)}}
+  {{! You can use any helper, including unbound, in a nested expression }}
+  {{capitalize (unbound this.name)}}
   ```
 
-  See the [routing guide](https://guides.emberjs.com/release/routing/rendering-a-template/) for more
-  information on how your `route` interacts with the `{{outlet}}` helper.
-  Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
+  The `unbound` helper only accepts a single argument, and it return an
+  unbound value.
 
-  @method outlet
+  @method unbound
   @for Ember.Templates.helpers
   @public
 */
-const outletHelper = internalHelper((_args, owner, scope) => {
-  (!(owner) && assert('Expected owner to be present, {{outlet}} requires an owner', owner));
-  (!(scope) && assert('Expected dynamic scope to be present. You may have attempted to use the {{outlet}} keyword dynamically. This keyword cannot be used dynamically.', scope));
-  let outletRef = createComputeRef(() => {
-    let state = valueForRef(scope.get('outletState'));
-    return state?.outlets?.main;
-  });
-  let lastState = null;
-  let outlet = null;
-  return createComputeRef(() => {
-    let outletState = valueForRef(outletRef);
-    let state = stateFor(outletRef, outletState);
-
-    // 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 {
-          {
-            // 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';
-              }
-              (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']);
-
-        // 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;
-        });
-        {
-          named['model'] = createDebugAliasRef('@model', named['model']);
-        }
-        let args = createCapturedArgs(named, EMPTY_POSITIONAL);
 
-        // Package up everything
-        outlet = curry(0, new OutletComponent(owner, state), outletOwner, args, true);
-      } else {
-        outlet = null;
-      }
-    }
-    return outlet;
-  });
+const unbound = internalHelper(({
+  positional,
+  named
+}) => {
+  (!(positional.length === 1 && Object.keys(named).length === 0) && assert('unbound helper cannot be called with multiple params or hash params', positional.length === 1 && Object.keys(named).length === 0));
+  return createUnboundRef(valueForRef(positional[0]), '(result of an `unbound` helper)');
 });
-function stateFor(ref, outlet) {
-  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;
-  return {
-    ref,
-    name: render.name,
-    template,
-    controller: render.controller
-  };
-}
-function isStable(state, lastState) {
-  if (state === null || lastState === null) {
-    return false;
-  }
-  return state.template === lastState.template && state.controller === lastState.controller;
-}
 
 function instrumentationPayload(name) {
   return {
@@ -1626,8 +600,6 @@ const BUILTIN_KEYWORD_HELPERS = {
   '-normalize-class': normalizeClassHelper,
   '-resolve': resolve,
   '-track-array': trackArray,
-  '-mount': mountHelper,
-  '-outlet': outletHelper,
   '-in-el-null': inElementNullCheckHelper
 };
 const BUILTIN_HELPERS = {
@@ -1635,13 +607,19 @@ const BUILTIN_HELPERS = {
   array,
   concat,
   fn,
-  get: get$1,
+  get,
   hash,
-  'unique-id': uniqueId
+  'unique-id': uniqueId,
+  // In prod builds, this is a no-op helper and is unused in practice. We shouldn't need
+  // to add it at all, but the current test build doesn't produce a "prod compiler", so
+  // we ended up running the debug-build for the template compliler in prod tests. Once
+  // that is fixed, this can be conditionally included only in DEBUG. For now, this
+  // allows the test to work and does not really harm anything, since it's just a no-op
+  // pass-through helper. Keeping it inside the object literal (rather than a top-level
+  // conditional assignment) keeps this module free of top-level side effects so that
+  // consumers that never resolve anything dynamically can tree-shake the whole table.
+  '-disallow-dynamic-resolution': disallowDynamicResolution
 };
-{
-  BUILTIN_HELPERS['-disallow-dynamic-resolution'] = disallowDynamicResolution;
-}
 
 // With the implementation of RFC #1006(https://rfcs.emberjs.com/id/1006-deprecate-action-template-helper), the `action` modifer was removed. It was the
 // only built-in keyword modifier, so this object is currently empty.
@@ -1675,12 +653,17 @@ class ResolverImpl {
       // than the raw value (`factoryFor(...).class`). This is because injections are already
       // bound in the factoryFor result, including type-based injections
 
+      // The classic helper manager is registered on the classic `Helper` base
+      // class; deriving it from the definition (rather than importing it from
+      // the module that defines `Helper`) keeps this module from pulling in
+      // the classic object model when no classic helpers are in use.
+      let manager = getInternalHelperManager(definition);
       {
         // In DEBUG we need to only set the associated value once, otherwise
         // we'll trigger an assertion
         if (!CLASSIC_HELPER_MANAGER_ASSOCIATED.has(factory)) {
           CLASSIC_HELPER_MANAGER_ASSOCIATED.add(factory);
-          setInternalHelperManager(CLASSIC_HELPER_MANAGER, factory);
+          setInternalHelperManager(manager, factory);
         }
       }
       return factory;
@@ -1688,6 +671,7 @@ class ResolverImpl {
     return definition;
   }
   lookupBuiltInHelper(name) {
+    (!(name !== '-outlet' && name !== '-mount') && assert(`The \`{{${name.slice(1)}}}\` keyword requires the router, which is not available here. ` + `It is only supported in templates rendered by an Ember application (e.g. not via \`renderComponent\`).`, name !== '-outlet' && name !== '-mount'));
     return BUILTIN_KEYWORD_HELPERS[name] ?? null;
   }
   lookupModifier(name, owner) {
@@ -1704,159 +688,377 @@ class ResolverImpl {
   lookupBuiltInModifier(name) {
     return BUILTIN_KEYWORD_MODIFIERS[name] ?? null;
   }
-  lookupComponent(name, owner) {
-    let pair = lookupComponentPair(owner, name);
-    if (pair === null) {
-      (!(name !== 'text-area') && assert('Could not find component `<TextArea />` (did you mean `<Textarea />`?)', name !== 'text-area'));
+  lookupComponent(name, owner) {
+    let pair = lookupComponentPair(owner, name);
+    if (pair === null) {
+      (!(name !== 'text-area') && assert('Could not find component `<TextArea />` (did you mean `<Textarea />`?)', name !== 'text-area'));
+      return null;
+    }
+    let template = null;
+    let key;
+    if (pair.component === null) {
+      key = template = pair.layout(owner);
+    } else {
+      key = pair.component;
+    }
+    let cachedComponentDefinition = this.componentDefinitionCache.get(key);
+    if (cachedComponentDefinition !== undefined) {
+      return cachedComponentDefinition;
+    }
+    if (template === null && pair.layout !== null) {
+      template = pair.layout(owner);
+    }
+    let finalizer = _instrumentStart('render.getComponentDefinition', instrumentationPayload, name);
+    let definition = null;
+    if (pair.component === null) {
+      definition = {
+        state: templateOnlyComponent(undefined, name),
+        manager: TEMPLATE_ONLY_COMPONENT_MANAGER,
+        template
+      };
+    } else {
+      let factory = pair.component;
+      (!(factory.class !== undefined) && assert(`missing component class ${name}`, factory.class !== undefined));
+      let ComponentClass = factory.class;
+      let manager = getInternalComponentManager(ComponentClass);
+      definition = {
+        state: isCurlyManager(manager) ? factory : ComponentClass,
+        manager,
+        template
+      };
+    }
+    finalizer();
+    this.componentDefinitionCache.set(key, definition);
+    (!(!(definition === null && name === 'text-area')) && assert('Could not find component `<TextArea />` (did you mean `<Textarea />`?)', !(definition === null && name === 'text-area')));
+    return definition;
+  }
+}
+
+function toIterator(iterable) {
+  if (iterable instanceof EachInWrapper) {
+    return toEachInIterator(iterable.inner);
+  } else {
+    return toEachIterator(iterable);
+  }
+}
+function toEachInIterator(iterable) {
+  if (!isIndexable(iterable)) {
+    return null;
+  }
+  if (Array.isArray(iterable) || isEmberArray(iterable)) {
+    return ObjectIterator.fromIndexable(iterable);
+  } else if (isNativeIterable(iterable)) {
+    return MapLikeNativeIterator.from(iterable);
+  } else if (hasForEach(iterable)) {
+    return ObjectIterator.fromForEachable(iterable);
+  } else {
+    return ObjectIterator.fromIndexable(iterable);
+  }
+}
+function toEachIterator(iterable) {
+  if (!isObject(iterable)) {
+    return null;
+  }
+  if (Array.isArray(iterable)) {
+    return ArrayIterator.from(iterable);
+  } else if (isEmberArray(iterable)) {
+    return EmberArrayIterator.from(iterable);
+  } else if (isNativeIterable(iterable)) {
+    return ArrayLikeNativeIterator.from(iterable);
+  } else if (hasForEach(iterable)) {
+    return ArrayIterator.fromForEachable(iterable);
+  } else {
+    return null;
+  }
+}
+class BoundedIterator {
+  position = 0;
+  constructor(length) {
+    this.length = length;
+  }
+  isEmpty() {
+    return false;
+  }
+  memoFor(position) {
+    return position;
+  }
+  next() {
+    let {
+      length,
+      position
+    } = this;
+    if (position >= length) {
+      return null;
+    }
+    let value = this.valueFor(position);
+    let memo = this.memoFor(position);
+    this.position++;
+    return {
+      value,
+      memo
+    };
+  }
+}
+class ArrayIterator extends BoundedIterator {
+  static from(iterable) {
+    return iterable.length > 0 ? new this(iterable) : null;
+  }
+  static fromForEachable(object) {
+    let array = [];
+    object.forEach(item => array.push(item));
+    return this.from(array);
+  }
+  constructor(array) {
+    super(array.length);
+    this.array = array;
+  }
+  valueFor(position) {
+    return this.array[position];
+  }
+}
+class EmberArrayIterator extends BoundedIterator {
+  static from(iterable) {
+    return iterable.length > 0 ? new this(iterable) : null;
+  }
+  constructor(array) {
+    super(array.length);
+    this.array = array;
+  }
+  valueFor(position) {
+    return objectAt(this.array, position);
+  }
+}
+class ObjectIterator extends BoundedIterator {
+  static fromIndexable(obj) {
+    let keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return null;
+    } else {
+      let values = [];
+      for (let key of keys) {
+        let value;
+        value = obj[key];
+
+        // Add the tag of the returned value if it is an array, since arrays
+        // should always cause updates if they are consumed and then changed
+        if (isTracking()) {
+          consumeTag(tagFor(obj, key));
+          if (Array.isArray(value)) {
+            consumeTag(tagFor(value, '[]'));
+          }
+        }
+        values.push(value);
+      }
+      return new this(keys, values);
+    }
+  }
+  static fromForEachable(obj) {
+    let keys = [];
+    let values = [];
+    let length = 0;
+    let isMapLike = false;
+
+    // Not using an arrow function here so we can get an accurate `arguments`
+    obj.forEach(function (value, key) {
+      isMapLike = isMapLike || arguments.length >= 2;
+      if (isMapLike) {
+        keys.push(key);
+      }
+      values.push(value);
+      length++;
+    });
+    if (length === 0) {
+      return null;
+    } else if (isMapLike) {
+      return new this(keys, values);
+    } else {
+      return new ArrayIterator(values);
+    }
+  }
+  constructor(keys, values) {
+    super(values.length);
+    this.keys = keys;
+    this.values = values;
+  }
+  valueFor(position) {
+    return this.values[position];
+  }
+  memoFor(position) {
+    return this.keys[position];
+  }
+}
+class NativeIterator {
+  static from(iterable) {
+    let iterator = iterable[Symbol.iterator]();
+    let result = iterator.next();
+    let {
+      done
+    } = result;
+    if (done) {
       return null;
-    }
-    let template = null;
-    let key;
-    if (pair.component === null) {
-      key = template = pair.layout(owner);
-    } else {
-      key = pair.component;
-    }
-    let cachedComponentDefinition = this.componentDefinitionCache.get(key);
-    if (cachedComponentDefinition !== undefined) {
-      return cachedComponentDefinition;
-    }
-    if (template === null && pair.layout !== null) {
-      template = pair.layout(owner);
-    }
-    let finalizer = _instrumentStart('render.getComponentDefinition', instrumentationPayload, name);
-    let definition = null;
-    if (pair.component === null) {
-      definition = {
-        state: templateOnlyComponent(undefined, name),
-        manager: TEMPLATE_ONLY_COMPONENT_MANAGER,
-        template
-      };
     } else {
-      let factory = pair.component;
-      (!(factory.class !== undefined) && assert(`missing component class ${name}`, factory.class !== undefined));
-      let ComponentClass = factory.class;
-      let manager = getInternalComponentManager(ComponentClass);
-      definition = {
-        state: isCurlyManager(manager) ? factory : ComponentClass,
-        manager,
-        template
-      };
+      return new this(iterator, result);
     }
-    finalizer();
-    this.componentDefinitionCache.set(key, definition);
-    (!(!(definition === null && name === 'text-area')) && assert('Could not find component `<TextArea />` (did you mean `<Textarea />`?)', !(definition === null && name === 'text-area')));
-    return definition;
   }
-}
-
-// We use the `InternalOwner` notion here because we actually need all of its
-// API for using with renderers (normally, it will be `EngineInstance`).
-// We use `getOwner` from our internal home for it rather than the narrower
-// public API for the same reason.
-const TOP_LEVEL_NAME = '-top-level';
-class OutletView {
-  static extend(injections) {
-    return class extends OutletView {
-      static create(options) {
-        if (options) {
-          return super.create(Object.assign({}, injections, options));
-        } else {
-          return super.create(injections);
-        }
-      }
-    };
+  position = 0;
+  constructor(iterable, result) {
+    this.iterable = iterable;
+    this.result = result;
   }
-  static reopenClass(injections) {
-    Object.assign(this, injections);
+  isEmpty() {
+    return false;
   }
-  static create(options) {
+  next() {
     let {
-      environment: _environment,
-      application: namespace,
-      template: templateFactory
-    } = options;
-    let owner = getOwner(options);
-    (!(owner) && assert('OutletView is unexpectedly missing an owner', owner));
-    let template = templateFactory(owner);
-    return new OutletView(_environment, owner, template, namespace);
-  }
-  ref;
-  state;
-  constructor(_environment, owner, template, namespace) {
-    this._environment = _environment;
-    this.owner = owner;
-    this.template = template;
-    this.namespace = namespace;
-    let outletStateTag = createTag();
-    let outletState = {
-      outlets: {
-        main: undefined
-      },
-      render: {
-        owner: owner,
-        name: TOP_LEVEL_NAME,
-        controller: undefined,
-        model: undefined,
-        template
-      }
-    };
-    let ref = this.ref = createComputeRef(() => {
-      consumeTag(outletStateTag);
-      return outletState;
-    }, state => {
-      DIRTY_TAG$1(outletStateTag);
-      outletState.outlets['main'] = state;
-    });
-    this.state = {
-      ref,
-      name: TOP_LEVEL_NAME,
-      template,
-      controller: undefined
+      iterable,
+      result,
+      position
+    } = this;
+    if (result.done) {
+      return null;
+    }
+    let value = this.valueFor(result, position);
+    let memo = this.memoFor(result, position);
+    this.position++;
+    this.result = iterable.next();
+    return {
+      value,
+      memo
     };
   }
-  appendTo(selector) {
-    let target;
-    if (this._environment.hasDOM) {
-      target = typeof selector === 'string' ? document.querySelector(selector) : selector;
-    } else {
-      target = selector;
-    }
-    let renderer = this.owner.lookup('renderer:-dom');
-
-    // SAFETY: It's not clear that this cast is safe.
-    // The types for appendOutletView may be incorrect or this is a potential bug.
-    schedule('render', renderer, 'appendOutletView', this, target);
+}
+class ArrayLikeNativeIterator extends NativeIterator {
+  valueFor(result) {
+    return result.value;
   }
-  rerender() {
-    /**/
+  memoFor(_result, position) {
+    return position;
   }
-  setOutletState(state) {
-    updateRef(this.ref, state);
+}
+class MapLikeNativeIterator extends NativeIterator {
+  valueFor(result) {
+    return result.value[1];
   }
-  destroy() {
-    /**/
+  memoFor(result) {
+    return result.value[0];
   }
 }
+function hasForEach(value) {
+  return value != null && typeof value['forEach'] === 'function';
+}
+function isNativeIterable(value) {
+  return value != null && typeof value[Symbol.iterator] === 'function';
+}
+function isIndexable(value) {
+  return value !== null && (typeof value === 'object' || typeof value === 'function');
+}
 
-class DynamicScope {
-  constructor(view, outletState) {
-    this.view = view;
-    this.outletState = outletState;
+function toBool(predicate) {
+  if (isProxy(predicate)) {
+    consumeTag(tagForProperty(predicate, 'content'));
+    return Boolean(get$1(predicate, 'isTruthy'));
+  } else if (isArray(predicate)) {
+    consumeTag(tagForProperty(predicate, '[]'));
+    return predicate.length !== 0;
+  } else if (isHTMLSafe(predicate)) {
+    return Boolean(predicate.toString());
+  } else {
+    return Boolean(predicate);
   }
-  child() {
-    return new DynamicScope(this.view, this.outletState);
+}
+
+///////////
+
+// Setup global context
+
+setGlobalContext({
+  scheduleRevalidate() {
+    _backburner.ensureInstance();
+  },
+  toBool,
+  toIterator,
+  getProp: _getProp,
+  setProp: _setProp,
+  getPath: get$1,
+  setPath: set,
+  scheduleDestroy(destroyable, destructor) {
+    schedule('actions', null, destructor, destroyable);
+  },
+  scheduleDestroyed(finalizeDestructor) {
+    schedule('destroy', null, finalizeDestructor);
+  },
+  warnIfStyleNotTrusted(value) {
+    (warn(constructStyleDeprecationMessage(String(value)), (() => {
+      if (value === null || value === undefined || isHTMLSafe(value)) {
+        return true;
+      }
+      return false;
+    })(), {
+      id: 'ember-htmlbars.style-xss-warning'
+    }));
+  },
+  assert(test, msg, options) {
+    {
+      let id = options?.id;
+      let override = VM_ASSERTION_OVERRIDES.filter(o => o.id === id)[0];
+      (!(test) && assert(override?.message ?? msg, test));
+    }
+  },
+  deprecate(msg, test, options) {
+    {
+      let {
+        id
+      } = options;
+      if (id === 'argument-less-helper-paren-less-invocation') {
+        throw new Error(`A resolved helper cannot be passed as a named argument as the syntax is ` + `ambiguously a pass-by-reference or invocation. Use the ` + `\`{{helper 'foo-helper}}\` helper to pass by reference or explicitly ` + `invoke the helper with parens: \`{{(fooHelper)}}\`.`);
+      }
+      let override = VM_DEPRECATION_OVERRIDES.filter(o => o.id === id)[0];
+      if (!override) throw new Error(`deprecation override for ${id} not found`);
+
+      // allow deprecations to be disabled in the VM_DEPRECATION_OVERRIDES array below
+      if (!override.disabled) {
+        (!(Boolean(test)) && deprecate(override.message ?? msg, Boolean(test), override));
+      }
+    }
   }
-  get(key) {
-    (!(key === 'outletState') && assert(`Using \`-get-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`, key === 'outletState'));
-    return this.outletState;
+});
+{
+  debug?.setTrackingTransactionEnv?.({
+    debugMessage(obj, keyName) {
+      let dirtyString = keyName ? `\`${keyName}\` on \`${getDebugName?.(obj)}\`` : `\`${getDebugName?.(obj)}\``;
+      return `You attempted to update ${dirtyString}, but it had already been used previously in the same computation.  Attempting to update a value after using it in a computation can cause logical errors, infinite revalidation bugs, and performance issues, and is not supported.`;
+    }
+  });
+}
+
+///////////
+
+// VM Assertion/Deprecation overrides
+
+const VM_DEPRECATION_OVERRIDES = [{
+  id: 'setting-on-hash',
+  until: '4.4.0',
+  for: 'ember-source',
+  since: {
+    available: '3.28.0',
+    enabled: '3.28.0'
   }
-  set(key, value) {
-    (!(key === 'outletState') && assert(`Using \`-with-dynamic-scope\` is only supported for \`outletState\` (you used \`${key}\`).`, key === 'outletState'));
-    this.outletState = value;
-    return value;
+}];
+const VM_ASSERTION_OVERRIDES = [];
+
+///////////
+
+// Define environment delegate
+
+class EmberEnvironmentDelegate {
+  enableDebugTooling = ENV._DEBUG_RENDER_TREE;
+  constructor(owner, isInteractive) {
+    this.owner = owner;
+    this.isInteractive = isInteractive;
   }
+  onTransactionCommit() {}
 }
+
 const NO_OP = () => {};
 
 // This wrapper logic prevents us from rerendering in case of a hard failure
@@ -1882,6 +1084,13 @@ function errorLoopTransaction(fn) {
     };
   }
 }
+
+/**
+ * The interface the `RendererState` needs from a render root. The base
+ * renderer only ever creates `ComponentRootState`s; the classic renderer
+ * (`./renderer`) adds `ClassicRootState` for outlet/classic-component roots.
+ */
+
 class ComponentRootState {
   type = 'component';
   #result;
@@ -1899,7 +1108,7 @@ class ComponentRootState {
       });
     });
   }
-  isFor(_component) {
+  isFor(_possibleRoot) {
     return false;
   }
   render() {
@@ -1915,62 +1124,6 @@ class ComponentRootState {
     return this.#result;
   }
 }
-class ClassicRootState {
-  type = 'classic';
-  id;
-  result;
-  destroyed;
-  render;
-  env;
-  constructor(root, context, owner, template, self, parentElement, dynamicScope, builder) {
-    this.root = root;
-    (!(template !== undefined) && assert(`You cannot render \`${valueForRef(self)}\` without a template.`, template !== undefined));
-    this.id = root instanceof OutletView ? guidFor(root) : getViewId(root);
-    this.result = undefined;
-    this.destroyed = false;
-    this.env = context.env;
-    this.render = errorLoopTransaction(() => {
-      let layout = unwrapTemplate(template).asLayout();
-      let iterator = renderMain(context, owner, self, builder(context.env, {
-        element: parentElement,
-        nextSibling: null
-      }), layout, dynamicScope);
-      let result = this.result = iterator.sync();
-      associateDestroyableChild(this, result);
-      this.render = errorLoopTransaction(() => {
-        if (isDestroying(result) || isDestroyed(result)) return;
-        return result.rerender({
-          alwaysRevalidate: false
-        });
-      });
-    });
-  }
-  isFor(possibleRoot) {
-    return this.root === possibleRoot;
-  }
-  destroy() {
-    let {
-      result,
-      env
-    } = this;
-    this.destroyed = true;
-    this.root = null;
-    this.result = undefined;
-    this.render = undefined;
-    if (result !== undefined) {
-      /*
-       Handles these scenarios:
-        * When roots are removed during standard rendering process, a transaction exists already
-         `.begin()` / `.commit()` are not needed.
-       * When roots are being destroyed manually (`component.append(); component.destroy() case), no
-         transaction exists already.
-       * When roots are being destroyed during `Renderer#destroy`, no transaction exists
-        */
-
-      inTransaction(env, () => destroy(result));
-    }
-  }
-}
 const renderers = [];
 function _resetRenderers() {
   renderers.length = 0;
@@ -2001,7 +1154,12 @@ let renderSettledDeferred = null;
 */
 function renderSettled() {
   if (renderSettledDeferred === null) {
-    renderSettledDeferred = RSVP.defer();
+    let resolve;
+    let promise = new Promise(r => resolve = r);
+    renderSettledDeferred = {
+      promise,
+      resolve
+    };
     // if there is no current runloop, the promise created above will not have
     // a chance to resolve (because its resolved in backburner's "end" event)
     if (!_getCurrentRunLoop()) {
@@ -2359,142 +1517,6 @@ class BaseRenderer {
   rerender() {
     this.state.scheduleRevalidate(this);
   }
-
-  // render(component: Component, options: { into: Cursor; args?: Record<string, unknown> }): void {
-  //   this.state.renderRoot(component);
-  // }
-}
-class Renderer extends BaseRenderer {
-  static strict(owner, document, options) {
-    return new BaseRenderer(owner, {
-      hasDOM: hasDOM,
-      ...options
-    }, document, new ResolverImpl(), clientBuilder);
-  }
-  _rootTemplate;
-  _viewRegistry;
-  static create(props) {
-    let {
-      _viewRegistry
-    } = props;
-    let owner = getOwner(props);
-    (!(owner) && assert('Renderer is unexpectedly missing an owner', owner));
-    let document = owner.lookup('service:-document');
-    let env = owner.lookup('-environment:main');
-    let rootTemplate = owner.lookup(privatize`template:-root`);
-    let builder = owner.lookup('service:-dom-builder');
-    return new this(owner, document, env, rootTemplate, _viewRegistry, builder);
-  }
-  constructor(owner, document, env, rootTemplate, viewRegistry, builder = clientBuilder, resolver = new ResolverImpl()) {
-    super(owner, env, document, resolver, builder);
-    this._rootTemplate = rootTemplate(owner);
-    this._viewRegistry = viewRegistry || owner.lookup('-view-registry:main');
-  }
-
-  // renderer HOOKS
-
-  appendOutletView(view, 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(0, outlet, view.owner, args, true), target);
-  }
-  appendTo(view, target) {
-    let definition = new RootComponentDefinition(view);
-    this._appendDefinition(view, curry(0, definition, this.state.owner, null, true), target);
-  }
-  _appendDefinition(root, definition, target) {
-    let self = createConstRef(definition, 'this');
-    let dynamicScope = new DynamicScope(null, UNDEFINED_REFERENCE);
-    let rootState = new ClassicRootState(root, this.state.context, this.state.owner, this._rootTemplate, self, target, dynamicScope, this.state.builder);
-    this.state.renderRoot(rootState, this);
-  }
-  cleanupRootFor(component) {
-    // no need to cleanup roots if we have already been destroyed
-    if (isDestroyed(this)) {
-      return;
-    }
-    let roots = this.state.roots;
-
-    // traverse in reverse so we can remove items
-    // without mucking up the index
-    let i = roots.length;
-    while (i--) {
-      let root = roots[i];
-      (!(root) && assert('has root', root));
-      if (root.type === 'classic' && root.isFor(component)) {
-        root.destroy();
-        roots.splice(i, 1);
-      }
-    }
-  }
-  remove(view) {
-    view._transitionTo('destroying');
-    this.cleanupRootFor(view);
-    if (this.state.isInteractive) {
-      view.trigger('didDestroyElement');
-    }
-  }
-  get _roots() {
-    return this.state.debug.roots;
-  }
-  get _inRenderTransaction() {
-    return this.state.debug.inRenderTransaction;
-  }
-  get _isInteractive() {
-    return this.state.debug.isInteractive;
-  }
-  get _context() {
-    return this.state.context;
-  }
-  register(view) {
-    let id = getViewId(view);
-    (!(!this._viewRegistry[id]) && assert('Attempted to register a view with an id already in use: ' + id, !this._viewRegistry[id]));
-    this._viewRegistry[id] = view;
-  }
-  unregister(view) {
-    delete this._viewRegistry[getViewId(view)];
-  }
-  getElement(component) {
-    if (this._isInteractive) {
-      return getViewElement(component);
-    } else {
-      throw new Error('Accessing `this.element` is not allowed in non-interactive environments (such as FastBoot).');
-    }
-  }
-  getBounds(component) {
-    let bounds = component[BOUNDS];
-    (!(bounds) && assert('object passed to getBounds must have the BOUNDS symbol as a property', bounds));
-    let parentElement = bounds.parentElement();
-    let firstNode = bounds.firstNode();
-    let lastNode = bounds.lastNode();
-    return {
-      parentElement,
-      firstNode,
-      lastNode
-    };
-  }
 }
 
-export { OutletView as O, Renderer as R, _resetRenderers as _, renderSettled as a, outletHelper as o, renderComponent as r };
+export { BaseRenderer as B, ResolverImpl as R, _resetRenderers as _, renderSettled as a, errorLoopTransaction as e, renderComponent as r };