ember-source 7.2.0-beta.1 → 7.3.0-alpha.2

package/docs/data.json

@@ -3,7 +3,7 @@
     "name": "The Ember API",
     "description": "The Ember API: a framework for building ambitious web applications",
     "url": "https://emberjs.com/",
-    "version": "7.2.0-beta.1"
+    "version": "7.3.0-alpha.2"
   },
   "files": {
     "node_modules/rsvp/lib/rsvp/promise/all.js": {
@@ -202,6 +202,13 @@
       },
       "namespaces": {}
     },
+    "packages/@ember/-internals/glimmer/lib/component-managers/curly-brand.ts": {
+      "name": "packages/@ember/-internals/glimmer/lib/component-managers/curly-brand.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
     "packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts": {
       "name": "packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts",
       "modules": {},
@@ -526,6 +533,15 @@
       "fors": {},
       "namespaces": {}
     },
+    "packages/@ember/-internals/glimmer/lib/base-renderer.ts": {
+      "name": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {
+        "@ember/renderer": 1
+      },
+      "namespaces": {}
+    },
     "packages/@ember/-internals/glimmer/lib/component.ts": {
       "name": "packages/@ember/-internals/glimmer/lib/component.ts",
       "modules": {},
@@ -544,6 +560,13 @@
       },
       "namespaces": {}
     },
+    "packages/@ember/-internals/glimmer/lib/helper-brand.ts": {
+      "name": "packages/@ember/-internals/glimmer/lib/helper-brand.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
     "packages/@ember/-internals/glimmer/lib/helper.ts": {
       "name": "packages/@ember/-internals/glimmer/lib/helper.ts",
       "modules": {},
@@ -555,13 +578,11 @@
       },
       "namespaces": {}
     },
