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

package/dist/dev/packages/shared-chunks/{index-DkwVSPP5.js → index-DaFzpTIE.js}

@@ -1,17 +1,17 @@
 import { a as assign } from './object-utils-AijlD-JH.js';
-import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, c as enumerate, r as reverse } from './array-utils-BEaSKdEb.js';
-import { ab as VM_PRIMITIVE_OP, aE as encodeHandle, o as VM_CONCAT_OP, O as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, N as VM_GET_PROPERTY_OP, P as VM_HAS_BLOCK_OP, au as VM_SPREAD_BLOCK_OP, m as VM_COMPILE_BLOCK_OP, Q as VM_HAS_BLOCK_PARAMS_OP, S as VM_IF_INLINE_OP, a2 as VM_NOT_OP, M as VM_GET_DYNAMIC_VAR_OP, $ as VM_LOG_OP, G as VM_FETCH_OP, ac as VM_PRIMITIVE_REFERENCE_OP, R as VM_HELPER_OP, x as VM_DUP_OP, A as VM_DYNAMIC_HELPER_OP, a7 as VM_POP_OP, h as VM_CAPTURE_ARGS_OP, t as VM_CURRY_OP, aH as isSmallInt, aF as encodeImmediate, ah as VM_PUSH_DYNAMIC_SCOPE_OP, g as VM_BIND_DYNAMIC_SCOPE_OP, a6 as VM_POP_DYNAMIC_SCOPE_OP, I as VM_GET_BLOCK_OP, U as VM_INVOKE_YIELD_OP, a9 as VM_POP_SCOPE_OP, i as VM_CHILD_SCOPE_OP, at as VM_SET_VARIABLE_OP, p as VM_CONSTANT_OP, ae as VM_PUSH_BLOCK_SCOPE_OP, ak as VM_PUSH_SYMBOL_TABLE_OP, ai as VM_PUSH_EMPTY_ARGS_OP, ad as VM_PUSH_ARGS_OP, D as VM_ENTER_OP, X as VM_JUMP_EQ_OP, F as VM_EXIT_OP, Z as VM_JUMP_UNLESS_OP, af as VM_PUSH_COMPONENT_DEFINITION_OP, _ as VM_LOAD_OP, f as VM_BEGIN_COMPONENT_TRANSACTION_OP, s as VM_CREATE_COMPONENT_OP, am as VM_REGISTER_COMPONENT_DESTRUCTOR_OP, K as VM_GET_COMPONENT_SELF_OP, ap as VM_ROOT_SCOPE_OP, ar as VM_SET_BLOCK_OP, w as VM_DID_RENDER_LAYOUT_OP, l as VM_COMMIT_COMPONENT_TRANSACTION_OP, aa as VM_PREPARE_ARGS_OP, aA as VM_VIRTUAL_ROOT_SCOPE_OP, as as VM_SET_NAMED_VARIABLES_OP, aq as VM_SET_BLOCKS_OP, T as VM_INVOKE_COMPONENT_LAYOUT_OP, al as VM_PUT_COMPONENT_OPERATIONS_OP, a3 as VM_OPEN_DYNAMIC_ELEMENT_OP, v as VM_DID_CREATE_ELEMENT_OP, H as VM_FLUSH_ELEMENT_OP, j as VM_CLOSE_ELEMENT_OP, an as VM_RESOLVE_CURRIED_COMPONENT_OP, ao as VM_RESOLVE_DYNAMIC_COMPONENT_OP, ag as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, J as VM_GET_COMPONENT_LAYOUT_OP, a5 as VM_POPULATE_LAYOUT_OP, L as VM_GET_COMPONENT_TAG_NAME_OP, k as VM_COMMENT_OP, a1 as VM_MODIFIER_OP, B as VM_DYNAMIC_MODIFIER_OP, av as VM_STATIC_ATTR_OP, aw as VM_STATIC_COMPONENT_ATTR_OP, y as VM_DYNAMIC_ATTR_OP, n as VM_COMPONENT_ATTR_OP, a4 as VM_OPEN_ELEMENT_OP, u as VM_DEBUGGER_OP, ay as VM_TEXT_OP, z as VM_DYNAMIC_CONTENT_TYPE_OP, aj as VM_PUSH_REMOTE_ELEMENT_OP, a8 as VM_POP_REMOTE_ELEMENT_OP, az as VM_TO_BOOLEAN_OP, C as VM_ENTER_LIST_OP, W as VM_ITERATE_OP, E as VM_EXIT_LIST_OP } from './syscall-ops-nrBHMOTp.js';
-import { e as VM_RETURN_OP, i as isMachineOp, d as VM_PUSH_FRAME_OP, c as VM_POP_FRAME_OP, a as VM_INVOKE_VIRTUAL_OP, b as VM_JUMP_OP, f as VM_RETURN_TO_OP, V as VM_INVOKE_STATIC_OP } from './vm-ops-5QCUIRx4.js';
-import { a as expect, u as unwrap, S as StackImpl, d as dict } from './collections-DEt-i-8B.js';
-import { i as isPresentArray } from './present-D0EfKzC6.js';
+import { b as EMPTY_STRING_ARRAY, E as EMPTY_ARRAY, e as enumerate, r as reverse } from './array-utils-CZQxrdD3.js';
+import { r as VM_PRIMITIVE_OP, aE as encodeHandle, au as VM_CONCAT_OP, al as VM_GET_VARIABLE_OP, q as VM_CONSTANT_REFERENCE_OP, ap as VM_GET_PROPERTY_OP, as as VM_HAS_BLOCK_OP, ar as VM_SPREAD_BLOCK_OP, E as VM_COMPILE_BLOCK_OP, at as VM_HAS_BLOCK_PARAMS_OP, av as VM_IF_INLINE_OP, aw as VM_NOT_OP, ax as VM_GET_DYNAMIC_VAR_OP, ay as VM_LOG_OP, y as VM_FETCH_OP, u as VM_PRIMITIVE_REFERENCE_OP, ak as VM_HELPER_OP, v as VM_DUP_OP, aj as VM_DYNAMIC_HELPER_OP, w as VM_POP_OP, $ as VM_CAPTURE_ARGS_OP, ai as VM_CURRY_OP, aF as isSmallInt, aG as encodeImmediate, m as VM_PUSH_DYNAMIC_SCOPE_OP, z as VM_BIND_DYNAMIC_SCOPE_OP, n as VM_POP_DYNAMIC_SCOPE_OP, aq as VM_GET_BLOCK_OP, F as VM_INVOKE_YIELD_OP, l as VM_POP_SCOPE_OP, k as VM_CHILD_SCOPE_OP, am 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, ao as VM_ROOT_SCOPE_OP, an 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, aA as VM_DEBUGGER_OP, K as VM_TEXT_OP, b as VM_ASSERT_SAME_OP, az 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-CN7STuUn.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, d as dict } from './collections-DPkjqeA3.js';
+import { i as isPresentArray } from './present-B1rrjAVM.js';
 import { a as assert } from './assert-Zqc4wiAV.js';
 import { InstructionEncoderImpl } from '../@glimmer/encoder/index.js';
