ember-source 7.1.0-alpha.5 → 7.1.0

package/dist/prod/packages/shared-chunks/{get-D5wxdTkY.js → get-Dt5L0TcU.js}

@@ -1,6 +1,6 @@
 import { a as createComputeRef, U as UNDEFINED_REFERENCE, v as valueForRef } from './reference-BshxG6wn.js';
-import { f as reifyPositional } from './debug-render-tree-BLtnOSbb.js';
-import { i as internalHelper } from './hash-DcUe-meU.js';
+import { f as reifyPositional } from './debug-render-tree-CF5O4-WI.js';
+import { i as internalHelper } from './hash-Dkj3I4L4.js';
 import { setPath, getPath } from '../@glimmer/global-context/index.js';
 import { i as isDict } from './collections-C3Y8z_9v.js';
 
@@ -19,10 +19,15 @@ const normalizeTextValue = value => {
 
   Example:
 
-  ```handlebars
-  {{some-component name=(concat firstName " " lastName)}}
 
-  {{! would pass name="<first name value> <last name value>" to the component}}
+  ```gjs
+  import { concat } from '@ember/helper';
+
+  <template>
+  {{yield (concat firstName " " lastName)}}
+
+  {{! would yield name="<first name value> <last name value>" to the component}}
+  </template>
   ```
 
   or for angle bracket invocation, you actually don't need concat at all.
@@ -46,28 +51,31 @@ const concat = internalHelper(({
 
   For example, these two usages are equivalent:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
+  import { get } from '@ember/object';
 
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
       language: "Ruby"
     }
+    
+    <template>
+      {{this.developer.name}}
+      {{get this.developer "name"}}
+    </template>
   }
   ```
 
-  ```handlebars
-  {{this.developer.name}}
-  {{get this.developer "name"}}
-  ```
-
   If there were several facts about a person, the `{{get}}` helper can dynamically
   pick one:
 
-  ```app/templates/application.hbs
-  <DeveloperDetail @factName="language" />
+  ```app/templates/application.gjs
+  <template>
+    <DeveloperDetail @factName="language" />
+  </template>
   ```
 
   ```handlebars
@@ -77,10 +85,11 @@ const concat = internalHelper(({
   For a more complex example, this template would allow the user to switch
   between showing the user's height and weight with a click:
 
-  ```app/components/developer-detail.js
+  ```app/components/developer-detail.gjs
   import Component from '@glimmer/component';
   import { tracked } from '@glimmer/tracking';
-
+  import { get } from '@ember/object';
+    
   export default class extends Component {
     @tracked developer = {
       name: "Sandi Metz",
@@ -92,28 +101,16 @@ const concat = internalHelper(({
     showFact = (fact) => {
       this.currentFact = fact;
     }
-  }
-  ```
-
-  ```app/components/developer-detail.js
-  {{get this.developer this.currentFact}}
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
-  ```
+    
+    <template>
+      {{get this.developer this.currentFact}}
 
-  The `{{get}}` helper can also respect mutable values itself. For example:
-
-  ```app/components/developer-detail.js
-  <Input @value={{mut (get this.person this.currentFact)}} />
-
-  <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
-  <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+      <button {{on 'click' (fn this.showFact "name")}}>Show name</button>
+      <button {{on 'click' (fn this.showFact "language")}}>Show language</button>
+    </template>
+  }
   ```
 
-  Would allow the user to swap what fact is being displayed, and also edit
-  that fact via a two-way mutable binding.
-
   @public
   @method get
  */

package/dist/prod/packages/shared-chunks/{get_properties-BcAC5sGx.js → get_properties-Nn08mLAH.js}

@@ -1,4 +1,4 @@
-import { g as get } from './property_get-hWJ0nGhW.js';
+import { g as get } from './property_get-CAFdpRyu.js';
 
 /**
  @module @ember/object

package/dist/prod/packages/shared-chunks/{hash-DcUe-meU.js → hash-Dkj3I4L4.js}

@@ -1,5 +1,5 @@
 import { a as createComputeRef, i as isInvokableRef, u as updateRef } from './reference-BshxG6wn.js';
-import { f as reifyPositional, g as check, e as reifyNamed } from './debug-render-tree-BLtnOSbb.js';
+import { f as reifyPositional, g as check, e as reifyNamed } from './debug-render-tree-CF5O4-WI.js';
 import { j as setInternalHelperManager } from './api-zh_k31vb.js';
 
 function internalHelper(helper) {
@@ -19,7 +19,7 @@ function internalHelper(helper) {
    ```
     or
    ```handlebars
-   {{my-component people=(array
+   {{yield people=(array
      'Tom Dale'
      'Yehuda Katz'
      this.myOtherPerson)
@@ -64,13 +64,17 @@ const context = buildUntouchableThis();
   to a component invoked within the loop. Here's how you could use the `fn`
   helper to pass both the function and its arguments together:
 
-    ```app/templates/components/items-listing.hbs
-  {{#each @items as |item|}}
-    <DisplayItem @item=item @select={{fn this.handleSelected item}} />
-  {{/each}}
+  ```app/components/items-listing.gjs
+  import DisplayItem from './display-item';
+    
+  <template>
+    {{#each @items as |item|}}
+      <DisplayItem @item=item @select={{fn this.handleSelected item}} />
+    {{/each}}
+  </template>
   ```
 
-  ```app/components/items-list.js
+  ```app/components/items-list.gjs
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
 
@@ -81,7 +85,7 @@ const context = buildUntouchableThis();
   }
   ```
 
-  In this case the `display-item` component will receive a normal function
+  In this case the `DisplayItem` component will receive a normal function
   that it can invoke. When it invokes the function, the `handleSelected`
   function will receive the `item` and any arguments passed, thanks to the
   `fn` helper.
@@ -98,7 +102,7 @@ const context = buildUntouchableThis();
   `handleSelected` is properly bound to the `items-list`, but let's explore what
   happens if we left out the arrow function:
 
-  ```app/components/items-list.js
+  ```app/components/items-list.gjs
   import Component from '@glimmer/component';
 
   export default class ItemsList extends Component {
@@ -115,6 +119,8 @@ const context = buildUntouchableThis();
 
   See also [partial application](https://en.wikipedia.org/wiki/Partial_application).
 
+  `fn` is built-in and does not require any additional imports.
+ 
   @method fn
   @public
 */
@@ -138,7 +144,7 @@ const fn = internalHelper(({
 
 /**
    Use the `{{hash}}` helper to create a hash to pass as an option to your
-   components. This is specially useful for contextual components where you can
+   components. This is especially useful for contextual components where you can
    just yield a hash:
 
    ```handlebars

package/dist/prod/packages/shared-chunks/{helper-Da672z4a.js → helper-CN6UzshW.js}

@@ -1,7 +1,6 @@
 import { setOwner } from '../@ember/-internals/owner/index.js';
 import { FrameworkObject } from '../@ember/object/-internals.js';
 import { g as getDebugName } from './get-debug-name-BDxIL2Y1.js';
-import './env-DXxsTFkM.js';
 import { join } from '../@ember/runloop/index.js';
 import { a as getInternalHelperManager, i as helperCapabilities } from './api-zh_k31vb.js';
 import { b as setHelperManager } from './api-CM1trl_4.js';
@@ -28,20 +27,32 @@ const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
   Ember Helpers are functions that can compute values, and are used in templates.
   For example, this code calls a helper named `format-currency`:
 
-  ```app/templates/application.hbs
-  <Cost @cents={{230}} />
+  ```app/templates/application.gjs
+  import Cost from '../components/cost';
+    
+  <template>
+    <Cost @cents={{230}} />
+  </template>
   ```
 
-  ```app/components/cost.hbs
-  <div>{{format-currency @cents currency="$"}}</div>
+  ```app/components/cost.gjs
+  import formatCurrency from '../helpers/format-currency';
+    
+  <template>
+    <div>{{formatCurrency @cents currency="$"}}</div>
+  </template>
   ```
 
   Additionally a helper can be called as a nested helper.
   In this example, we show the formatted currency value if the `showMoney`
   named argument is truthy.
 
-  ```handlebars
-  {{if @showMoney (format-currency @cents currency="$")}}
+  ```gjs
+  import formatCurrency from '../helpers/format-currency';
+
+  <template>
+    {{if @showMoney (formatCurrency @cents currency="$")}}
+  </template>
   ```
 
   Helpers defined using a class must provide a `compute` function. For example:

package/dist/prod/packages/shared-chunks/{index--2U-v2nf.js → index-Bj71BDDA.js}

@@ -1,14 +1,13 @@
 import { a as assign } from './object-utils-AijlD-JH.js';
 import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, e as enumerate, r as reverse } from './array-utils-CZQxrdD3.js';
-import { s as VM_PRIMITIVE_OP, aG as VM_RETURN_OP, aM as encodeHandle, aN as isMachineOp, aw as VM_CONCAT_OP, an as VM_GET_VARIABLE_OP, r as VM_CONSTANT_REFERENCE_OP, ar as VM_GET_PROPERTY_OP, au as VM_HAS_BLOCK_OP, at as VM_SPREAD_BLOCK_OP, F as VM_COMPILE_BLOCK_OP, av as VM_HAS_BLOCK_PARAMS_OP, ax as VM_IF_INLINE_OP, ay as VM_NOT_OP, az as VM_GET_DYNAMIC_VAR_OP, aK as VM_PUSH_FRAME_OP, aA as VM_LOG_OP, aJ as VM_POP_FRAME_OP, z as VM_FETCH_OP, v as VM_PRIMITIVE_REFERENCE_OP, am as VM_HELPER_OP, w as VM_DUP_OP, al as VM_DYNAMIC_HELPER_OP, x as VM_POP_OP, a0 as VM_CAPTURE_ARGS_OP, ak as VM_CURRY_OP, aO as isSmallInt, aP as encodeImmediate, n as VM_PUSH_DYNAMIC_SCOPE_OP, A as VM_BIND_DYNAMIC_SCOPE_OP, o as VM_POP_DYNAMIC_SCOPE_OP, as as VM_GET_BLOCK_OP, G as VM_INVOKE_YIELD_OP, m as VM_POP_SCOPE_OP, l as VM_CHILD_SCOPE_OP, ao as VM_SET_VARIABLE_OP, aI as VM_INVOKE_VIRTUAL_OP, p as VM_CONSTANT_OP, E as VM_PUSH_BLOCK_SCOPE_OP, D as VM_PUSH_SYMBOL_TABLE_OP, $ as VM_PUSH_EMPTY_ARGS_OP, _ as VM_PUSH_ARGS_OP, B as VM_ENTER_OP, J as VM_JUMP_EQ_OP, aH as VM_JUMP_OP, C as VM_EXIT_OP, aF as VM_RETURN_TO_OP, I as VM_JUMP_UNLESS_OP, Y as VM_PUSH_COMPONENT_DEFINITION_OP, y as VM_LOAD_OP, a4 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a2 as VM_CREATE_COMPONENT_OP, a3 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a9 as VM_GET_COMPONENT_SELF_OP, aq as VM_ROOT_SCOPE_OP, ap as VM_SET_BLOCK_OP, ah as VM_DID_RENDER_LAYOUT_OP, ai as VM_COMMIT_COMPONENT_TRANSACTION_OP, a1 as VM_PREPARE_ARGS_OP, ad as VM_VIRTUAL_ROOT_SCOPE_OP, ae as VM_SET_NAMED_VARIABLES_OP, af as VM_SET_BLOCKS_OP, ag as VM_INVOKE_COMPONENT_LAYOUT_OP, a5 as VM_PUT_COMPONENT_OPERATIONS_OP, O as VM_OPEN_DYNAMIC_ELEMENT_OP, a8 as VM_DID_CREATE_ELEMENT_OP, R as VM_FLUSH_ELEMENT_OP, S as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, Z as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, ab as VM_GET_COMPONENT_LAYOUT_OP, ac as VM_POPULATE_LAYOUT_OP, aa as VM_GET_COMPONENT_TAG_NAME_OP, M as VM_COMMENT_OP, T as VM_MODIFIER_OP, U as VM_DYNAMIC_MODIFIER_OP, W as VM_STATIC_ATTR_OP, a7 as VM_STATIC_COMPONENT_ATTR_OP, X as VM_DYNAMIC_ATTR_OP, a6 as VM_COMPONENT_ATTR_OP, N as VM_OPEN_ELEMENT_OP, aj as VM_DEBUGGER_OP, L as VM_TEXT_OP, j as VM_INVOKE_STATIC_OP, aB as VM_DYNAMIC_CONTENT_TYPE_OP, P as VM_PUSH_REMOTE_ELEMENT_OP, Q as VM_POP_REMOTE_ELEMENT_OP, K as VM_TO_BOOLEAN_OP, aC as VM_ENTER_LIST_OP, aE as VM_ITERATE_OP, aD as VM_EXIT_LIST_OP } from './opcode-metadata-9iSW5JGP.js';
-import './curried-BVwSNqpf.js';
-import './reference-BshxG6wn.js';
+import { r as VM_PRIMITIVE_OP, aF as encodeHandle, av as VM_CONCAT_OP, am as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, aq as VM_GET_PROPERTY_OP, at as VM_HAS_BLOCK_OP, as as VM_SPREAD_BLOCK_OP, E as VM_COMPILE_BLOCK_OP, au as VM_HAS_BLOCK_PARAMS_OP, aw as VM_IF_INLINE_OP, ax as VM_NOT_OP, ay as VM_GET_DYNAMIC_VAR_OP, az as VM_LOG_OP, y as VM_FETCH_OP, u as VM_PRIMITIVE_REFERENCE_OP, al as VM_HELPER_OP, v as VM_DUP_OP, ak as VM_DYNAMIC_HELPER_OP, w as VM_POP_OP, $ as VM_CAPTURE_ARGS_OP, aj as VM_CURRY_OP, aG as isSmallInt, aH as encodeImmediate, m as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, ar as VM_GET_BLOCK_OP, F as VM_INVOKE_YIELD_OP, l as VM_POP_SCOPE_OP, k as VM_CHILD_SCOPE_OP, an as VM_SET_VARIABLE_OP, o as VM_CONSTANT_OP, D as VM_PUSH_BLOCK_SCOPE_OP, C as VM_PUSH_SYMBOL_TABLE_OP, _ as VM_PUSH_EMPTY_ARGS_OP, Z as VM_PUSH_ARGS_OP, A as VM_ENTER_OP, I as VM_JUMP_EQ_OP, B as VM_EXIT_OP, H as VM_JUMP_UNLESS_OP, X as VM_PUSH_COMPONENT_DEFINITION_OP, x as VM_LOAD_OP, a3 as VM_BEGIN_COMPONENT_TRANSACTION_OP, a1 as VM_CREATE_COMPONENT_OP, a2 as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, a8 as VM_GET_COMPONENT_SELF_OP, ap as VM_ROOT_SCOPE_OP, ao as VM_SET_BLOCK_OP, ag as VM_DID_RENDER_LAYOUT_OP, ah as VM_COMMIT_COMPONENT_TRANSACTION_OP, a0 as VM_PREPARE_ARGS_OP, ac as VM_VIRTUAL_ROOT_SCOPE_OP, ad as VM_SET_NAMED_VARIABLES_OP, ae as VM_SET_BLOCKS_OP, af as VM_INVOKE_COMPONENT_LAYOUT_OP, a4 as VM_PUT_COMPONENT_OPERATIONS_OP, N as VM_OPEN_DYNAMIC_ELEMENT_OP, a7 as VM_DID_CREATE_ELEMENT_OP, Q as VM_FLUSH_ELEMENT_OP, R as VM_CLOSE_ELEMENT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, Y as VM_RESOLVE_DYNAMIC_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, aa as VM_GET_COMPONENT_LAYOUT_OP, ab as VM_POPULATE_LAYOUT_OP, a9 as VM_GET_COMPONENT_TAG_NAME_OP, L as VM_COMMENT_OP, S as VM_MODIFIER_OP, T as VM_DYNAMIC_MODIFIER_OP, U as VM_STATIC_ATTR_OP, a6 as VM_STATIC_COMPONENT_ATTR_OP, W as VM_DYNAMIC_ATTR_OP, a5 as VM_COMPONENT_ATTR_OP, M as VM_OPEN_ELEMENT_OP, ai as VM_DEBUGGER_OP, K as VM_TEXT_OP, aA as VM_DYNAMIC_CONTENT_TYPE_OP, O as VM_PUSH_REMOTE_ELEMENT_OP, P as VM_POP_REMOTE_ELEMENT_OP, J as VM_TO_BOOLEAN_OP, aB as VM_ENTER_LIST_OP, aD as VM_ITERATE_OP, aC as VM_EXIT_LIST_OP } from './syscall-ops-BPFtDquC.js';
+import { b as VM_RETURN_OP, i as isMachineOp, f as VM_PUSH_FRAME_OP, e as VM_POP_FRAME_OP, d as VM_INVOKE_VIRTUAL_OP, c as VM_JUMP_OP, a as VM_RETURN_TO_OP, V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
 import { e as expect, u as unwrap, S as StackImpl, a as isPresentArray, d as dict } from './collections-C3Y8z_9v.js';
-import { a as assert } from './assert-CUCJBR2C.js';
+import { a as assert } from './assert-Zqc4wiAV.js';
 import { InstructionEncoderImpl } from '../@glimmer/encoder/index.js';
 import { A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
 import { o as opcodes } from './opcodes-CplRyHl_.js';
-import { a as $v0, f as $fp, $ as $s0, e as $sp, d as $s1 } from './registers-DoamZwaG.js';
+import { a as $v0, f as $fp, $ as $s0, g as $sp, h as $s1 } from './registers-C_W2qYHJ.js';
 import { ContentType } from '../@glimmer/vm/index.js';
 import { h as hasCapability } from './capabilities-_5e35539.js';
 

package/dist/prod/packages/shared-chunks/{index-D87qoERP.js → index-ClxHbCe9.js}

@@ -10,22 +10,22 @@ import { associateDestroyableChild, isDestroyed, destroy, registerDestructor, is
 import { artifacts } from '../@glimmer/program/index.js';
 import { R as RuntimeOpImpl } from './program-B7CWdS8W.js';
 import { v as valueForRef, U as UNDEFINED_REFERENCE, a as createComputeRef, c as createConstRef, j as createInvokableRef, k as createReadOnlyRef, l as createUnboundRef, g as childRefFromParts, u as updateRef } from './reference-BshxG6wn.js';
-import { c as clientBuilder } from './element-builder-BPjq0rxK.js';
-import { E as EMPTY_ARGS, c as createCapturedArgs, b as EMPTY_POSITIONAL, d as curry } from './debug-render-tree-BLtnOSbb.js';
-import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-nx5-PsDW.js';
+import { c as clientBuilder } from './element-builder-CnlTPNyw.js';
+import { E as EMPTY_ARGS, c as createCapturedArgs, b as EMPTY_POSITIONAL, d as curry } from './debug-render-tree-CF5O4-WI.js';
+import { g as runtimeOptions, i as inTransaction, r as renderComponent$1, d as renderMain } from './render-DkJJmoI4.js';
 import { d as dict } from './collections-C3Y8z_9v.js';
-import { u as unwrapTemplate, a as CurlyComponentManager, i as initialRenderInstrumentDetails, b as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-BsqvV8G0.js';
+import { u as unwrapTemplate, a as CurlyComponentManager, i as initialRenderInstrumentDetails, b as ComponentStateBucket, D as DIRTY_TAG, c as isCurlyManager, B as BOUNDS } from './curly-ZzX43b50.js';
 import { C as CONSTANT_TAG, a as consumeTag, x as isTracking, D as DIRTY_TAG$1, p as createTag, d as valueForTag, i as CURRENT_TAG, v as validateTag } from './cache-BIlOoPA7.js';
 import { a as RSVP } from './rsvp-CnCSY930.js';
 import '../@ember/engine/instance.js';
 import { _instrumentStart } from '../@ember/instrumentation/index.js';
 import { c as capabilityFlagsFrom } from './capabilities-_5e35539.js';
-import { t as templateFactory } from './index--2U-v2nf.js';
-import { g as getFactoryFor } from './container-D5NwW5Fd.js';
-import { g as get, a as _getProp } from './property_get-hWJ0nGhW.js';
-import { _ as _setProp, s as set } from './property_set-Dj5-ScWk.js';
+import { t as templateFactory } from './index-Bj71BDDA.js';
+import { g as getFactoryFor } from './container-BYOnjnwz.js';
+import { g as get, a as _getProp } from './property_get-CAFdpRyu.js';
+import { _ as _setProp, s as set } from './property_set-BunbMFtp.js';
 import setGlobalContext from '../@glimmer/global-context/index.js';
-import { t as tagForObject, o as objectAt, a as tagForProperty } from './chain-tags-BJqcuCM1.js';
+import { t as tagForObject, o as objectAt, a as tagForProperty } from './chain-tags-C9rFtQ_x.js';
 import { isEmberArray } from '../@ember/array/-internals.js';
 import { i as isObject } from './spec-BXl1reqK.js';
 import { t as tagFor } from './meta-B9mldqPL.js';
@@ -36,18 +36,18 @@ import { i as isHTMLSafe } from './index-D-xTBV4B.js';
 import { isArray } from '../@ember/array/index.js';
 import { g as getComponentTemplate } from './template-Dc_cBOoX.js';
 import { c as hasInternalComponentManager, j as setInternalHelperManager, g as getInternalComponentManager } from './api-zh_k31vb.js';
-import { h as hash, f as fn, a as array } from './hash-DcUe-meU.js';
-import { g as get$1, c as concat } from './get-D5wxdTkY.js';
-import { o as on } from './on-C3ZQiUUD.js';
+import { h as hash, f as fn, a as array } from './hash-Dkj3I4L4.js';
+import { g as get$1, c as concat } from './get-Dt5L0TcU.js';
+import { o as on } from './on-CWgOWNSL.js';
 import { T as TEMPLATE_ONLY_COMPONENT_MANAGER, t as templateOnlyComponent } from './template-only-BtLl0uH0.js';
-import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-Da672z4a.js';
+import { i as isClassicHelper, C as CLASSIC_HELPER_MANAGER } from './helper-CN6UzshW.js';
 import { dasherize } from '../@ember/-internals/string/index.js';
 import { a as uniqueId } from './unique-id-CfHImDRV.js';
 import '../route-recognizer/index.js';
 import './unrecognized-url-error-DDBwfzdm.js';
 import '../@ember/routing/lib/routing-service.js';
 import { generateControllerFactory } from '../@ember/routing/lib/generate_controller.js';
-import { E as EvaluationContextImpl } from './program-context-CGMN-aQM.js';
+import { E as EvaluationContextImpl } from './program-context-B8HKU7wu.js';
 
 function instrumentationPayload$1(def) {
   // "main" used to be the outlet name, keeping it around for compatibility
@@ -239,7 +239,7 @@ class RootComponentDefinition {
 */
 
 /**
-  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
@@ -283,6 +283,8 @@ class RootComponentDefinition {
     {{/each}}
   </ul>
   ```
+    
+  `#each` is a keyword and does not need to be imported. 
 
   ### Specifying Keys
 
@@ -350,11 +352,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';
 
@@ -363,21 +365,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>
@@ -385,6 +385,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
@@ -776,73 +778,42 @@ const trackArray = internalHelper(({
 */
 
 /**
-  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`:
+  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`. 
 
-  ```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
+  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
-  {{my-child childClickCount=totalClicks click-count-change=(fn (mut totalClicks))}}
+  <MyChild @childClickCount={{this.totalClicks}} @clickCountChange={{fn (mut this.totalClicks)}} />
   ```
 
-  The child `Component` would invoke the function with the new click value:
+  The child `Component` would invoke the function with the new click count:
 
-  ```javascript
-  // my-child.js
+  ```app/components/my-child.gjs
+  import Component from '@glimmer/component';
+  import { action } from '@ember/object';
+    
   export default class MyChild extends Component {
-    click() {
-      this.get('click-count-change')(this.get('childClickCount') + 1);
+    @action
+    update() {
+      this.args.clickCountChange(this.args.childClickCount + 1);
     }
+    
+    <template>
+      <button {{on "click" this.update}}>
+        Click me!
+      </button>
+    </template>
   }
   ```
 
   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
@@ -864,6 +835,10 @@ const mut = internalHelper(({
 /**
   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.
@@ -876,14 +851,6 @@ const mut = internalHelper(({
   }
   ```
 
-  ```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
@@ -1160,15 +1127,14 @@ class MountDefinition {
 
   For example, the following template mounts the `ember-chat` engine:
 
-  ```handlebars
-  {{! application.hbs }}
+  ```app/templates/application.gjs
   {{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:
 
-  ```
+  ```hbs
   <div>
     {{mount 'admin' model=userSettings}}
   </div>
@@ -1176,15 +1142,20 @@ class MountDefinition {
 
   Or an inline `hash`, and you can even pass components:
 
+  ```gjs
+  import SignInButton from '../components/sign-in-button';
+  <template>
+    <div>
+      <h1>Application template!</h1>
+      {{mount 'admin' model=(hash
+          title='Secret Admin'
+          signInButton=SignInButton
+      )}}
+    </div>
+  </template>
   ```
-  <div>
-    <h1>Application template!</h1>
-    {{mount 'admin' model=(hash
-        title='Secret Admin'
-        signInButton=(component 'sign-in-button')
-    )}}
-  </div>
-  ```
+ 
+ `mount` is built-in and does not need to be imported.
 
   @method mount
   @param {String} name Name of the engine to mount.
@@ -1316,23 +1287,30 @@ function makeRouteTemplate(owner, name, template) {
 /**
   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:
-
-  ```app/templates/application.hbs
-  <MyHeader />
-
-  <div class="my-dynamic-content">
-    <!-- this content will change based on the current route, which depends on the current URL -->
-    {{outlet}}
-  </div>
-
-  <MyFooter />
+  application's `application.gjs` file:
+
+  ```app/templates/application.gjs
+  import MyHeader from '../components/my-header';
+  import MyFooter from '../components/my-footer';
+    
+  <template>
+    <MyHeader />
+  
+    <div class="my-dynamic-content">
+      <!-- this content will change based on the current route, which depends on the current URL -->
+      {{outlet}}
+    </div>
+  
+    <MyFooter />
+  </template>
   ```
 
   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.
 
+  `outlet` is built-in and does not need to be imported. 
+ 
   @method outlet
   @for Ember.Templates.helpers
   @public

package/dist/prod/packages/shared-chunks/{injected_property-D9B-fPiH.js → injected_property--eJunJph.js}

@@ -1,7 +1,6 @@
 import { getOwner } from '../@ember/-internals/owner/index.js';
-import './env-DXxsTFkM.js';
-import { c as computed, d as defineProperty } from './computed-2Udcmflw.js';
-import { i as isElementDescriptor } from './decorator-DBCISop4.js';
+import { c as computed, d as defineProperty } from './computed-DjCIU_ht.js';
+import { i as isElementDescriptor } from './decorator-9ikVwsjY.js';
 
 let DEBUG_INJECTION_FUNCTIONS;
 

package/dist/prod/packages/shared-chunks/{invoke-Dr_CRwA_.js → invoke-Cj5zMqHz.js}

@@ -2,7 +2,7 @@ import { associateDestroyableChild } from '../@glimmer/destroyable/index.js';
 import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-zh_k31vb.js';
 import { getOwner } from '../@glimmer/owner/index.js';
 import { b as createCache, g as getValue } from './cache-BIlOoPA7.js';
-import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './debug-render-tree-BLtnOSbb.js';
+import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './debug-render-tree-CF5O4-WI.js';
 
 function getArgs(proxy) {
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- @fixme

package/dist/prod/packages/shared-chunks/{libraries-DaXpIDYN.js → libraries-_k-4KK5_.js}

@@ -1,6 +1,5 @@
-import './env-DXxsTFkM.js';
 import VERSION from '../ember/version.js';
-import './property_get-hWJ0nGhW.js';
+import './property_get-CAFdpRyu.js';
 
 /**
  @module ember

package/dist/prod/packages/shared-chunks/{observers-Co4JALkS.js → observers-CDkeR0nI.js}

@@ -3,8 +3,8 @@ import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
 import { registerDestructor } from '../@glimmer/destroyable/index.js';
 import { d as valueForTag, v as validateTag, i as CURRENT_TAG } from './cache-BIlOoPA7.js';
 import { a as tagMetaFor } from './meta-B9mldqPL.js';
-import { g as getChainTagsForKey } from './chain-tags-BJqcuCM1.js';
-import { a as addListener, r as removeListener, s as sendEvent } from './events-970OxD6Q.js';
+import { g as getChainTagsForKey } from './chain-tags-C9rFtQ_x.js';
+import { a as addListener, r as removeListener, s as sendEvent } from './events-DYrYz3V8.js';
 
 const AFTER_OBSERVERS = ':change';
 function changeEvent(keyName) {