-    "packages/@ember/-internals/glimmer/lib/renderer.ts": {
-      "name": "packages/@ember/-internals/glimmer/lib/renderer.ts",
+    "packages/@ember/-internals/glimmer/lib/router-resolver.ts": {
+      "name": "packages/@ember/-internals/glimmer/lib/router-resolver.ts",
       "modules": {},
       "classes": {},
-      "fors": {
-        "@ember/renderer": 1
-      },
+      "fors": {},
       "namespaces": {}
     },
     "packages/@ember/-internals/glimmer/tests/integration/components/render-component-test.ts": {
@@ -2511,6 +2532,13 @@
       "fors": {},
       "namespaces": {}
     },
+    "packages/@glimmer/validator/lib/tracked-value.ts": {
+      "name": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
     "packages/@glimmer/validator/lib/tracking.ts": {
       "name": "packages/@glimmer/validator/lib/tracking.ts",
       "modules": {},
@@ -2721,40 +2749,40 @@
       "file": "packages/@ember/-internals/glimmer/lib/utils/string.ts",
       "line": 70
     },
-    "@glimmer/tracking": {
-      "name": "@glimmer/tracking",
+    "@ember/renderer": {
+      "name": "@ember/renderer",
       "submodules": {},
       "elements": {},
       "classes": {
-        "@glimmer/tracking": 1
+        "@ember/renderer": 1,
+        "Renderer": 1,
+        "BucketCache": 1
       },
       "fors": {
-        "@glimmer/tracking": 1
+        "@ember/renderer": 1
       },
       "namespaces": {},
       "tag": "module",
-      "file": "packages/@glimmer/tracking/index.ts",
-      "line": 4,
-      "description": "In order to tell Ember a value might change, we need to mark it as trackable.\nTrackable values are values that:\n\n- Can change over their component’s lifetime and\n- Should cause Ember to rerender if and when they change\n\nWe can do this by marking the field with the `@tracked` decorator.",
+      "file": "packages/@ember/routing/lib/cache.ts",
+      "line": 1,
       "access": "public",
       "tagname": ""
     },
-    "@ember/renderer": {
-      "name": "@ember/renderer",
+    "@glimmer/tracking": {
+      "name": "@glimmer/tracking",
       "submodules": {},
       "elements": {},
       "classes": {
-        "@ember/renderer": 1,
-        "Renderer": 1,
-        "BucketCache": 1
+        "@glimmer/tracking": 1
       },
       "fors": {
-        "@ember/renderer": 1
+        "@glimmer/tracking": 1
       },
       "namespaces": {},
       "tag": "module",
-      "file": "packages/@ember/routing/lib/cache.ts",
-      "line": 1,
+      "file": "packages/@glimmer/tracking/index.ts",
+      "line": 10,
+      "description": "In order to tell Ember a value might change, we need to mark it as trackable.\nTrackable values are values that:\n\n- Can change over their component’s lifetime and\n- Should cause Ember to rerender if and when they change\n\nWe can do this by marking the field with the `@tracked` decorator.",
       "access": "public",
       "tagname": ""
     },
@@ -2853,7 +2881,7 @@
       "namespaces": {},
       "tag": "module",
       "file": "packages/@ember/utils/lib/compare.ts",
-      "line": 49
+      "line": 48
     },
     "@ember/application": {
       "name": "@ember/application",
@@ -3611,6 +3639,17 @@
       "access": "public",
       "tagname": ""
     },
+    "@ember/renderer": {
+      "name": "@ember/renderer",
+      "shortname": "@ember/renderer",
+      "classitems": [],
+      "plugins": [],
+      "extensions": [],
+      "plugin_for": [],
+      "extension_for": [],
+      "module": "@ember/renderer",
+      "namespace": ""
+    },
     "Component": {
       "name": "Component",
       "shortname": "Component",
@@ -3655,7 +3694,7 @@
       "namespace": "",
       "file": "packages/@ember/-internals/glimmer/lib/helper.ts",
       "line": 57,
-      "description": "Ember Helpers are functions that can compute values, and are used in templates.\nFor example, this code calls a helper named `format-currency`:\n\n```app/templates/application.gjs\nimport Cost from '../components/cost';\n  \n<template>\n  <Cost @cents={{230}} />\n</template>\n```\n\n```app/components/cost.gjs\nimport formatCurrency from '../helpers/format-currency';\n  \n<template>\n  <div>{{formatCurrency @cents currency=\"$\"}}</div>\n</template>\n```\n\nAdditionally a helper can be called as a nested helper.\nIn this example, we show the formatted currency value if the `showMoney`\nnamed argument is truthy.\n\n```gjs\nimport formatCurrency from '../helpers/format-currency';\n\n<template>\n  {{if @showMoney (formatCurrency @cents currency=\"$\")}}\n</template>\n```\n\nHelpers defined using a class must provide a `compute` function. For example:\n\n```app/helpers/format-currency.js\nimport Helper from '@ember/component/helper';\n\nexport default class extends Helper {\n  compute([cents], { currency }) {\n    return `${currency}${cents * 0.01}`;\n  }\n}\n```\n\nEach time the input to a helper changes, the `compute` function will be\ncalled again.\n\nAs instances, these helpers also have access to the container and will accept\ninjected dependencies.\n\nAdditionally, class helpers can call `recompute` to force a new computation.",
+      "description": "Ember Helpers are functions that can compute values, and are used in templates.\nFor example, this code calls a helper named `format-currency`:\n\n```app/templates/application.gjs\nimport Cost from '../components/cost';\n\n<template>\n  <Cost @cents={{230}} />\n</template>\n```\n\n```app/components/cost.gjs\nimport formatCurrency from '../helpers/format-currency';\n\n<template>\n  <div>{{formatCurrency @cents currency=\"$\"}}</div>\n</template>\n```\n\nAdditionally a helper can be called as a nested helper.\nIn this example, we show the formatted currency value if the `showMoney`\nnamed argument is truthy.\n\n```gjs\nimport formatCurrency from '../helpers/format-currency';\n\n<template>\n  {{if @showMoney (formatCurrency @cents currency=\"$\")}}\n</template>\n```\n\nHelpers defined using a class must provide a `compute` function. For example:\n\n```app/helpers/format-currency.js\nimport Helper from '@ember/component/helper';\n\nexport default class extends Helper {\n  compute([cents], { currency }) {\n    return `${currency}${cents * 0.01}`;\n  }\n}\n```\n\nEach time the input to a helper changes, the `compute` function will be\ncalled again.\n\nAs instances, these helpers also have access to the container and will accept\ninjected dependencies.\n\nAdditionally, class helpers can call `recompute` to force a new computation.",
       "extends": "CoreObject",
       "access": "public",
       "tagname": "",
@@ -3672,17 +3711,6 @@
       "module": "@ember/component",
       "namespace": ""
     },
-    "@ember/renderer": {
-      "name": "@ember/renderer",
-      "shortname": "@ember/renderer",
-      "classitems": [],
-      "plugins": [],
-      "extensions": [],
-      "plugin_for": [],
-      "extension_for": [],
-      "module": "@ember/renderer",
-      "namespace": ""
-    },
     "Ember": {
       "name": "Ember",
       "shortname": "Ember",
@@ -4097,7 +4125,7 @@
       "module": "ember",
       "namespace": "Ember",
       "file": "packages/@ember/-internals/runtime/lib/mixins/comparable.ts",
-      "line": 7,
+      "line": 8,
       "description": "Implements some standard methods for comparing objects. Add this mixin to\nany class you create that can compare its instances.\n\nYou should implement the `compare()` method.",
       "since": "Ember 0.9",
       "access": "private",
@@ -6457,6 +6485,13 @@
       "class": "EmberENV",
       "module": "rsvp"
     },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/component-managers/curly-brand.ts",
+      "line": 1,
+      "description": "The brand for the curly component manager lives in its own module so that\ncode which only needs to *detect* the curly manager (e.g. the resolver)\ndoes not have to import the manager itself (and with it the classic\ncomponent machinery).",
+      "class": "Ember.Templates.helpers",
+      "module": "rsvp"
+    },
     {
       "file": "packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts",
       "line": 113,
@@ -7168,15 +7203,169 @@
     {
       "file": "packages/@ember/-internals/glimmer/lib/views/outlet.ts",
       "line": 114,
-      "class": "Component",
+      "class": "@ember/renderer",
       "module": "@ember/template"
     },
     {
       "file": "packages/@ember/-internals/glimmer/lib/views/outlet.ts",
       "line": 122,
-      "class": "Component",
+      "class": "@ember/renderer",
+      "module": "@ember/template"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 68,
+      "description": "The interface the `RendererState` needs from a render root. The base\nrenderer only ever creates `ComponentRootState`s; the classic renderer\n(`./renderer`) adds `ClassicRootState` for outlet/classic-component roots.",
+      "class": "@ember/renderer",
       "module": "@ember/template"
     },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 413,
+      "description": "Destroys the render tree and removes all rendered content from the element rendered into",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 421,
+      "description": "The GlimmerRenderResult from the last render. Used to get positional\ninformation (firstNode) when a re-render replaces the content, so\nthat the new content is placed at the same DOM position.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 437,
+      "description": "Render a component into a DOM element.",
+      "itemtype": "method",
+      "name": "renderComponent",
+      "static": 1,
+      "params": [
+        {
+          "name": "component",
+          "description": "The component to render.",
+          "type": "Object"
+        },
+        {
+          "name": "options",
+          "description": "",
+          "type": "Object",
+          "props": [
+            {
+              "name": "into",
+              "description": "Where to render the component in to.",
+              "type": "Element"
+            },
+            {
+              "name": "owner",
+              "description": "Optionally specify the owner to use. This will be used for injections, and overall cleanup.",
+              "type": "Object",
+              "optional": true
+            },
+            {
+              "name": "env",
+              "description": "Optional renderer configuration",
+              "type": "Object",
+              "optional": true
+            },
+            {
+              "name": "args",
+              "description": "Optionally pass args in to the component. These may be reactive as long as it is an object or object-like",
+              "type": "Object",
+              "optional": true
+            }
+          ]
+        }
+      ],
+      "access": "public",
+      "tagname": "",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 452,
+      "description": "The component definition to render.\n\nAny component that has had its manager registered is valid.\nFor the component-types that ship with ember, manager registration\ndoes not need to be worried about.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 466,
+      "description": "The element to render the component in to.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 471,
+      "description": "Optional owner. Defaults to `{}`, can be any object, but will need to implement the [Owner](https://api.emberjs.com/ember/release/classes/Owner) API for components within this render tree to access services.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 475,
+      "description": "Optionally configure the rendering environment",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 479,
+      "description": "When false, modifiers will not run.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 483,
+      "description": "All other options are forwarded to the underlying renderer.\n(its API is currently private and out of scope for this RFC,\n so passing additional things here is also considered private API)",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 491,
+      "description": "These args get passed to the rendered component\n\nIf your args are reactive, re-rendering will happen automatically.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 500,
+      "description": "SAFETY: we should figure out what we need out of a `document` and narrow the API.\n        this exercise should also end up beginning to define what we need for CLI rendering (or to other outputs)",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 521,
+      "description": "Replace all contents, if we've rendered multiple times.\n\nhttps://github.com/emberjs/rfcs/pull/1099/files#diff-2b962105b9083ca84579cdc957f27f49407440f3c5078083fa369ec18cc46da8R365\n\nWe could later add an option to not do this behavior\n\nNOTE: destruction is async",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 532,
+      "description": "We can only replace the inner HTML the first time.\nBecause destruction is async, it won't be safe to\ndo this again, and we'll have to rely on the above destroy.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 541,
+      "description": "If there's an existing render result with valid bounds, use its\nfirstNode as the nextSibling so that new content is inserted at\nthe same DOM position. This ensures stable ordering when multiple\nrenderComponent calls target the same element and one is re-invoked\n(e.g., due to tracked dependency changes).\n\nThe old content's DOM nodes are still present (destruction is async),\nso firstNode() is a valid position reference. The new content is placed\nBEFORE the old content. When the old content is eventually destroyed\n(async clear of bounds), the new content remains in the correct position.",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/base-renderer.ts",
+      "line": 609,
+      "description": "SAFETY: are there consequences for being looser with *this* owner?\n        the public API for `owner` is kinda `Partial<InternalOwner>`\n        aka: implement only what you need.\n        But for actual ember apps, you *need* to implement everything\n        an app needs (which will actually change and become less over time)",
+      "class": "@ember/renderer",
+      "module": "@ember/renderer"
+    },
     {
       "file": "packages/@ember/-internals/glimmer/lib/component.ts",
       "line": 41,
@@ -7198,7 +7387,7 @@
         }
       ],
       "class": "Component",
-      "module": "@ember/template"
+      "module": "@ember/renderer"
     },
     {
       "file": "packages/@ember/-internals/glimmer/lib/component.ts",
@@ -7714,7 +7903,7 @@
     {
       "file": "packages/@ember/-internals/glimmer/lib/glimmer-tracking-docs.ts",
       "line": 22,
-      "description": "Marks a property as tracked. By default, values that are rendered in Ember app\ntemplates are _static_, meaning that updates to them won't cause the\napplication to rerender. Marking a property as tracked means that when that\nproperty changes, any templates that used that property, directly or\nindirectly, will rerender. For instance, consider this component:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\nimport { action } from '@ember/object';\n\nexport default class CounterComponent extends Component {\n  @tracked count = 0;\n\n  get timesTen() {\n    return this.count * 10;\n  }\n\n  @action\n  plusOne() {\n    this.count += 1;\n  }\n  \n  <template>\n    <div>Count: {{this.count}}</div>\n    <div>Times Ten: {{this.timesTen}}</div>\n    <div>\n      <button {{on \"click\" this.plusOne}}>\n        Plus One\n      </button>\n    </div>\n  </template>\n}\n```\n\nBoth the `{{this.count}}` and the `{{this.timesTen}}` properties in the\ntemplate will update whenever the button is clicked. Any tracked properties\nthat are used in any way to calculate a value that is used in the template\nwill cause a rerender when updated - this includes through method calls and\nother means:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\n\nclass Entry {\n  @tracked name;\n  @tracked phoneNumber;\n\n  constructor(name, phoneNumber) {\n    this.name = name;\n    this.phoneNumber = phoneNumber;\n  }\n}\n\nexport default class PhoneBookComponent extends Component {\n  entries = [\n    new Entry('Pizza Palace', 5551234),\n    new Entry('1st Street Cleaners', 5554321),\n    new Entry('Plants R Us', 5552468),\n  ];\n\n  // Any usage of this property will update whenever any of the names in the\n  // entries arrays are updated\n  get names() {\n    return this.entries.map(e => e.name);\n  }\n\n  // Any usage of this property will update whenever any of the numbers in the\n  // entries arrays are updated\n  get numbers() {\n    return this.getFormattedNumbers();\n  }\n\n  getFormattedNumbers() {\n    return this.entries\n      .map(e => e.phoneNumber)\n      .map(number => {\n        let numberString = '' + number;\n\n        return numberString.slice(0, 3) + '-' + numberString.slice(3);\n      });\n  }\n}\n```\n\nIt's important to note that setting tracked properties will always trigger an\nupdate, even if the property is set to the same value as it was before.\n\n```js\nlet entry = new Entry('Pizza Palace', 5551234);\n\n// if entry was used when rendering, this would cause a rerender, even though\n// the name is being set to the same value as it was before\nentry.name = entry.name;\n```\n\n`tracked` can also be used with the classic Ember object model in a similar\nmanner to classic computed properties:\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked(),\n  phoneNumber: tracked()\n});\n```\n\nOften this is unnecessary, but to ensure robust auto-tracking behavior it is\nadvisable to mark tracked state appropriately wherever possible.\n\nThis form of `tracked` also accepts an optional configuration object\ncontaining either an initial `value` or an `initializer` function (but not\nboth).\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked({ value: 'Zoey' }),\n  favoriteSongs: tracked({\n    initializer: () => ['Raspberry Beret', 'Time After Time']\n  })\n});\n```",
+      "description": "Marks a property as tracked. By default, values that are rendered in Ember app\ntemplates are _static_, meaning that updates to them won't cause the\napplication to rerender. Marking a property as tracked means that when that\nproperty changes, any templates that used that property, directly or\nindirectly, will rerender. For instance, consider this component:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\nimport { action } from '@ember/object';\n\nexport default class CounterComponent extends Component {\n  @tracked count = 0;\n\n  get timesTen() {\n    return this.count * 10;\n  }\n\n  @action\n  plusOne() {\n    this.count += 1;\n  }\n  \n  <template>\n    <div>Count: {{this.count}}</div>\n    <div>Times Ten: {{this.timesTen}}</div>\n    <div>\n      <button {{on \"click\" this.plusOne}}>\n        Plus One\n      </button>\n    </div>\n  </template>\n}\n```\n\nBoth the `{{this.count}}` and the `{{this.timesTen}}` properties in the\ntemplate will update whenever the button is clicked. Any tracked properties\nthat are used in any way to calculate a value that is used in the template\nwill cause a rerender when updated - this includes through method calls and\nother means:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\n\nclass Entry {\n  @tracked name;\n  @tracked phoneNumber;\n\n  constructor(name, phoneNumber) {\n    this.name = name;\n    this.phoneNumber = phoneNumber;\n  }\n}\n\nexport default class PhoneBookComponent extends Component {\n  entries = [\n    new Entry('Pizza Palace', 5551234),\n    new Entry('1st Street Cleaners', 5554321),\n    new Entry('Plants R Us', 5552468),\n  ];\n\n  // Any usage of this property will update whenever any of the names in the\n  // entries arrays are updated\n  get names() {\n    return this.entries.map(e => e.name);\n  }\n\n  // Any usage of this property will update whenever any of the numbers in the\n  // entries arrays are updated\n  get numbers() {\n    return this.getFormattedNumbers();\n  }\n\n  getFormattedNumbers() {\n    return this.entries\n      .map(e => e.phoneNumber)\n      .map(number => {\n        let numberString = '' + number;\n\n        return numberString.slice(0, 3) + '-' + numberString.slice(3);\n      });\n  }\n}\n```\n\nIt's important to note that setting tracked properties will always trigger an\nupdate, even if the property is set to the same value as it was before.\n\n```js\nlet entry = new Entry('Pizza Palace', 5551234);\n\n// if entry was used when rendering, this would cause a rerender, even though\n// the name is being set to the same value as it was before\nentry.name = entry.name;\n```\n\n`tracked` can also be used with the classic Ember object model in a similar\nmanner to classic computed properties:\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked(),\n  phoneNumber: tracked()\n});\n```\n\nOften this is unnecessary, but to ensure robust auto-tracking behavior it is\nadvisable to mark tracked state appropriately wherever possible.\n\nThis form of `tracked` also accepts an optional configuration object\ncontaining either an initial `value` or an `initializer` function (but not\nboth).\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked({ value: 'Zoey' }),\n  favoriteSongs: tracked({\n    initializer: () => ['Raspberry Beret', 'Time After Time']\n  })\n});\n```\n\nCalling `tracked` with an initial value creates a standalone reactive\nvalue, usable outside of classes:\n\n```js\nimport { tracked } from '@glimmer/tracking';\n\nconst count = tracked(0);\n\ncount.value;                // read the value, entangling with any tracking context\ncount.value = 1;            // write the value, notifying consumers\ncount.get();                // function shorthand for reading\ncount.set(2);               // function shorthand for writing\ncount.update((n) => n + 1); // write based on the current value, without entangling\ncount.freeze();             // prevent all future writes\n```\n\nReading `value` in a template (or in a getter used by a template) will\nrerender just like a `@tracked` property:\n\n```gjs\nimport { tracked } from '@glimmer/tracking';\nimport { on } from '@ember/modifier';\n\nconst count = tracked(0);\nconst increment = () => count.value++;\n\n<template>\n  Count is: {{count.value}}\n\n  <button {{on \"click\" increment}}>add one</button>\n</template>\n```\n\nThis form accepts an options object containing an `equals` function, which\ndecides whether a written value should notify consumers (it defaults to\n`Object.is`), and a `description` used for debugging:\n\n```js\nconst count = tracked(0, { equals: (a, b) => a === b });\n\ncount.value = 0; // does not notify consumers, the value did not change\n```\n\nNote: when `tracked` is called with a single plain object whose keys are all\ndrawn from `value`, `initializer`, `equals`, and `description`, it is treated\nas the configuration object for a decorator (or classic-class field), not as a\nstandalone value wrapping that object. To create a standalone reactive value\naround such an object, pass it as an initial value and include a (possibly\nempty) options argument: `tracked({ value: 5 }, {})`.\n\nThe `@tracked` decorator accepts the same options. By default, setting a\n`@tracked` property always notifies consumers, even when setting the\nproperty to the same value; passing `equals` opts in to equality-based\nnotification instead:\n\n```js\nimport { tracked } from '@glimmer/tracking';\n\nclass Counter {\n  @tracked({ equals: (a, b) => a === b }) count = 0;\n\n  noop = () => {\n    // does not notify consumers, the value did not change\n    this.count = this.count;\n  };\n}\n```",
       "itemtype": "method",
       "name": "tracked",
       "static": 1,
@@ -7725,7 +7914,7 @@
     },
     {
       "file": "packages/@ember/-internals/glimmer/lib/glimmer-tracking-docs.ts",
-      "line": 158,
+      "line": 226,
       "description": "Gives the getter a caching behavior. The return value of the getter\nwill be cached until any of the properties it is entangled with\nare invalidated. This is useful when a getter is expensive and\nused very often.\n\nFor instance, in this `GuestList` class, we have the `sortedGuests`\ngetter that sorts the guests alphabetically:\n\n```javascript\n  import { tracked } from '@glimmer/tracking';\n\n  class GuestList {\n    @tracked guests = ['Zoey', 'Tomster'];\n\n    get sortedGuests() {\n      return this.guests.slice().sort()\n    }\n  }\n```\n\nEvery time `sortedGuests` is accessed, a new array will be created and sorted,\nbecause JavaScript getters do not cache by default. When the guest list\nis small, like the one in the example, this is not a problem. However, if\nthe guest list were to grow very large, it would mean that we would be doing\na large amount of work each time we accessed `sortedGuests`. With `@cached`,\nwe can cache the value instead:\n\n```javascript\n  import { tracked, cached } from '@glimmer/tracking';\n\n  class GuestList {\n    @tracked guests = ['Zoey', 'Tomster'];\n\n    @cached\n    get sortedGuests() {\n      return this.guests.slice().sort()\n    }\n  }\n```\n\nNow the `sortedGuests` getter will be cached based on autotracking.\nIt will only rerun and create a new sorted array when the guests tracked\nproperty is updated.\n\n\n### Tradeoffs\n\nOveruse is discouraged.\n\nIn general, you should avoid using `@cached` unless you have confirmed that\nthe getter you are decorating is computationally expensive, since `@cached`\nadds a small amount of overhead to the getter.\nWhile the individual costs are small, a systematic use of the `@cached`\ndecorator can add up to a large impact overall in your app.\nMany getters and tracked properties are only accessed once during rendering,\nand then never rerendered, so adding `@cached` when unnecessary can\nnegatively impact performance.\n\nAlso, `@cached` may rerun even if the values themselves have not changed,\nsince tracked properties will always invalidate.\nFor example updating an integer value from `5` to an other `5` will trigger\na rerun of the cached properties building from this integer.\n\nAvoiding a cache invalidation in this case is not something that can\nbe achieved on the `@cached` decorator itself, but rather when updating\nthe underlying tracked values, by applying some diff checking mechanisms:\n\n```javascript\nif (nextValue !== this.trackedProp) {\n  this.trackedProp = nextValue;\n}\n```\n\nHere equal values won't update the property, therefore not triggering\nthe subsequent cache invalidations of the `@cached` properties who were\nusing this `trackedProp`.\n\nRemember that setting tracked data should only be done during initialization,\nor as the result of a user action. Setting tracked data during render\n(such as in a getter), is not supported.",
       "itemtype": "method",
       "name": "cached",
@@ -7735,6 +7924,13 @@
       "class": "@glimmer/tracking",
       "module": "@glimmer/tracking"
     },
+    {
+      "file": "packages/@ember/-internals/glimmer/lib/helper-brand.ts",
+      "line": 1,
+      "description": "The brand for classic (class-based) helpers lives in its own module so that\ncode which only needs to *detect* classic helpers (e.g. the resolver) does\nnot have to import the classic `Helper` base class (and with it the classic\nobject model: `EmberObject`, `Mixin`, meta, etc.).",
+      "class": "Helper",
+      "module": "@glimmer/tracking"
+    },
     {
       "file": "packages/@ember/-internals/glimmer/lib/helper.ts",
       "line": 117,
@@ -7779,7 +7975,7 @@
     },
     {
       "file": "packages/@ember/-internals/glimmer/lib/helper.ts",
-      "line": 325,
+      "line": 319,
       "description": "The type of a function-based helper.",
       "note": "This is *not* user-constructible: it is exported only so that the type\n  returned by the `helper` function can be named (and indeed can be exported\n  like `export default helper(...)` safely).",
       "class": "Helper",
@@ -7787,7 +7983,7 @@
     },
     {
       "file": "packages/@ember/-internals/glimmer/lib/helper.ts",
-      "line": 356,
+      "line": 350,
       "description": "In many cases it is not necessary to use the full `Helper` class.\nThe `helper` method create pure-function helpers without instances.\nFor example:\n\n```app/helpers/format-currency.js\nimport { helper } from '@ember/component/helper';\n\nexport default helper(function([cents], {currency}) {\n  return `${currency}${cents * 0.01}`;\n});\n```",
       "static": 1,
       "params": [
@@ -7806,158 +8002,18 @@
       "module": "@ember/component"
     },
     {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 552,
-      "description": "Destroys the render tree and removes all rendered content from the element rendered into",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 560,
-      "description": "The GlimmerRenderResult from the last render. Used to get positional\ninformation (firstNode) when a re-render replaces the content, so\nthat the new content is placed at the same DOM position.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 576,
-      "description": "Render a component into a DOM element.",
-      "itemtype": "method",
-      "name": "renderComponent",
-      "static": 1,
-      "params": [
-        {
-          "name": "component",
-          "description": "The component to render.",
-          "type": "Object"
-        },
-        {
-          "name": "options",
-          "description": "",
-          "type": "Object",
-          "props": [
-            {
-              "name": "into",
-              "description": "Where to render the component in to.",
-              "type": "Element"
-            },
-            {
-              "name": "owner",
-              "description": "Optionally specify the owner to use. This will be used for injections, and overall cleanup.",
-              "type": "Object",
-              "optional": true
-            },
-            {
-              "name": "env",
-              "description": "Optional renderer configuration",
-              "type": "Object",
-              "optional": true
-            },
-            {
-              "name": "args",
-              "description": "Optionally pass args in to the component. These may be reactive as long as it is an object or object-like",
-              "type": "Object",
-              "optional": true
-            }
-          ]
-        }
-      ],
-      "access": "public",
-      "tagname": "",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 591,
-      "description": "The component definition to render.\n\nAny component that has had its manager registered is valid.\nFor the component-types that ship with ember, manager registration\ndoes not need to be worried about.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 605,
-      "description": "The element to render the component in to.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 610,
-      "description": "Optional owner. Defaults to `{}`, can be any object, but will need to implement the [Owner](https://api.emberjs.com/ember/release/classes/Owner) API for components within this render tree to access services.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 614,
-      "description": "Optionally configure the rendering environment",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 618,
-      "description": "When false, modifiers will not run.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 622,
-      "description": "All other options are forwarded to the underlying renderer.\n(its API is currently private and out of scope for this RFC,\n so passing additional things here is also considered private API)",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 630,
-      "description": "These args get passed to the rendered component\n\nIf your args are reactive, re-rendering will happen automatically.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 639,
-      "description": "SAFETY: we should figure out what we need out of a `document` and narrow the API.\n        this exercise should also end up beginning to define what we need for CLI rendering (or to other outputs)",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 660,
-      "description": "Replace all contents, if we've rendered multiple times.\n\nhttps://github.com/emberjs/rfcs/pull/1099/files#diff-2b962105b9083ca84579cdc957f27f49407440f3c5078083fa369ec18cc46da8R365\n\nWe could later add an option to not do this behavior\n\nNOTE: destruction is async",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 671,
-      "description": "We can only replace the inner HTML the first time.\nBecause destruction is async, it won't be safe to\ndo this again, and we'll have to rely on the above destroy.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 680,
-      "description": "If there's an existing render result with valid bounds, use its\nfirstNode as the nextSibling so that new content is inserted at\nthe same DOM position. This ensures stable ordering when multiple\nrenderComponent calls target the same element and one is re-invoked\n(e.g., due to tracked dependency changes).\n\nThe old content's DOM nodes are still present (destruction is async),\nso firstNode() is a valid position reference. The new content is placed\nBEFORE the old content. When the old content is eventually destroyed\n(async clear of bounds), the new content remains in the correct position.",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
-    },
-    {
-      "file": "packages/@ember/-internals/glimmer/lib/renderer.ts",
-      "line": 748,
-      "description": "SAFETY: are there consequences for being looser with *this* owner?\n        the public API for `owner` is kinda `Partial<InternalOwner>`\n        aka: implement only what you need.\n        But for actual ember apps, you *need* to implement everything\n        an app needs (which will actually change and become less over time)",
-      "class": "@ember/renderer",
-      "module": "@ember/renderer"
+      "file": "packages/@ember/-internals/glimmer/lib/router-resolver.ts",
+      "line": 13,
+      "description": "The resolver used by the classic application `Renderer`. It extends the\nshared `ResolverImpl` with the keywords that require the router and engine\ninfrastructure (`{{outlet}}` and `{{mount}}`). Keeping these out of the\nbase resolver means renderers that have no router (e.g. `renderComponent`)\ndo not pull the outlet/engine machinery into the build.",
+      "class": "Ember.Templates.helpers",
+      "module": "@ember/component"
     },
     {
       "file": "packages/@ember/-internals/glimmer/tests/integration/components/render-component-test.ts",
       "line": 445,
       "description": "Test skipped because when an error occurs,\nwe mess up the cache used by renderComponent.",
       "class": "Ember.Templates.helpers",
-      "module": "@ember/renderer"
+      "module": "@ember/component"
     },
     {
       "file": "packages/@ember/-internals/glimmer/tests/integration/components/render-component-test.ts",
@@ -7969,28 +8025,28 @@
         "due\n      to being destroyed."
       ],
       "class": "Ember.Templates.helpers",
-      "module": "@ember/renderer"
+      "module": "@ember/component"
     },
     {
       "file": "packages/@ember/-internals/glimmer/tests/integration/components/render-component-test.ts",
       "line": 759,
       "description": "NOTE: subsequent renders to the same element are prepended to the element's children",
       "class": "Ember.Templates.helpers",
-      "module": "@ember/renderer"
+      "module": "@ember/component"
     },
     {
       "file": "packages/@ember/-internals/glimmer/tests/integration/components/render-component-test.ts",
       "line": 828,
       "description": "ERROR in conflict with the NOTE on this test.\nthe elementns flip locations... which is kinda bonkers",
       "class": "Ember.Templates.helpers",
-      "module": "@ember/renderer"
+      "module": "@ember/component"
     },
     {
       "file": "packages/@ember/-internals/glimmer/tests/integration/components/render-component-test.ts",
       "line": 925,
       "description": "We need to pass a scope so that we get a strict-mode component.",
       "class": "Ember.Templates.helpers",
-      "module": "@ember/renderer"
+      "module": "@ember/component"
     },
     {
       "file": "packages/@ember/-internals/glimmer/tests/integration/components/runtime-template-compiler-implicit-test.ts",
@@ -8003,7 +8059,7 @@
         }
       ],
       "class": "Ember.Templates.helpers",