-import { b as TYPE_SIZE, A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-B9qxc-pB.js';
+import { a as TYPE_SIZE, A as ARG_SHIFT, M as MACHINE_MASK, I as InternalComponentCapabilities } from './flags-BZxHQ0yn.js';
 import { d as debugToString } from './debug-to-string-C6LsA_qz.js';
 import { o as opcodes } from './opcodes-CplRyHl_.js';
-import { h as $v0, $ as $fp, c as $s0, e as $sp, d as $s1 } from './registers-Buvdhhxx.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-CZkuOqqC.js';
+import { h as hasCapability } from './capabilities-CajW4QjE.js';
 
 function isGetLikeTuple(opcode) {
   return Array.isArray(opcode) && opcode.length === 2;
@@ -1612,6 +1612,7 @@ STATEMENTS.add(opcodes.Append, (op, [, value]) => {
         op(VM_DYNAMIC_CONTENT_TYPE_OP);
       }, when => {
         when(ContentType.Component, () => {
+          op(VM_ASSERT_SAME_OP);
           op(VM_RESOLVE_CURRIED_COMPONENT_OP);
           op(VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP);
           InvokeNonStaticComponent(op, {
@@ -1954,4 +1955,4 @@ class TemplateImpl {
   }
 }
 
-export { CallDynamic as C, EMPTY_BLOCKS as E, InvokeBareComponent as I, SwitchCases as S, WrappedBuilder as W, EncoderImpl as a, InvokeStaticBlock as b, InvokeStaticBlockWithStack as c, compilable as d, compileStatements as e, encodeOp as f, templateCompilationContext as g, templateFactory as h, invokePreparedComponent as i, meta as m, templateCacheCounters as t };
+export { CallDynamic as C, EMPTY_BLOCKS as E, InvokeStaticBlock as I, SwitchCases as S, WrappedBuilder as W, templateCacheCounters as a, compileStatements as b, compilable as c, InvokeStaticBlockWithStack as d, templateCompilationContext as e, EncoderImpl as f, encodeOp as g, InvokeBareComponent as h, invokePreparedComponent as i, meta as m, templateFactory as t };

package/dist/dev/packages/shared-chunks/{injected_property-B075jH6c.js → injected_property-CbBLr5jt.js}

@@ -1,7 +1,7 @@
 import { getOwner } from '../@ember/-internals/owner/index.js';
 import '../@ember/debug/index.js';
-import { d as computed, f as defineProperty } from './computed-Daavz6vC.js';
-import { c as isElementDescriptor } from './decorator-DYQwMItS.js';
+import { c as computed, d as defineProperty } from './computed-BPCtuOxQ.js';
+import { i as isElementDescriptor } from './decorator-B5Uh5NFI.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 let DEBUG_INJECTION_FUNCTIONS;

package/dist/dev/packages/shared-chunks/{internal-Bpr6ihB_.js → internal-DTOXyEGM.js}

@@ -1,10 +1,10 @@
 import { setOwner } from '../@ember/-internals/owner/index.js';
-import { a as guidFor } from './guid-PO2v9BaN.js';
+import { g as guidFor } from './guid-Cbq2sNV_.js';
 import '../@ember/debug/index.js';
 import { s as setComponentTemplate } from './template-R_5UMHhb.js';
-import { s as setInternalComponentManager } from './api-DG5kRT-o.js';
-import { v as valueForRef, j as isConstRef, d as createConstRef } from './reference-C-OXd_kp.js';
-import { x as untrack } from './cache-CeWOBNQg.js';
+import { s as setInternalComponentManager } from './api-DuLOZMO_.js';
+import { v as valueForRef, i as isConstRef, a as createConstRef } from './reference-BqOLhKFy.js';
+import { u as untrack } from './cache-DGDPVCpC.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 function NOOP() {}

package/dist/dev/packages/shared-chunks/{internal-helper-IC87S6iZ.js → internal-helper-CKrni0b_.js}

@@ -1,4 +1,4 @@
-import { j as setInternalHelperManager } from './api-DG5kRT-o.js';
+import { j as setInternalHelperManager } from './api-DuLOZMO_.js';
 
 function internalHelper(helper) {
   return setInternalHelperManager(helper, {});

package/dist/dev/packages/shared-chunks/{invoke-Ds0KEfP_.js → invoke-d9sqa50M.js}

@@ -1,8 +1,8 @@
 import { isDestroying, isDestroyed, associateDestroyableChild } from '../@glimmer/destroyable/index.js';
-import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-DG5kRT-o.js';
+import { a as getInternalHelperManager, f as hasValue, h as hasDestroyable } from './api-DuLOZMO_.js';
 import { getOwner } from '../@glimmer/owner/index.js';
-import { l as createCache, r as getValue } from './cache-CeWOBNQg.js';
-import { E as EMPTY_ARGS, b as EMPTY_NAMED, c as EMPTY_POSITIONAL } from './untouchable-this-BHdAERUu.js';
+import { g as createCache, h as getValue } from './cache-DGDPVCpC.js';
+import { E as EMPTY_ARGS, a as EMPTY_NAMED, b as EMPTY_POSITIONAL } from './arguments-CDkbOqTS.js';
 
 let ARGS_CACHES = new WeakMap() ;
 function getArgs(proxy) {

package/dist/dev/packages/shared-chunks/{libraries-P8Ins5CB.js → libraries-DwffpMGE.js}

@@ -1,6 +1,6 @@
 import { warn, debug } from '../@ember/debug/index.js';
 import VERSION from '../ember/version.js';
-import { g as get } from './property_get-BjbsrgpU.js';
+import { g as get } from './property_get-CRP7MFz_.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 /**

package/dist/dev/packages/shared-chunks/{meta-Cjo3zQJq.js → meta-BqC7f9Ia.js}

@@ -1,4 +1,4 @@
-import { n as createUpdatableTag, y as unwrap, o as debug, D as DIRTY_TAG } from './cache-CeWOBNQg.js';
+import { b as createUpdatableTag, d as unwrap, e as debug, D as DIRTY_TAG } from './cache-DGDPVCpC.js';
 
 function isObjectLike(u) {
   return typeof u === 'object' && u !== null || typeof u === 'function';

package/dist/{prod/packages/shared-chunks/namespace_search-TFdmjK_a.js → dev/packages/shared-chunks/namespace_search-BfvzEQzN.js}

@@ -131,4 +131,4 @@ function tryIsNamespace(lookup, prop) {
   }
 }
 
-export { NAMESPACES as N, NAMESPACES_BY_ID as a, addNamespace as b, findNamespaces as c, processNamespace as d, setUnprocessedMixins as e, findNamespace as f, isSearchDisabled as i, processAllNamespaces as p, removeNamespace as r, setSearchDisabled as s };
+export { NAMESPACES as N, NAMESPACES_BY_ID as a, addNamespace as b, findNamespaces as c, processNamespace as d, setSearchDisabled as e, findNamespace as f, isSearchDisabled as i, processAllNamespaces as p, removeNamespace as r, setUnprocessedMixins as s };

package/dist/dev/packages/shared-chunks/{normalize-CxG_iVLJ.js → normalize-CKySQVU7.js}

@@ -1,4 +1,4 @@
-import { a as expect } from './collections-DEt-i-8B.js';
+import { e as expect } from './collections-DPkjqeA3.js';
 import { s as setLocalDebugType } from './debug-brand-B1TWjOCH.js';
 
 class CursorImpl {
@@ -81,4 +81,4 @@ function isString(value) {
   return typeof value === 'string';
 }
 
-export { ConcreteBounds as C, CursorImpl as a, isFragment as b, clear as c, isNode as d, isSafeString as e, isString as f, isEmpty as i, move as m, normalizeStringValue as n, shouldCoerce as s };
+export { ConcreteBounds as C, CursorImpl as a, isEmpty as b, clear as c, isString as d, isFragment as e, isNode as f, isSafeString as i, move as m, normalizeStringValue as n, shouldCoerce as s };

package/dist/dev/packages/shared-chunks/{or-Bg6rCMF8.js → not-DYh6AY9Z.js}

@@ -1,23 +1,6 @@
 import { toBool } from '../@glimmer/global-context/index.js';
-import { b as createComputeRef, v as valueForRef } from './reference-C-OXd_kp.js';
-import { i as internalHelper } from './hash-2-93qikL.js';
-
-const and = internalHelper(({
-  positional
-}) => {
-  if (positional.length < 2) {
-    throw new Error(`\`and\` expects at least two arguments, but received ${positional.length}.`);
-  }
-  return createComputeRef(() => {
-    let last;
-    for (let i = 0; i < positional.length; i++) {
-      let arg = positional[i];
-      last = arg ? valueForRef(arg) : arg;
-      if (!toBool(last)) return last;
-    }
-    return last;
-  }, null, 'and');
-});
+import { c as createComputeRef, v as valueForRef } from './reference-BqOLhKFy.js';
+import { i as internalHelper } from './hash-6NDs_5_f.js';
 
 /**
  * Performs a strict equality comparison.
@@ -31,6 +14,18 @@ function eq(left, right) {
   return left === right;
 }
 
+/**
+ * Performs a strict inequality comparison.
+ *
+ * left !== right
+ */
+function neq(left, right) {
+  if (arguments.length !== 2) {
+    throw new Error(`\`neq\` expects exactly two arguments, but received ${arguments.length}.`);
+  }
+  return left !== right;
+}
+
 /**
  * Performs a greater than comparison.
  *
@@ -79,24 +74,22 @@ function lte(left, right) {
   return left <= right;
 }
 
-/**
- * Performs a strict inequality comparison.
- *
- * left !== right
- */
-function neq(left, right) {
-  if (arguments.length !== 2) {
-    throw new Error(`\`neq\` expects exactly two arguments, but received ${arguments.length}.`);
-  }
-  return left !== right;
-}
-
-const not = (...args) => {
-  if (args.length !== 1) {
-    throw new Error(`\`not\` expects exactly one argument, but received ${args.length}.`);
+const and = internalHelper(({
+  positional
+}) => {
+  if (positional.length < 2) {
+    throw new Error(`\`and\` expects at least two arguments, but received ${positional.length}.`);
   }
-  return !toBool(args[0]);
-};
+  return createComputeRef(() => {
+    let last;
+    for (let i = 0; i < positional.length; i++) {
+      let arg = positional[i];
+      last = arg ? valueForRef(arg) : arg;
+      if (!toBool(last)) return last;
+    }
+    return last;
+  }, null, 'and');
+});
 
 const or = internalHelper(({
   positional
@@ -115,4 +108,11 @@ const or = internalHelper(({
   }, null, 'or');
 });
 
+const not = (...args) => {
+  if (args.length !== 1) {
+    throw new Error(`\`not\` expects exactly one argument, but received ${args.length}.`);
+  }
+  return !toBool(args[0]);
+};
+
 export { and as a, gte as b, lte as c, not as d, eq as e, gt as g, lt as l, neq as n, or as o };

package/dist/dev/packages/shared-chunks/{observers-CejcZw5s.js → observers-DMlX2nCi.js}

@@ -1,10 +1,10 @@
 import { E as ENV } from './env-g-kaAFLN.js';
 import { peekMeta } from '../@ember/-internals/meta/lib/meta.js';
 import { registerDestructor } from '../@glimmer/destroyable/index.js';
-import { B as valueForTag, z as validateTag, c as CURRENT_TAG } from './cache-CeWOBNQg.js';
-import { a as tagMetaFor } from './meta-Cjo3zQJq.js';
-import { g as getChainTagsForKey } from './chain-tags-DfmU63mS.js';
-import { a as addListener, r as removeListener, s as sendEvent } from './events-B1lx9T1I.js';
+import { a as valueForTag, v as validateTag, k as CURRENT_TAG } from './cache-DGDPVCpC.js';
+import { a as tagMetaFor } from './meta-BqC7f9Ia.js';
+import { g as getChainTagsForKey } from './chain-tags-uWSImHzB.js';
+import { a as addListener, r as removeListener, s as sendEvent } from './events-6aFVjD4k.js';
 
 const AFTER_OBSERVERS = ':change';
 function changeEvent(keyName) {
@@ -196,4 +196,4 @@ function destroyObservers(target) {
   if (ASYNC_OBSERVERS.size > 0) ASYNC_OBSERVERS.delete(target);
 }
 
-export { ASYNC_OBSERVERS as A, SYNC_OBSERVERS as S, activateObserver as a, addObserver as b, flushSyncObservers as c, resumeObserverDeactivation as d, revalidateObservers as e, flushAsyncObservers as f, suspendedObserverDeactivation as g, removeObserver as r, setObserverSuspended as s };
+export { ASYNC_OBSERVERS as A, SYNC_OBSERVERS as S, activateObserver as a, addObserver as b, revalidateObservers as c, flushSyncObservers as d, resumeObserverDeactivation as e, flushAsyncObservers as f, setObserverSuspended as g, removeObserver as r, suspendedObserverDeactivation as s };

package/dist/dev/packages/shared-chunks/{on-Ch_lyozr.js → on-DlF0Wy7P.js}

@@ -1,8 +1,8 @@
-import { e as buildUntouchableThis, f as check, l as reifyNamed } from './untouchable-this-BHdAERUu.js';
+import { g as buildUntouchableThis, h as check, e as reifyNamed } from './arguments-CDkbOqTS.js';
 import { registerDestructor } from '../@glimmer/destroyable/index.js';
-import { k as setInternalModifierManager } from './api-DG5kRT-o.js';
-import { v as valueForRef } from './reference-C-OXd_kp.js';
-import { n as createUpdatableTag } from './cache-CeWOBNQg.js';
+import { k as setInternalModifierManager } from './api-DuLOZMO_.js';
+import { v as valueForRef } from './reference-BqOLhKFy.js';
+import { b as createUpdatableTag } from './cache-DGDPVCpC.js';
 
 const untouchableContext = buildUntouchableThis('`on` modifier');
 class OnModifierState {
@@ -139,11 +139,7 @@ function addEventListener(element, eventName, callback, options) {
   For example, if you'd like to run a function on your component when a `<button>`
   in the components template is clicked you might do something like:
 
-  ```app/components/like-post.hbs
-  <button {{on 'click' this.saveLike}}>Like this post!</button>
-  ```
-
-  ```app/components/like-post.js
+  ```app/components/like-post.gjs
   import Component from '@glimmer/component';
   import { action } from '@ember/object';
 
@@ -152,6 +148,10 @@ function addEventListener(element, eventName, callback, options) {
       // someone likes your post!
       // better send a request off to your server...
     }
+    
+    <template>
+      <button {{on 'click' this.saveLike}}>Like this post!</button>
+    </template>
   }
   ```
 
@@ -199,7 +199,7 @@ function addEventListener(element, eventName, callback, options) {
   properly bound to the `items-list`, but let's explore what happens if we
   left out the arrow function:
 
-  ```app/components/like-post.js
+  ```app/components/like-post.gjs
   import Component from '@glimmer/component';
 
   export default class LikePostComponent extends Component {

package/dist/dev/packages/shared-chunks/outlet-CHFL7tun.js

@@ -0,0 +1,135 @@
+import '../@ember/debug/index.js';
+import { _instrumentStart } from '../@ember/instrumentation/index.js';
+import { c as capabilityFlagsFrom } from './capabilities-CajW4QjE.js';
+import { v as valueForRef, U as UNDEFINED_REFERENCE } from './reference-BqOLhKFy.js';
+import { E as EMPTY_ARGS } from './arguments-CDkbOqTS.js';
+import { u as unwrapTemplate } from './curly-DGUCLOud.js';
+import { t as templateFactory } from './index-DaFzpTIE.js';
+import { assert } from '../@ember/debug/lib/assert.js';
+
+function instrumentationPayload(def) {
+  // "main" used to be the outlet name, keeping it around for compatibility
+  return {
+    object: `${def.name}:main`
+  };
+}
+const CAPABILITIES = {
+  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 = /*@__PURE__*/capabilityFlagsFrom(CAPABILITIES);
+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, 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 != null && 'buildChildEngineInstance' in currentOwner) && assert('Expected currentOwner to be an EngineInstance', currentOwner != null && 'buildChildEngineInstance' in currentOwner));
+        let engineInstance = currentOwner;
+        let {
+          mountPoint
+        } = engineInstance;
+        if (mountPoint) {
+          state.engine = {
+            mountPoint,
+            instance: engineInstance
+          };
+        }
+      }
+    }
+    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;
+  }
+  getSelf() {
+    return UNDEFINED_REFERENCE;
+  }
+  didCreate() {}
+  didUpdate() {}
+  didRenderLayout(state) {
+    state.finalize();
+  }
+  didUpdateLayout() {}
+  getDestroyable() {
+    return null;
+  }
+}
+const OUTLET_MANAGER = /*@__PURE__*/new OutletComponentManager();
+const OUTLET_COMPONENT_TEMPLATE = templateFactory(
+/*
+  <@Component @controller={{@controller}} @model={{@model}} />
+*/
+{
+  "id": null,
+  "block": "[[[8,[30,1],null,[[\"@controller\",\"@model\"],[[30,2],[30,3]]],null]],[\"@Component\",\"@controller\",\"@model\"],[]]",
+  "moduleName": "(unknown template module)",
+  "isStrictMode": true
+});
+class OutletComponent {
+  // handle is not used by this custom definition
+  handle = -1;
+  resolvedName = null;
+  manager = OUTLET_MANAGER;
+  capabilities = CAPABILITIES_MASK;
+  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);
+}
+
+export { OutletComponent as O, createRootOutlet as c };

package/dist/dev/packages/shared-chunks/{present-D0EfKzC6.js → present-B1rrjAVM.js}

@@ -21,4 +21,4 @@ function mapPresentArray(list, mapper) {
   return out;
 }
 
-export { asPresentArray as a, getLast as b, getFirst as g, isPresentArray as i, mapPresentArray as m };
+export { getFirst as a, asPresentArray as b, getLast as g, isPresentArray as i, mapPresentArray as m };

package/dist/{prod/packages/shared-chunks/program-CF651Zuj.js → dev/packages/shared-chunks/program-DlgjqLa6.js}

@@ -1,5 +1,5 @@
-import { u as unwrap } from './collections-By4M3cTy.js';
-import { O as OPERAND_LEN_MASK, A as ARG_SHIFT, M as MACHINE_MASK, T as TYPE_MASK } from './flags-B9qxc-pB.js';
+import { u as unwrap } from './collections-DPkjqeA3.js';
+import { O as OPERAND_LEN_MASK, A as ARG_SHIFT, M as MACHINE_MASK, T as TYPE_MASK } from './flags-BZxHQ0yn.js';
 
 class RuntimeOpImpl {
   offset = 0;
@@ -173,4 +173,4 @@ function sizeof(table, handle) {
   }
 }
 
-export { ProgramHeapImpl as P, RuntimeOpImpl as R, ProgramImpl as a };
+export { ProgramImpl as P, RuntimeOpImpl as R, ProgramHeapImpl as a };

package/dist/dev/packages/shared-chunks/{program-context-BaYVr5GA.js → program-context-Dq8xN2HI.js}

@@ -1,8 +1,8 @@
-import { a0 as VM_MAIN_OP, r as VM_CONTENT_TYPE_OP, e as VM_ASSERT_SAME_OP, a as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, an as VM_RESOLVE_CURRIED_COMPONENT_OP, ag as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, c as VM_APPEND_SAFE_HTML_OP, V as VM_APPEND_DOCUMENT_FRAGMENT_OP, b as VM_APPEND_NODE_OP } from './syscall-ops-nrBHMOTp.js';
-import { V as VM_INVOKE_STATIC_OP } from './vm-ops-5QCUIRx4.js';
-import { c as $s0 } from './registers-Buvdhhxx.js';
+import { V as VM_MAIN_OP, a as VM_CONTENT_TYPE_OP, b as VM_ASSERT_SAME_OP, c as VM_APPEND_HTML_OP, d as VM_APPEND_TEXT_OP, e as VM_RESOLVE_CURRIED_COMPONENT_OP, f as VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP, g as VM_APPEND_SAFE_HTML_OP, h as VM_APPEND_DOCUMENT_FRAGMENT_OP, i as VM_APPEND_NODE_OP } from './syscall-ops-CN7STuUn.js';
+import { V as VM_INVOKE_STATIC_OP } from './vm-ops-ImHv0Wtg.js';
+import { $ as $s0 } from './registers-C_W2qYHJ.js';
 import { ContentType } from '../@glimmer/vm/index.js';
-import { a as EncoderImpl, f as encodeOp, i as invokePreparedComponent, S as SwitchCases, I as InvokeBareComponent, C as CallDynamic } from './index-DkwVSPP5.js';
+import { f as EncoderImpl, g as encodeOp, i as invokePreparedComponent, S as SwitchCases, h as InvokeBareComponent, C as CallDynamic } from './index-DaFzpTIE.js';
 
 class StdLib {
   constructor(main, trustingGuardedAppend, cautiousGuardedAppend, trustingNonDynamicAppend, cautiousNonDynamicAppend) {
@@ -54,6 +54,7 @@ function StdAppend(op, trusting, nonDynamicAppend) {
     });
     if (typeof nonDynamicAppend === 'number') {
       when(ContentType.Component, () => {
+        op(VM_ASSERT_SAME_OP);
         op(VM_RESOLVE_CURRIED_COMPONENT_OP);
         op(VM_PUSH_DYNAMIC_COMPONENT_INSTANCE_OP);
         InvokeBareComponent(op);

package/dist/dev/packages/shared-chunks/{property_get-BjbsrgpU.js → property_get-CRP7MFz_.js}

@@ -1,8 +1,8 @@
 import { s as setProxy } from './is_proxy-Bzg0d4m4.js';
 import { isEmberArray } from '../@ember/array/-internals.js';
 import '../@ember/debug/index.js';
-import { w as track, u as isTracking, k as consumeTag } from './cache-CeWOBNQg.js';
-import { t as tagFor } from './meta-Cjo3zQJq.js';
+import { t as track, z as isTracking, c as consumeTag } from './cache-DGDPVCpC.js';
+import { t as tagFor } from './meta-BqC7f9Ia.js';
 import { C as Cache } from './cache-qDyqAcpg.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
@@ -136,4 +136,4 @@ track(() => _getProp({
   a: fakeProxy
 }, 'a'));
 
-export { PROXY_CONTENT as P, _getPath as _, _getProp as a, getPossibleMandatoryProxyValue as b, get as g, hasUnknownProperty as h, isPath as i };
+export { PROXY_CONTENT as P, _getPath as _, getPossibleMandatoryProxyValue as a, _getProp as b, get as g, hasUnknownProperty as h, isPath as i };

package/dist/dev/packages/shared-chunks/{property_set-LJskl202.js → property_set-qCUylPEK.js}

@@ -1,9 +1,9 @@
 import { s as setWithMandatorySetter, l as lookupDescriptor } from './mandatory-setter-BpbAMTzV.js';
 import { t as toString } from './to-string-C7M8LBLH.js';
 import '../@ember/debug/index.js';
-import { C as COMPUTED_SETTERS } from './decorator-DYQwMItS.js';
-import { i as isPath, _ as _getPath, b as getPossibleMandatoryProxyValue } from './property_get-BjbsrgpU.js';
-import { n as notifyPropertyChange } from './computed-Daavz6vC.js';
+import { C as COMPUTED_SETTERS } from './decorator-B5Uh5NFI.js';
+import { i as isPath, _ as _getPath, a as getPossibleMandatoryProxyValue } from './property_get-CRP7MFz_.js';
+import { n as notifyPropertyChange } from './computed-BPCtuOxQ.js';
 import { assert } from '../@ember/debug/lib/assert.js';
 
 /**

package/dist/dev/packages/shared-chunks/{reference-C-OXd_kp.js → reference-BqOLhKFy.js}

@@ -1,6 +1,6 @@
-import { i as isDict, a as expect } from './collections-DEt-i-8B.js';
+import { e as expect, i as isDict } from './collections-DPkjqeA3.js';
 import { setProp, getProp } from '../@glimmer/global-context/index.js';
-import { b as CONSTANT_TAG, I as INITIAL, z as validateTag, w as track, B as valueForTag, k as consumeTag } from './cache-CeWOBNQg.js';
+import { C as CONSTANT_TAG, I as INITIAL, v as validateTag, t as track, a as valueForTag, c as consumeTag } from './cache-DGDPVCpC.js';
 
 const REFERENCE = Symbol('REFERENCE');
 const CONSTANT = 0;
@@ -172,4 +172,4 @@ let createDebugAliasRef;
   };
 }
 
-export { FALSE_REFERENCE as F, NULL_REFERENCE as N, REFERENCE as R, TRUE_REFERENCE as T, UNDEFINED_REFERENCE as U, childRefFromParts as a, createComputeRef as b, childRefFor as c, createConstRef as d, createDebugAliasRef as e, createInvokableRef as f, createPrimitiveRef as g, createReadOnlyRef as h, createUnboundRef as i, isConstRef as j, isInvokableRef as k, isUpdatableRef as l, updateRef as u, valueForRef as v };
+export { FALSE_REFERENCE as F, NULL_REFERENCE as N, REFERENCE as R, TRUE_REFERENCE as T, UNDEFINED_REFERENCE as U, createConstRef as a, isInvokableRef as b, createComputeRef as c, isUpdatableRef as d, createPrimitiveRef as e, childRefFor as f, childRefFromParts as g, createDebugAliasRef as h, isConstRef as i, createInvokableRef as j, createReadOnlyRef as k, createUnboundRef as l, updateRef as u, valueForRef as v };

package/dist/dev/packages/shared-chunks/{registers-Buvdhhxx.js → registers-C_W2qYHJ.js}

@@ -32,4 +32,4 @@ function isLowLevelRegister(register) {
   return register <= $sp;
 }
 
-export { $fp as $, $pc as a, $ra as b, $s0 as c, $s1 as d, $sp as e, $t0 as f, $t1 as g, $v0 as h, isLowLevelRegister as i };
+export { $s0 as $, $v0 as a, $t1 as b, $t0 as c, $pc as d, $ra as e, $fp as f, $sp as g, $s1 as h, isLowLevelRegister as i };

package/dist/dev/packages/shared-chunks/{rehydrate-builder-IH4d_JQy.js → rehydrate-builder-C6k1XhET.js}

@@ -1,8 +1,8 @@
-import { c as NewTreeBuilder, R as RemoteBlock, C as COMMENT_NODE, T as TEXT_NODE, E as ELEMENT_NODE, N as NS_SVG } from './element-builder-Cl1kHFJE.js';
-import { a as castToSimple, c as castToBrowser } from './simple-cast-BXTrayoV.js';
-import { a as expect } from './collections-DEt-i-8B.js';
+import { N as NewTreeBuilder, R as RemoteBlock, C as COMMENT_NODE, T as TEXT_NODE, E as ELEMENT_NODE, e as NS_SVG } from './api-C0PAtEgQ.js';
+import { c as castToSimple, a as castToBrowser } from './simple-cast-DCvJLSin.js';
+import { e as expect } from './collections-DPkjqeA3.js';
 import { a as assert } from './assert-Zqc4wiAV.js';
-import { C as ConcreteBounds, a as CursorImpl } from './normalize-CxG_iVLJ.js';
+import { C as ConcreteBounds, a as CursorImpl } from './normalize-CKySQVU7.js';
 
 const SERIALIZATION_FIRST_NODE_STRING = '%+b:0%';
 function isSerializationFirstNode(node) {