-      "module": "@ember/renderer"
+      "module": "@ember/component"
     },
     {
       "file": "packages/@ember/-internals/glimmer/index.ts",
@@ -9108,7 +9164,7 @@
     },
     {
       "file": "packages/@ember/-internals/metal/lib/tracked.ts",
-      "line": 14,
+      "line": 15,
       "decorator": "",
       "access": "private",
       "tagname": "Marks a property as tracked.\n\nBy default, a component's properties are expected to be static,\nmeaning you are not able to update them and have the template update accordingly.\nMarking a property as tracked means that when that property changes,\na rerender of the component is scheduled so the template is kept up to date.\n\nThere are two usages for the `@tracked` decorator, shown below.",
@@ -9125,6 +9181,41 @@
       "class": "@ember/owner",
       "module": "@ember/object"
     },
+    {
+      "file": "packages/@ember/-internals/metal/lib/tracked.ts",
+      "line": 77,
+      "description": "Reactivity options for the standalone `tracked(value, options)` form.\n\n- `equals` decides whether writing a value notifies consumers; it defaults to\n  `Object.is`.\n- `description` is used in development for debugging.\n\n`equals` is a function-typed property (rather than method syntax) on purpose:\nthis keeps its parameters checked strictly, so passing an `equals` typed for\nthe wrong value type is a type error instead of being silently accepted.",
+      "class": "@ember/owner",
+      "module": "@ember/object"
+    },
+    {
+      "file": "packages/@ember/-internals/metal/lib/tracked.ts",
+      "line": 93,
+      "description": "Options for `tracked` used as a decorator, or as a field on a *classic* class\n(`EmberObject.extend({ foo: tracked({ value }) })`).\n\nAll properties are optional because this single shape backs several usages:\nclassic-field defaults (`tracked({ value })` / `tracked({ initializer })`) and\noptions-only native decorators (`@tracked({ equals })`). The mutually\nexclusive combinations (e.g. both `value` and `initializer`) and the\nclassic-only restriction on `value`/`initializer` are enforced at runtime via\nassertions rather than in the type, matching the runtime `isDecoratorOptions`\ncheck that accepts any object composed of these keys.\n\n- `value` / `initializer` supply a default value and are only valid on classic\n  classes; native classes use class field initializers instead.\n- `equals` / `description` configure reactivity, mirroring\n  {@link TrackedValueOptions}.",
+      "class": "@ember/owner",
+      "module": "@ember/object"
+    },
+    {
+      "file": "packages/@ember/-internals/metal/lib/tracked.ts",
+      "line": 124,
+      "description": "`tracked` as a decorator factory: `@tracked({ equals })`, or on classic\nclasses `tracked({ value })` / `tracked({ initializer })`.",
+      "class": "@ember/owner",
+      "module": "@ember/object"
+    },
+    {
+      "file": "packages/@ember/-internals/metal/lib/tracked.ts",
+      "line": 129,
+      "description": "`tracked` as a bare decorator: `@tracked foo = 1`.",
+      "class": "@ember/owner",
+      "module": "@ember/object"
+    },
+    {
+      "file": "packages/@ember/-internals/metal/lib/tracked.ts",
+      "line": 138,
+      "description": "`tracked` as a standalone reactive value, usable outside of classes:\n`const count = tracked(0)`.",
+      "class": "@ember/owner",
+      "module": "@ember/object"
+    },
     {
       "file": "packages/@ember/-internals/owner/index.ts",
       "line": 24,
@@ -9759,7 +9850,7 @@
     },
     {
       "file": "packages/@ember/-internals/runtime/lib/mixins/comparable.ts",
-      "line": 22,
+      "line": 23,
       "description": "__Required.__ You must implement this method to apply this mixin.\n\nOverride to return the result of the comparison of the two parameters. The\ncompare method should return:\n\n- `-1` if `a < b`\n- `0` if `a == b`\n- `1` if `a > b`\n\nDefault implementation raises an exception.",
       "itemtype": "method",
       "name": "compare",
@@ -20161,7 +20252,7 @@
     },
     {
       "file": "packages/@ember/utils/lib/compare.ts",
-      "line": 53,
+      "line": 52,
       "description": "Compares two javascript values and returns:\n\n - -1 if the first is smaller than the second,\n - 0 if both are equal,\n - 1 if the first is greater than the second.\n\n ```javascript\n import { compare } from '@ember/utils';\n\n compare('hello', 'hello');  // 0\n compare('abc', 'dfg');      // -1\n compare(2, 1);              // 1\n ```\n\nIf the types of the two objects are different precedence occurs in the\nfollowing order, with types earlier in the list considered `<` types\nlater in the list:\n\n - undefined\n - null\n - boolean\n - number\n - string\n - array\n - object\n - instance\n - function\n - class\n - date\n\n ```javascript\n import { compare } from '@ember/utils';\n\n compare('hello', 50);       // 1\n compare(50, 'hello');       // -1\n ```",
       "itemtype": "method",
       "name": "compare",
@@ -24240,8 +24331,8 @@
     },
     {
       "file": "packages/@glimmer/tracking/index.ts",
-      "line": 17,
-      "description": "Marks a property as tracked. By default, values that are rendered in Ember app\ntemplates are _static_, meaning that updates to them won't cause the\napplication to rerender. Marking a property as tracked means that when that\nproperty changes, any templates that used that property, directly or\nindirectly, will rerender. For instance, consider this component:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\nimport { action } from '@ember/object';\n\nexport default class CounterComponent extends Component {\n  @tracked count = 0;\n\n  get timesTen() {\n    return this.count * 10;\n  }\n\n  @action\n  plusOne() {\n    this.count += 1;\n  }\n  \n  <template>\n    <div>Count: {{this.count}}</div>\n    <div>Times Ten: {{this.timesTen}}</div>\n    <div>\n      <button {{on \"click\" this.plusOne}}>\n        Plus One\n      </button>\n    </div>\n  </template>\n}\n```\n\nBoth the `{{this.count}}` and the `{{this.timesTen}}` properties in the\ntemplate will update whenever the button is clicked. Any tracked properties\nthat are used in any way to calculate a value that is used in the template\nwill cause a rerender when updated - this includes through method calls and\nother means:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\n\nclass Entry {\n  @tracked name;\n  @tracked phoneNumber;\n\n  constructor(name, phoneNumber) {\n    this.name = name;\n    this.phoneNumber = phoneNumber;\n  }\n}\n\nexport default class PhoneBookComponent extends Component {\n  entries = [\n    new Entry('Pizza Palace', 5551234),\n    new Entry('1st Street Cleaners', 5554321),\n    new Entry('Plants R Us', 5552468),\n  ];\n\n  // Any usage of this property will update whenever any of the names in the\n  // entries arrays are updated\n  get names() {\n    return this.entries.map(e => e.name);\n  }\n\n  // Any usage of this property will update whenever any of the numbers in the\n  // entries arrays are updated\n  get numbers() {\n    return this.getFormattedNumbers();\n  }\n\n  getFormattedNumbers() {\n    return this.entries\n      .map(e => e.phoneNumber)\n      .map(number => {\n        let numberString = '' + number;\n\n        return numberString.slice(0, 3) + '-' + numberString.slice(3);\n      });\n  }\n}\n```\n\nIt's important to note that setting tracked properties will always trigger an\nupdate, even if the property is set to the same value as it was before.\n\n```js\nlet entry = new Entry('Pizza Palace', 5551234);\n// if entry was used when rendering, this would cause a rerender, even though\n// the name is being set to the same value as it was before\nentry.name = entry.name;\n```\n\n`tracked` can also be used with the classic Ember object model in a similar\nmanner to classic computed properties:\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked(),\n  phoneNumber: tracked()\n});\n```\n\nOften this is unnecessary, but to ensure robust auto-tracking behavior it is\nadvisable to mark tracked state appropriately wherever possible.\nThis form of `tracked` also accepts an optional configuration object\ncontaining either an initial `value` or an `initializer` function (but not\nboth).\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked({ value: 'Zoey' }),\n  favoriteSongs: tracked({\n    initializer: () => ['Raspberry Beret', 'Time After Time']\n  })\n});\n```",
+      "line": 23,
+      "description": "Marks a property as tracked. By default, values that are rendered in Ember app\ntemplates are _static_, meaning that updates to them won't cause the\napplication to rerender. Marking a property as tracked means that when that\nproperty changes, any templates that used that property, directly or\nindirectly, will rerender. For instance, consider this component:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\nimport { action } from '@ember/object';\n\nexport default class CounterComponent extends Component {\n  @tracked count = 0;\n\n  get timesTen() {\n    return this.count * 10;\n  }\n\n  @action\n  plusOne() {\n    this.count += 1;\n  }\n\n  <template>\n    <div>Count: {{this.count}}</div>\n    <div>Times Ten: {{this.timesTen}}</div>\n    <div>\n      <button {{on \"click\" this.plusOne}}>\n        Plus One\n      </button>\n    </div>\n  </template>\n}\n```\n\nBoth the `{{this.count}}` and the `{{this.timesTen}}` properties in the\ntemplate will update whenever the button is clicked. Any tracked properties\nthat are used in any way to calculate a value that is used in the template\nwill cause a rerender when updated - this includes through method calls and\nother means:\n\n```gjs\nimport Component from '@glimmer/component';\nimport { tracked } from '@glimmer/tracking';\n\nclass Entry {\n  @tracked name;\n  @tracked phoneNumber;\n\n  constructor(name, phoneNumber) {\n    this.name = name;\n    this.phoneNumber = phoneNumber;\n  }\n}\n\nexport default class PhoneBookComponent extends Component {\n  entries = [\n    new Entry('Pizza Palace', 5551234),\n    new Entry('1st Street Cleaners', 5554321),\n    new Entry('Plants R Us', 5552468),\n  ];\n\n  // Any usage of this property will update whenever any of the names in the\n  // entries arrays are updated\n  get names() {\n    return this.entries.map(e => e.name);\n  }\n\n  // Any usage of this property will update whenever any of the numbers in the\n  // entries arrays are updated\n  get numbers() {\n    return this.getFormattedNumbers();\n  }\n\n  getFormattedNumbers() {\n    return this.entries\n      .map(e => e.phoneNumber)\n      .map(number => {\n        let numberString = '' + number;\n\n        return numberString.slice(0, 3) + '-' + numberString.slice(3);\n      });\n  }\n}\n```\n\nIt's important to note that setting tracked properties will always trigger an\nupdate, even if the property is set to the same value as it was before.\n\n```js\nlet entry = new Entry('Pizza Palace', 5551234);\n// if entry was used when rendering, this would cause a rerender, even though\n// the name is being set to the same value as it was before\nentry.name = entry.name;\n```\n\n`tracked` can also be used with the classic Ember object model in a similar\nmanner to classic computed properties:\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked(),\n  phoneNumber: tracked()\n});\n```\n\nOften this is unnecessary, but to ensure robust auto-tracking behavior it is\nadvisable to mark tracked state appropriately wherever possible.\nThis form of `tracked` also accepts an optional configuration object\ncontaining either an initial `value` or an `initializer` function (but not\nboth).\n\n```javascript\nimport EmberObject from '@ember/object';\nimport { tracked } from '@glimmer/tracking';\n\nconst Entry = EmberObject.extend({\n  name: tracked({ value: 'Zoey' }),\n  favoriteSongs: tracked({\n    initializer: () => ['Raspberry Beret', 'Time After Time']\n  })\n});\n```\n\nCalling `tracked` with an initial value creates a standalone reactive\nvalue, usable outside of classes:\n\n```js\nimport { tracked } from '@glimmer/tracking';\n\nconst count = tracked(0);\n\ncount.value;                // read the value, entangling with any tracking context\ncount.value = 1;            // write the value, notifying consumers\ncount.get();                // function shorthand for reading\ncount.set(2);               // function shorthand for writing\ncount.update((n) => n + 1); // write based on the current value, without entangling\ncount.freeze();             // prevent all future writes\n```\n\nReading `value` in a template (or in a getter used by a template) will\nrerender just like a `@tracked` property:\n\n```gjs\nimport { tracked } from '@glimmer/tracking';\nimport { on } from '@ember/modifier';\n\nconst count = tracked(0);\nconst increment = () => count.value++;\n\n<template>\n  Count is: {{count.value}}\n\n  <button {{on \"click\" increment}}>add one</button>\n</template>\n```\n\nThis form accepts an options object containing an `equals` function, which\ndecides whether a written value should notify consumers (it defaults to\n`Object.is`), and a `description` used for debugging:\n\n```js\nconst count = tracked(0, { equals: (a, b) => a === b });\n\ncount.value = 0; // does not notify consumers, the value did not change\n```\n\nNote: when `tracked` is called with a single plain object whose keys are all\ndrawn from `value`, `initializer`, `equals`, and `description`, it is treated\nas the configuration object for a decorator (or classic-class field), not as a\nstandalone value wrapping that object. To create a standalone reactive value\naround such an object, pass it as an initial value and include a (possibly\nempty) options argument: `tracked({ value: 5 }, {})`.\n\nThe `@tracked` decorator accepts the same options. By default, setting a\n`@tracked` property always notifies consumers, even when setting the\nproperty to the same value; passing `equals` opts in to equality-based\nnotification instead:\n\n```js\nimport { tracked } from '@glimmer/tracking';\n\nclass Counter {\n  @tracked({ equals: (a, b) => a === b }) count = 0;\n\n  noop = () => {\n    // does not notify consumers, the value did not change\n    this.count = this.count;\n  };\n}\n```",
       "itemtype": "method",
       "name": "tracked",
       "static": 1,
@@ -24252,7 +24343,7 @@
     },
     {
       "file": "packages/@glimmer/tracking/index.ts",
-      "line": 151,
+      "line": 225,
       "description": "The `@cached` decorator can be used on getters in order to cache the return\nvalue of the getter. This is useful when a getter is expensive and used very\noften. For instance, in this guest list class, we have the `sortedGuests`\ngetter that sorts the guests alphabetically:\n\n```js\nimport { tracked } from '@glimmer/tracking';\n\nclass GuestList {\n  @tracked guests = ['Zoey', 'Tomster'];\n\n  get sortedGuests() {\n    return this.guests.slice().sort()\n  }\n}\n```\n\nEvery time `sortedGuests` is accessed, a new array will be created and sorted,\nbecause JavaScript getters do not cache by default. When the guest list is\nsmall, like the one in the example, this is not a problem. However, if the guest\nlist were to grow very large, it would mean that we would be doing a large\namount of work each time we accessed `sortedGetters`. With `@cached`, we can\ncache the value instead:\n\n```js\nimport { tracked, cached } from '@glimmer/tracking';\n\nclass GuestList {\n  @tracked guests = ['Zoey', 'Tomster'];\n\n  @cached\n  get sortedGuests() {\n    return this.guests.slice().sort()\n  }\n}\n```\n\nNow the `sortedGuests` getter will be cached based on _autotracking_. It will\nonly rerun and create a new sorted array when the `guests` tracked property is\nupdated.\n\nIn general, you should avoid using `@cached` unless you have confirmed that the\ngetter you are decorating is computationally expensive. `@cached` adds a small\namount of overhead to the getter, making it more expensive. While this overhead\nis small, if `@cached` is overused it can add up to a large impact overall in\nyour app. Many getters and tracked properties are only accessed once, rendered,\nand then never rerendered, so adding `@cached` when it is unnecessary can\nnegatively impact performance.",
       "itemtype": "method",
       "name": "cached",
@@ -24366,6 +24457,55 @@
       "class": "TestAdapter",
       "module": "@glimmer/tracking"
     },
+    {
+      "file": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "line": 8,
+      "description": "A mutable reactive value.\n\nReading `value` consumes the underlying tag (entangling with any active\ntracking frame), and writing `value` dirties it.",
+      "class": "TestAdapter",
+      "module": "@glimmer/tracking"
+    },
+    {
+      "file": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "line": 18,
+      "description": "A reactive value that can only be read.",
+      "class": "TestAdapter",
+      "module": "@glimmer/tracking"
+    },
+    {
+      "file": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "line": 37,
+      "description": "The underlying value.\n\nReading entangles with the current tracking frame, and writing notifies\nconsumers (unless the configured `equals` deems the new value equal to\nthe current one).",
+      "class": "TestAdapter",
+      "module": "@glimmer/tracking"
+    },
+    {
+      "file": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "line": 54,
+      "description": "Function short-hand for reading `value`.",
+      "class": "TestAdapter",
+      "module": "@glimmer/tracking"
+    },
+    {
+      "file": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "line": 61,
+      "description": "Function short-hand for assigning `value`.\n\nReturns `true` if the value changed (and consumers were notified),\n`false` if the new value was equal to the current one.",
+      "class": "TestAdapter",
+      "module": "@glimmer/tracking"
+    },
+    {
+      "file": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "line": 87,
+      "description": "Update the value based on the current value, without consuming it.",
+      "class": "TestAdapter",
+      "module": "@glimmer/tracking"
+    },
+    {
+      "file": "packages/@glimmer/validator/lib/tracked-value.ts",
+      "line": 94,
+      "description": "Prevents further updates, making the TrackedValue behave as a\nReadOnlyReactive.",
+      "class": "TestAdapter",
+      "module": "@glimmer/tracking"
+    },
     {
       "file": "packages/@glimmer/validator/lib/tracking.ts",
       "line": 10,
@@ -24541,7 +24681,7 @@
     },
     {
       "message": "unknown tag: note",
-      "line": " packages/@ember/-internals/glimmer/lib/helper.ts:325"
+      "line": " packages/@ember/-internals/glimmer/lib/helper.ts:319"
     },
     {
       "message": "unknown tag: decorator",
@@ -24549,7 +24689,7 @@
     },
     {
       "message": "unknown tag: decorator",
-      "line": " packages/@ember/-internals/metal/lib/tracked.ts:14"
+      "line": " packages/@ember/-internals/metal/lib/tracked.ts:15"
     },
     {
       "message": "unknown tag: internal",
@@ -24715,6 +24855,10 @@
       "message": "unknown tag: debug",
       "line": " packages/@glimmer/runtime/lib/scope.ts:86"
     },
+    {
+      "message": "Missing item type\nThe brand for the curly component manager lives in its own module so that\ncode which only needs to *detect* the curly manager (e.g. the resolver)\ndoes not have to import the manager itself (and with it the classic\ncomponent machinery).",
+      "line": " packages/@ember/-internals/glimmer/lib/component-managers/curly-brand.ts:1"
+    },
     {
       "message": "Missing item type\nThis \"upgrades\" a route template into a invocable component. Conceptually\nit can be 1:1 for each unique `Template`, but it's also cheap to construct,\nso unless the stability is desirable for other reasons, it's probably not\nworth caching this.",
       "line": " packages/@ember/-internals/glimmer/lib/component-managers/route-template.ts:113"
@@ -24784,68 +24928,80 @@
       "line": " packages/@ember/-internals/glimmer/lib/views/outlet.ts:122"
     },
     {
-      "message": "Missing item type",
-      "line": " packages/@ember/-internals/glimmer/lib/helper.ts:135"
-    },
-    {
-      "message": "Missing item type\nThe type of a function-based helper.",
-      "line": " packages/@ember/-internals/glimmer/lib/helper.ts:325"
+      "message": "Missing item type\nThe interface the `RendererState` needs from a render root. The base\nrenderer only ever creates `ComponentRootState`s; the classic renderer\n(`./renderer`) adds `ClassicRootState` for outlet/classic-component roots.",
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:68"
     },
     {
       "message": "Missing item type\nDestroys the render tree and removes all rendered content from the element rendered into",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:552"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:413"
     },
     {
       "message": "Missing item type\nThe GlimmerRenderResult from the last render. Used to get positional\ninformation (firstNode) when a re-render replaces the content, so\nthat the new content is placed at the same DOM position.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:560"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:421"
     },
     {
       "message": "Missing item type\nThe component definition to render.\n\nAny component that has had its manager registered is valid.\nFor the component-types that ship with ember, manager registration\ndoes not need to be worried about.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:591"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:452"
     },
     {
       "message": "Missing item type\nThe element to render the component in to.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:605"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:466"
     },
     {
       "message": "Missing item type\nOptional owner. Defaults to `{}`, can be any object, but will need to implement the [Owner](https://api.emberjs.com/ember/release/classes/Owner) API for components within this render tree to access services.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:610"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:471"
     },
     {
       "message": "Missing item type\nOptionally configure the rendering environment",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:614"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:475"
     },
     {
       "message": "Missing item type\nWhen false, modifiers will not run.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:618"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:479"
     },
     {
       "message": "Missing item type\nAll other options are forwarded to the underlying renderer.\n(its API is currently private and out of scope for this RFC,\n so passing additional things here is also considered private API)",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:622"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:483"
     },
     {
       "message": "Missing item type\nThese args get passed to the rendered component\n\nIf your args are reactive, re-rendering will happen automatically.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:630"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:491"
     },
     {
       "message": "Missing item type\nSAFETY: we should figure out what we need out of a `document` and narrow the API.\n        this exercise should also end up beginning to define what we need for CLI rendering (or to other outputs)",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:639"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:500"
     },
     {
       "message": "Missing item type\nReplace all contents, if we've rendered multiple times.\n\nhttps://github.com/emberjs/rfcs/pull/1099/files#diff-2b962105b9083ca84579cdc957f27f49407440f3c5078083fa369ec18cc46da8R365\n\nWe could later add an option to not do this behavior\n\nNOTE: destruction is async",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:660"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:521"
     },
     {
       "message": "Missing item type\nWe can only replace the inner HTML the first time.\nBecause destruction is async, it won't be safe to\ndo this again, and we'll have to rely on the above destroy.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:671"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:532"
     },
     {
       "message": "Missing item type\nIf there's an existing render result with valid bounds, use its\nfirstNode as the nextSibling so that new content is inserted at\nthe same DOM position. This ensures stable ordering when multiple\nrenderComponent calls target the same element and one is re-invoked\n(e.g., due to tracked dependency changes).\n\nThe old content's DOM nodes are still present (destruction is async),\nso firstNode() is a valid position reference. The new content is placed\nBEFORE the old content. When the old content is eventually destroyed\n(async clear of bounds), the new content remains in the correct position.",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:680"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:541"
     },
     {
       "message": "Missing item type\nSAFETY: are there consequences for being looser with *this* owner?\n        the public API for `owner` is kinda `Partial<InternalOwner>`\n        aka: implement only what you need.\n        But for actual ember apps, you *need* to implement everything\n        an app needs (which will actually change and become less over time)",
-      "line": " packages/@ember/-internals/glimmer/lib/renderer.ts:748"
+      "line": " packages/@ember/-internals/glimmer/lib/base-renderer.ts:609"
+    },
+    {
+      "message": "Missing item type\nThe brand for classic (class-based) helpers lives in its own module so that\ncode which only needs to *detect* classic helpers (e.g. the resolver) does\nnot have to import the classic `Helper` base class (and with it the classic\nobject model: `EmberObject`, `Mixin`, meta, etc.).",
+      "line": " packages/@ember/-internals/glimmer/lib/helper-brand.ts:1"
+    },
+    {
+      "message": "Missing item type",
+      "line": " packages/@ember/-internals/glimmer/lib/helper.ts:135"
+    },
+    {
+      "message": "Missing item type\nThe type of a function-based helper.",
+      "line": " packages/@ember/-internals/glimmer/lib/helper.ts:319"
+    },
+    {
+      "message": "Missing item type\nThe resolver used by the classic application `Renderer`. It extends the\nshared `ResolverImpl` with the keywords that require the router and engine\ninfrastructure (`{{outlet}}` and `{{mount}}`). Keeping these out of the\nbase resolver means renderers that have no router (e.g. `renderComponent`)\ndo not pull the outlet/engine machinery into the build.",
+      "line": " packages/@ember/-internals/glimmer/lib/router-resolver.ts:13"
     },
     {
       "message": "Missing item type\nTest skipped because when an error occurs,\nwe mess up the cache used by renderComponent.",
@@ -25045,7 +25201,27 @@
     },
     {
       "message": "Missing item type",
-      "line": " packages/@ember/-internals/metal/lib/tracked.ts:14"
+      "line": " packages/@ember/-internals/metal/lib/tracked.ts:15"
+    },
+    {
+      "message": "Missing item type\nReactivity options for the standalone `tracked(value, options)` form.\n\n- `equals` decides whether writing a value notifies consumers; it defaults to\n  `Object.is`.\n- `description` is used in development for debugging.\n\n`equals` is a function-typed property (rather than method syntax) on purpose:\nthis keeps its parameters checked strictly, so passing an `equals` typed for\nthe wrong value type is a type error instead of being silently accepted.",
+      "line": " packages/@ember/-internals/metal/lib/tracked.ts:77"
+    },
+    {
+      "message": "Missing item type\nOptions for `tracked` used as a decorator, or as a field on a *classic* class\n(`EmberObject.extend({ foo: tracked({ value }) })`).\n\nAll properties are optional because this single shape backs several usages:\nclassic-field defaults (`tracked({ value })` / `tracked({ initializer })`) and\noptions-only native decorators (`@tracked({ equals })`). The mutually\nexclusive combinations (e.g. both `value` and `initializer`) and the\nclassic-only restriction on `value`/`initializer` are enforced at runtime via\nassertions rather than in the type, matching the runtime `isDecoratorOptions`\ncheck that accepts any object composed of these keys.\n\n- `value` / `initializer` supply a default value and are only valid on classic\n  classes; native classes use class field initializers instead.\n- `equals` / `description` configure reactivity, mirroring\n  {@link TrackedValueOptions}.",
+      "line": " packages/@ember/-internals/metal/lib/tracked.ts:93"
+    },
+    {
+      "message": "Missing item type\n`tracked` as a decorator factory: `@tracked({ equals })`, or on classic\nclasses `tracked({ value })` / `tracked({ initializer })`.",
+      "line": " packages/@ember/-internals/metal/lib/tracked.ts:124"
+    },
+    {
+      "message": "Missing item type\n`tracked` as a bare decorator: `@tracked foo = 1`.",
+      "line": " packages/@ember/-internals/metal/lib/tracked.ts:129"
+    },
+    {
+      "message": "Missing item type\n`tracked` as a standalone reactive value, usable outside of classes:\n`const count = tracked(0)`.",
+      "line": " packages/@ember/-internals/metal/lib/tracked.ts:138"
     },
     {
       "message": "Missing item type\nA type registry for the DI system, which other participants in the DI system\ncan register themselves into with declaration merging. The contract for this\ntype is that its keys are the `Type` from a `FullName`, and each value for a\n`Type` is another registry whose keys are the `Name` from a `FullName`. The\nmechanic for providing a registry is [declaration merging][handbook].\n\n[handbook]: https://www.typescriptlang.org/docs/handbook/declaration-merging.html\n\nFor example, Ember's `@ember/service` module includes this set of definitions:\n\n```ts\nexport default class Service extends EmberObject {}\n\n// For concrete singleton classes to be merged into.\ninterface Registry extends Record<string, Service> {}\n\ndeclare module '@ember/owner' {\n  service: Registry;\n}\n```\n\nDeclarations of services can then include the registry:\n\n```ts\nimport Service from '@ember/service';\n\nexport default class Session extends Service {\n  login(username: string, password: string) {\n    // ...\n  }\n}\n\ndeclare module '@ember/service' {\n  interface Registry {\n    session: Session;\n  }\n}\n```\n\nThen users of the `Owner` API will be able to do things like this with strong\ntype safety guarantees:\n\n```ts\ngetOwner(this)?.lookup('service:session').login(\"hello\", \"1234abcd\");\n```",
@@ -27475,6 +27651,34 @@
       "message": "Missing item type\nCreates a global autotracking transaction. This will prevent any backflow\nin any `track` calls within the transaction, even if they are not\nexternally consumed.\n\n`runInAutotrackingTransaction` can be called within itself, and it will add\nonto the existing transaction if one exists.\n\nTODO: Only throw an error if the `track` is consumed.",
       "line": " packages/@glimmer/validator/lib/debug.ts:104"
     },
+    {
+      "message": "Missing item type\nA mutable reactive value.\n\nReading `value` consumes the underlying tag (entangling with any active\ntracking frame), and writing `value` dirties it.",
+      "line": " packages/@glimmer/validator/lib/tracked-value.ts:8"
+    },
+    {
+      "message": "Missing item type\nA reactive value that can only be read.",
+      "line": " packages/@glimmer/validator/lib/tracked-value.ts:18"
+    },
+    {
+      "message": "Missing item type\nThe underlying value.\n\nReading entangles with the current tracking frame, and writing notifies\nconsumers (unless the configured `equals` deems the new value equal to\nthe current one).",
+      "line": " packages/@glimmer/validator/lib/tracked-value.ts:37"
+    },
+    {
+      "message": "Missing item type\nFunction short-hand for reading `value`.",
+      "line": " packages/@glimmer/validator/lib/tracked-value.ts:54"
+    },
+    {
+      "message": "Missing item type\nFunction short-hand for assigning `value`.\n\nReturns `true` if the value changed (and consumers were notified),\n`false` if the new value was equal to the current one.",
+      "line": " packages/@glimmer/validator/lib/tracked-value.ts:61"
+    },
+    {
+      "message": "Missing item type\nUpdate the value based on the current value, without consuming it.",
+      "line": " packages/@glimmer/validator/lib/tracked-value.ts:87"
+    },
+    {
+      "message": "Missing item type\nPrevents further updates, making the TrackedValue behave as a\nReadOnlyReactive.",
+      "line": " packages/@glimmer/validator/lib/tracked-value.ts:94"
+    },
     {
       "message": "Missing item type\nAn object that that tracks @tracked properties that were consumed.",
       "line": " packages/@glimmer/validator/lib/tracking.ts:10"