ember-source 6.3.0-beta.1 → 6.3.0

package/build-metadata.json

@@ -1,6 +1,6 @@
 {
-  "version": "6.3.0-beta.1",
+  "version": "6.3.0",
   "buildType": "tag",
-  "SHA": "46ffedacedc31d19f084941bd88ffa76fd18c3c6",
-  "assetPath": "/tag/shas/46ffedacedc31d19f084941bd88ffa76fd18c3c6.tgz"
+  "SHA": "043ab68a76da672c5d15b174fd897fab70136ae0",
+  "assetPath": "/tag/shas/043ab68a76da672c5d15b174fd897fab70136ae0.tgz"
 }

package/dist/ember-template-compiler.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   6.3.0-beta.1
+ * @version   6.3.0
  */
 /* eslint-disable no-var */
 /* globals global globalThis self */
@@ -15638,7 +15638,7 @@ var define, require;
           }, Symbol.toStringTag, { value: 'Module' });
 
           // this file gets replaced with the real value during the build
-          const version = '6.3.0-beta.1';
+          const version = '6.3.0';
 
           const emberVersion = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,

package/dist/ember-testing.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   6.3.0-beta.1
+ * @version   6.3.0
  */
 /* eslint-disable no-var */
 /* globals global globalThis self */

package/dist/ember.debug.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   6.3.0-beta.1
+ * @version   6.3.0
  */
 /* eslint-disable no-var */
 /* globals global globalThis self */
@@ -3366,7 +3366,7 @@ var define, require;
           }, Symbol.toStringTag, { value: 'Module' });
 
           // this file gets replaced with the real value during the build
-          const Version = '6.3.0-beta.1';
+          const Version = '6.3.0';
 
           const emberVersion = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,

package/dist/ember.prod.js

@@ -5,7 +5,7 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   6.3.0-beta.1
+ * @version   6.3.0
  */
 /* eslint-disable no-var */
 /* globals global globalThis self */
@@ -2607,7 +2607,7 @@ var define, require;
           }, Symbol.toStringTag, { value: 'Module' });
 
           // this file gets replaced with the real value during the build
-          const Version = '6.3.0-beta.1';
+          const Version = '6.3.0';
 
           const emberVersion = /*#__PURE__*/Object.defineProperty({
                     __proto__: null,

package/dist/packages/ember/version.js

@@ -1,4 +1,4 @@
 // this file gets replaced with the real value during the build
-const Version = '6.3.0-beta.1';
+const Version = '6.3.0';
 
 export { Version as default };

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": "6.3.0-beta.1"
+    "version": "6.3.0"
   },
   "files": {
     "node_modules/rsvp/lib/rsvp/promise/all.js": {
@@ -529,9 +529,7 @@
     },
     "packages/@ember/-internals/glimmer/lib/glimmer-tracking-docs.ts": {
       "name": "packages/@ember/-internals/glimmer/lib/glimmer-tracking-docs.ts",
-      "modules": {
-        "@glimmer/tracking": 1
-      },
+      "modules": {},
       "classes": {},
       "fors": {
         "@glimmer/tracking": 1
@@ -1727,6 +1725,68 @@
       },
       "namespaces": {}
     },
+    "packages/@glimmer/component/dist/-private/component.d.ts": {
+      "name": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
+    "packages/@glimmer/component/dist/-private/ember-component-manager.d.ts": {
+      "name": "packages/@glimmer/component/dist/-private/ember-component-manager.d.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
+    "packages/@glimmer/component/dist/index.d.ts": {
+      "name": "packages/@glimmer/component/dist/index.d.ts",
+      "modules": {
+        "@glimmer/component": 1
+      },
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
+    "packages/@glimmer/component/dist/index.js": {
+      "name": "packages/@glimmer/component/dist/index.js",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
+    "packages/@glimmer/component/src/-private/component.ts": {
+      "name": "packages/@glimmer/component/src/-private/component.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
+    "packages/@glimmer/component/src/-private/ember-component-manager.ts": {
+      "name": "packages/@glimmer/component/src/-private/ember-component-manager.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
+    "packages/@glimmer/component/src/index.ts": {
+      "name": "packages/@glimmer/component/src/index.ts",
+      "modules": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {}
+    },
+    "packages/@glimmer/tracking/index.ts": {
+      "name": "packages/@glimmer/tracking/index.ts",
+      "modules": {
+        "@glimmer/tracking": 1
+      },
+      "classes": {},
+      "fors": {
+        "@glimmer/tracking": 1
+      },
+      "namespaces": {}
+    },
     "packages/ember-testing/lib/adapters/adapter.ts": {
       "name": "packages/ember-testing/lib/adapters/adapter.ts",
       "modules": {},
@@ -2009,9 +2069,9 @@
       },
       "namespaces": {},
       "tag": "module",
-      "file": "packages/@ember/-internals/glimmer/lib/glimmer-tracking-docs.ts",
-      "line": 1,
-      "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.\n\n### Caching a getter value\n\nThe `@cached` decorator can be used on getters in order to cache the\nreturn value of the getter.\n\nThis method adds an extra overhead to each memoized getter, therefore caching\nthe values should not be the default strategy, but used in last resort.",
+      "file": "packages/@glimmer/tracking/index.ts",
+      "line": 3,
+      "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": ""
     },
@@ -2611,6 +2671,20 @@
       "access": "public",
       "tagname": ""
     },
+    "@glimmer/component": {
+      "name": "@glimmer/component",
+      "submodules": {},
+      "elements": {},
+      "classes": {},
+      "fors": {},
+      "namespaces": {},
+      "tag": "module",
+      "file": "packages/@glimmer/component/dist/index.d.ts",
+      "line": 3,
+      "description": "A component is a reusable UI element that consists of a `.hbs` template and an\noptional JavaScript class that defines its behavior. For example, someone\nmight make a `button` in the template and handle the click behavior in the\nJavaScript file that shares the same name as the template.\n\nComponents are broken down into two categories:\n\n- Components _without_ JavaScript, that are based only on a template. These\n  are called Template-only or TO components.\n- Components _with_ JavaScript, which consist of a template and a backing\n  class.\n\nEmber ships with two types of JavaScript classes for components:\n\n1. Glimmer components, imported from `@glimmer/component`, which are the\n   default components for Ember Octane (3.15) and more recent editions.\n2. Classic components, imported from `@ember/component`, which were the\n   default for older editions of Ember (pre 3.15).\n\nBelow is the documentation for Template-only and Glimmer components. If you\nare looking for the API documentation for Classic components, it is\n[available here](/ember/release/classes/Component). The source code for\nGlimmer components can be found in [`@glimmer/component`](https://github.com/glimmerjs/glimmer.js/tree/master/packages/%40glimmer/component).\n\n## Defining a Template-only Component\n\nThe simplest way to create a component is to create a template file in\n`app/templates/components`. For example, if you name a template\n`app/templates/components/person-profile.hbs`:\n\n```app/templates/components/person-profile.hbs\n<h1>{{@person.name}}</h1>\n<img src={{@person.avatar}}>\n<p class='signature'>{{@person.signature}}</p>\n```\n\nYou will be able to use `<PersonProfile />` to invoke this component elsewhere\nin your application:\n\n```app/templates/application.hbs\n<PersonProfile @person={{this.currentUser}} />\n```\n\nNote that component names are capitalized here in order to distinguish them\nfrom regular HTML elements, but they are dasherized in the file system.\n\nWhile the angle bracket invocation form is generally preferred, it is also\npossible to invoke the same component with the `{{person-profile}}` syntax:\n\n```app/templates/application.hbs\n{{person-profile person=this.currentUser}}\n```\n\nNote that with this syntax, you use dashes in the component name and\narguments are passed without the `@` sign.\n\nIn both cases, Ember will render the content of the component template we\ncreated above. The end result will be something like this:\n\n```html\n<h1>Tomster</h1>\n<img src=\"https://emberjs.com/tomster.jpg\">\n<p class='signature'>Out of office this week</p>\n```\n\n## File System Nesting\n\nComponents can be nested inside sub-folders for logical groupping. For\nexample, if we placed our template in\n`app/templates/components/person/short-profile.hbs`, we can invoke it as\n`<Person::ShortProfile />`:\n\n```app/templates/application.hbs\n<Person::ShortProfile @person={{this.currentUser}} />\n```\n\nOr equivalently, `{{person/short-profile}}`:\n\n```app/templates/application.hbs\n{{person/short-profile person=this.currentUser}}\n```\n\n## Using Blocks\n\nYou can use `yield` inside a template to include the **contents** of any block\nattached to the component. For instance, if we added a `{{yield}}` to our\ncomponent like so:\n\n```app/templates/components/person-profile.hbs\n<h1>{{@person.name}}</h1>\n{{yield}}\n```\n\nWe could then invoke it like this:\n\n```handlebars\n<PersonProfile @person={{this.currentUser}}>\n  <p>Admin mode</p>\n</PersonProfile>\n```\n\nor with curly syntax like this:\n\n```handlebars\n{{#person-profile person=this.currentUser}}\n  <p>Admin mode</p>\n{{/person-profile}}\n```\n\nAnd the content passed in between the brackets of the component would be\nrendered in the same place as the `{{yield}}` within it, replacing it.\n\nBlocks are executed in their original context, meaning they have access to the\nscope and any in-scope variables where they were defined.\n\n### Passing parameters to blocks\n\nYou can also pass positional parameters to `{{yield}}`, which are then made\navailable in the block:\n\n```app/templates/components/person-profile.hbs\n<h1>{{@person.name}}</h1>\n{{yield @person.signature}}\n```\n\nWe can then use this value in the block like so:\n\n```handlebars\n<PersonProfile @person={{this.currentUser}} as |signature|>\n  {{signature}}\n</PersonProfile>\n```\n\n### Passing multiple blocks\n\nYou can pass multiple blocks to a component by giving them names, and\nspecifying which block you are yielding to with `{{yield}}`. For instance, if\nwe wanted to add a way for users to customize the title of our\n`<PersonProfile>` component, we could add a named block inside of the header:\n\n```app/templates/components/person-profile.hbs\n<h1>{{yield to=\"title\"}}</h1>\n{{yield}}\n```\n\nThis component could then be invoked like so:\n\n```handlebars\n<PersonProfile @person={{this.currentUser}}>\n  <:title>{{this.currentUser.name}}</:title>\n  <:default>{{this.currentUser.signature}}</:default>\n</PersonProfile>\n```\n\nWhen passing named blocks, you must name every block, including the `default`\nblock, which is the block that is defined if you do not pass a `to` parameter\nto `{{yield}}`. Whenever you invoke a component without passing explicitly\nnamed blocks, the passed block is considered the `default` block.\n\n### Passing parameters to named blocks\n\nYou can also pass parameters to named blocks:\n\n```app/templates/components/person-profile.hbs\n<h1>{{yield @person.name to=\"title\"}}</h1>\n{{yield @person.signature}}\n```\n\nThese parameters can then be used like so:\n\n```handlebars\n<PersonProfile @person={{this.currentUser}}>\n  <:title as |name|>{{name}}</:title>\n  <:default as |signature|>{{signature}}</:default>\n</PersonProfile>\n```\n\n### Checking to see if a block exists\n\nYou can also check to see if a block exists using the `(has-block)` keyword,\nand conditionally use it, or provide a default template instead.\n\n```app/templates/components/person-profile.hbs\n<h1>\n  {{#if (has-block \"title\")}}\n    {{yield @person.name to=\"title\"}}\n  {{else}}\n    {{@person.name}}\n  {{/if}}\n</h1>\n\n{{#if (has-block)}}\n  {{yield @person.signature}}\n{{else}}\n  {{@person.signature}}\n{{/if}}\n```\n\nWith this template, we can then optionally pass in one block, both blocks, or\nnone at all:\n\n```handlebars\n{{! passing both blocks }}\n<PersonProfile @person={{this.currentUser}}>\n  <:title as |name|>{{name}}</:title>\n  <:default as |signature|>{{signature}}</:default>\n</PersonProfile>\n\n{{! passing just the title block }}\n<PersonProfile @person={{this.currentUser}}>\n  <:title as |name|>{{name}}</:title>\n</PersonProfile>\n\n{{! passing just the default block }}\n<PersonProfile @person={{this.currentUser}} as |signature|>\n  {{signature}}\n</PersonProfile>\n\n{{! not passing any blocks }}\n<PersonProfile @person={{this.currentUser}}/>\n```\n\n### Checking to see if a block has parameters\n\nWe can also check if a block receives parameters using the `(has-block-params)`\nkeyword, and conditionally yield different values if so.\n\n```app/templates/components/person-profile.hbs\n{{#if (has-block-params)}}\n  {{yield @person.signature}}\n{{else}}\n  {{yield}}\n{{/if}}\n```\n\n## Customizing Components With JavaScript\n\nTo add JavaScript to a component, create a JavaScript file in the same\nlocation as the template file, with the same name, and export a subclass\nof `Component` as the default value. For example, to add Javascript to the\n`PersonProfile` component which we defined above, we would create\n`app/components/person-profile.js` and export our class as the default, like\nso:\n\n```app/components/person-profile.js\nimport Component from '@glimmer/component';\n\nexport default class PersonProfileComponent extends Component {\n  get displayName() {\n    let { title, firstName, lastName } = this.args.person;\n\n    if (title) {\n      return `${title} ${lastName}`;\n    } else {\n      return `${firstName} ${lastName}`;\n    }\n  })\n}\n```\n\nYou can add your own properties, methods, and lifecycle hooks to this\nsubclass to customize its behavior, and you can reference the instance of the\nclass in your template using `{{this}}`. For instance, we could access the\n`displayName` property of our `PersonProfile` component instance in the\ntemplate like this:\n\n```app/templates/components/person-profile.hbs\n<h1>{{this.displayName}}</h1>\n{{yield}}\n```\n\n## `constructor`\n\nparams: `owner` object and `args` object\n\nConstructs a new component and assigns itself the passed properties. The\nconstructor is run whenever a new instance of the component is created, and\ncan be used to setup the initial state of the component.\n\n```javascript\nimport Component from '@glimmer/component';\n\nexport default class SomeComponent extends Component {\n  constructor(owner, args) {\n    super(owner, args);\n\n    if (this.args.displayMode === 'list') {\n      this.items = [];\n    }\n  }\n}\n```\n\nService injections and arguments are available in the constructor.\n\n```javascript\nimport Component from '@glimmer/component';\nimport { service } from '@ember/service';\n\nexport default class SomeComponent extends Component {\n  @service myAnimations;\n\n  constructor(owner, args) {\n    super(owner, args);\n\n    if (this.args.fadeIn === true) {\n      this.myAnimations.register(this, 'fade-in');\n    }\n  }\n}\n```\n\n## `willDestroy`\n\n`willDestroy` is called after the component has been removed from the DOM, but\nbefore the component is fully destroyed. This lifecycle hook can be used to\ncleanup the component and any related state.\n\n```javascript\nimport Component from '@glimmer/component';\nimport { service } from '@ember/service';\n\nexport default class SomeComponent extends Component {\n  @service myAnimations;\n\n  willDestroy() {\n    super.willDestroy(...arguments);\n\n    this.myAnimations.unregister(this);\n  }\n}\n```\n\n## `args`\n\nThe `args` property of Glimmer components is an object that contains the\n_arguments_ that are passed to the component. For instance, the\nfollowing component usage:\n\n```handlebars\n<SomeComponent @fadeIn={{true}} />\n```\n\nWould result in the following `args` object to be passed to the component:\n\n```javascript\n{ fadeIn: true }\n```\n\n`args` can be accessed at any point in the component lifecycle, including\n`constructor` and `willDestroy`. They are also automatically marked as tracked\nproperties, and they can be depended on as computed property dependencies:\n\n```javascript\nimport Component from '@glimmer/component';\nimport { computed } from '@ember/object';\n\nexport default class SomeComponent extends Component {\n\n  @computed('args.someValue')\n  get computedGetter() {\n    // updates whenever args.someValue updates\n    return this.args.someValue;\n  }\n\n  get standardGetter() {\n    // updates whenever args.anotherValue updates (Ember 3.13+)\n    return this.args.anotherValue;\n  }\n}\n```\n\n## `isDestroying`\n\nA boolean flag to tell if the component is in the process of destroying. This is set to\ntrue before `willDestroy` is called.\n\n## `isDestroyed`\nA boolean to tell if the component has been fully destroyed. This is set to true\nafter `willDestroy` is called.",
+      "access": "public",
+      "tagname": ""
+    },
     "@ember/test": {
       "name": "@ember/test",
       "submodules": {},
@@ -18896,6 +18970,252 @@
       "class": "@ember/utils",
       "module": "@ember/utils"
     },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 10,
+      "description": "This provides us a way to have a \"fallback\" which represents an empty object,\nwithout the downsides of how TS treats `{}`. Specifically: this will\ncorrectly leverage \"excess property checking\" so that, given a component\nwhich has no named args, if someone invokes it with any named args, they will\nget a type error.",
+      "internal": "This is exported so declaration emit works (if it were not emitted,\n  declarations which fall back to it would not work). It is *not* intended for\n  public usage, and the specific mechanics it uses may change at any time.\n  The location of this export *is* part of the public API, because moving it\n  will break existing declarations, but is not legal for end users to import\n  themselves, so ***DO NOT RELY ON IT***.",
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 30,
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 62,
+      "description": "Given any allowed shorthand form of a signature, desugars it to its full\nexpanded type.",
+      "internal": "This is only exported so we can avoid duplicating it in\n  [Glint](https://github.com/typed-ember/glint) or other such tooling. It is\n  *not* intended for public usage, and the specific mechanics it uses may\n  change at any time. Although the signature produced by is part of Glimmer's\n  public API the existence and mechanics of this specific symbol are *not*,\n  so ***DO NOT RELY ON IT***.",
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 74,
+      "internal": "we use this type for convenience internally; inference means users\n  should not normally need to name it",
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 79,
+      "description": "The `Component` class defines an encapsulated UI element that is rendered to\nthe DOM. A component is made up of a template and, optionally, this component\nobject.\n\n## Defining a Component\n\nTo define a component, subclass `Component` and add your own properties,\nmethods and lifecycle hooks:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n}\n```\n\n## Lifecycle Hooks\n\nLifecycle hooks allow you to respond to changes to a component, such as when\nit gets created, rendered, updated or destroyed. To add a lifecycle hook to a\ncomponent, implement the hook as a method on your component subclass.\n\nFor example, to be notified when Glimmer has rendered your component so you\ncan attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  didInsertElement() {\n    $(this.element).pickadate();\n  }\n}\n```\n\n## Data for Templates\n\n`Component`s have two different kinds of data, or state, that can be\ndisplayed in templates:\n\n1. Arguments\n2. Properties\n\nArguments are data that is passed in to a component from its parent\ncomponent. For example, if I have a `UserGreeting` component, I can pass it\na name and greeting to use:\n\n```hbs\n<UserGreeting @name=\"Ricardo\" @greeting=\"Olá\" />\n```\n\nInside my `UserGreeting` template, I can access the `@name` and `@greeting`\narguments that I've been given:\n\n```hbs\n{{@greeting}}, {{@name}}!\n```\n\nArguments are also available inside my component:\n\n```ts\nconsole.log(this.args.greeting); // prints \"Olá\"\n```\n\nProperties, on the other hand, are internal to the component and declared in\nthe class. You can use properties to store data that you want to show in the\ntemplate, or pass to another component as an argument.\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  user = {\n    name: 'Robbie'\n  }\n}\n```\n\nIn the above example, we've defined a component with a `user` property that\ncontains an object with its own `name` property.\n\nWe can render that property in our template:\n\n```hbs\nHello, {{user.name}}!\n```\n\nWe can also take that property and pass it as an argument to the\n`UserGreeting` component we defined above:\n\n```hbs\n<UserGreeting @greeting=\"Hello\" @name={{user.name}} />\n```\n\n## Arguments vs. Properties\n\nRemember, arguments are data that was given to your component by its parent\ncomponent, and properties are data your component has defined for itself.\n\nYou can tell the difference between arguments and properties in templates\nbecause arguments always start with an `@` sign (think \"A is for arguments\"):\n\n```hbs\n{{@firstName}}\n```\n\nWe know that `@firstName` came from the parent component, not the current\ncomponent, because it starts with `@` and is therefore an argument.\n\nOn the other hand, if we see:\n\n```hbs\n{{name}}\n```\n\nWe know that `name` is a property on the component. If we want to know where\nthe data is coming from, we can go look at our component class to find out.\n\nInside the component itself, arguments always show up inside the component's\n`args` property. For example, if `{{@firstName}}` is `Tom` in the template,\ninside the component `this.args.firstName` would also be `Tom`.",
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 203,
+      "description": "Constructs a new component and assigns itself the passed properties. You\nshould not construct new components yourself. Instead, Glimmer will\ninstantiate new components automatically as it renders.",
+      "params": [
+        {
+          "name": "owner",
+          "description": ""
+        },
+        {
+          "name": "args",
+          "description": ""
+        }
+      ],
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 212,
+      "description": "Named arguments passed to the component from its parent component.\nThey can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n\nSay you have the following component, which will have two `args`, `firstName` and `lastName`:\n\n```hbs\n<my-component @firstName=\"Arthur\" @lastName=\"Dent\" />\n```\n\nIf you needed to calculate `fullName` by combining both of them, you would do:\n\n```ts\ndidInsertElement() {\n  console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n}\n```\n\nWhile in the template you could do:\n\n```hbs\n<p>Welcome, {{@firstName}} {{@lastName}}!</p>\n```",
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/component.d.ts",
+      "line": 239,
+      "description": "Called before the component has been removed from the DOM.",
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/-private/ember-component-manager.d.ts",
+      "line": 4,
+      "description": "This component manager runs in Ember.js environments and extends the base component manager to:\n\n1. Properly destroy the component's associated `meta` data structure\n2. Schedule destruction using Ember's runloop",
+      "class": "@glimmer/tracking",
+      "module": "@ember/utils"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 32,
+      "description": "This provides us a way to have a \"fallback\" which represents an empty object,\nwithout the downsides of how TS treats `{}`. Specifically: this will\ncorrectly leverage \"excess property checking\" so that, given a component\nwhich has no named args, if someone invokes it with any named args, they will\nget a type error.",
+      "internal": "This is exported so declaration emit works (if it were not emitted,\n  declarations which fall back to it would not work). It is *not* intended for\n  public usage, and the specific mechanics it uses may change at any time.\n  The location of this export *is* part of the public API, because moving it\n  will break existing declarations, but is not legal for end users to import\n  themselves, so ***DO NOT RELY ON IT***.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 47,
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 49,
+      "description": "Given any allowed shorthand form of a signature, desugars it to its full\nexpanded type.",
+      "internal": "This is only exported so we can avoid duplicating it in\n  [Glint](https://github.com/typed-ember/glint) or other such tooling. It is\n  *not* intended for public usage, and the specific mechanics it uses may\n  change at any time. Although the signature produced by is part of Glimmer's\n  public API the existence and mechanics of this specific symbol are *not*,\n  so ***DO NOT RELY ON IT***.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 66,
+      "internal": "we use this type for convenience internally; inference means users\n  should not normally need to name it",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 71,
+      "description": "The `Component` class defines an encapsulated UI element that is rendered to\nthe DOM. A component is made up of a template and, optionally, this component\nobject.\n\n## Defining a Component\n\nTo define a component, subclass `Component` and add your own properties,\nmethods and lifecycle hooks:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n}\n```\n\n## Lifecycle Hooks\n\nLifecycle hooks allow you to respond to changes to a component, such as when\nit gets created, rendered, updated or destroyed. To add a lifecycle hook to a\ncomponent, implement the hook as a method on your component subclass.\n\nFor example, to be notified when Glimmer has rendered your component so you\ncan attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  didInsertElement() {\n    $(this.element).pickadate();\n  }\n}\n```\n\n## Data for Templates\n\n`Component`s have two different kinds of data, or state, that can be\ndisplayed in templates:\n\n1. Arguments\n2. Properties\n\nArguments are data that is passed in to a component from its parent\ncomponent. For example, if I have a `UserGreeting` component, I can pass it\na name and greeting to use:\n\n```hbs\n<UserGreeting @name=\"Ricardo\" @greeting=\"Olá\" />\n```\n\nInside my `UserGreeting` template, I can access the `@name` and `@greeting`\narguments that I've been given:\n\n```hbs\n{{@greeting}}, {{@name}}!\n```\n\nArguments are also available inside my component:\n\n```ts\nconsole.log(this.args.greeting); // prints \"Olá\"\n```\n\nProperties, on the other hand, are internal to the component and declared in\nthe class. You can use properties to store data that you want to show in the\ntemplate, or pass to another component as an argument.\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  user = {\n    name: 'Robbie'\n  }\n}\n```\n\nIn the above example, we've defined a component with a `user` property that\ncontains an object with its own `name` property.\n\nWe can render that property in our template:\n\n```hbs\nHello, {{user.name}}!\n```\n\nWe can also take that property and pass it as an argument to the\n`UserGreeting` component we defined above:\n\n```hbs\n<UserGreeting @greeting=\"Hello\" @name={{user.name}} />\n```\n\n## Arguments vs. Properties\n\nRemember, arguments are data that was given to your component by its parent\ncomponent, and properties are data your component has defined for itself.\n\nYou can tell the difference between arguments and properties in templates\nbecause arguments always start with an `@` sign (think \"A is for arguments\"):\n\n```hbs\n{{@firstName}}\n```\n\nWe know that `@firstName` came from the parent component, not the current\ncomponent, because it starts with `@` and is therefore an argument.\n\nOn the other hand, if we see:\n\n```hbs\n{{name}}\n```\n\nWe know that `name` is a property on the component. If we want to know where\nthe data is coming from, we can go look at our component class to find out.\n\nInside the component itself, arguments always show up inside the component's\n`args` property. For example, if `{{@firstName}}` is `Tom` in the template,\ninside the component `this.args.firstName` would also be `Tom`.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 195,
+      "description": "Constructs a new component and assigns itself the passed properties. You\nshould not construct new components yourself. Instead, Glimmer will\ninstantiate new components automatically as it renders.",
+      "params": [
+        {
+          "name": "owner",
+          "description": ""
+        },
+        {
+          "name": "args",
+          "description": ""
+        }
+      ],
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 212,
+      "description": "Named arguments passed to the component from its parent component.\nThey can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n\nSay you have the following component, which will have two `args`, `firstName` and `lastName`:\n\n```hbs\n<my-component @firstName=\"Arthur\" @lastName=\"Dent\" />\n```\n\nIf you needed to calculate `fullName` by combining both of them, you would do:\n\n```ts\ndidInsertElement() {\n  console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n}\n```\n\nWhile in the template you could do:\n\n```hbs\n<p>Welcome, {{@firstName}} {{@lastName}}!</p>\n```",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 244,
+      "description": "Called before the component has been removed from the DOM.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/dist/index.js",
+      "line": 279,
+      "description": "This component manager runs in Ember.js environments and extends the base component manager to:\n\n1. Properly destroy the component's associated `meta` data structure\n2. Schedule destruction using Ember's runloop",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 36,
+      "description": "This provides us a way to have a \"fallback\" which represents an empty object,\nwithout the downsides of how TS treats `{}`. Specifically: this will\ncorrectly leverage \"excess property checking\" so that, given a component\nwhich has no named args, if someone invokes it with any named args, they will\nget a type error.",
+      "internal": "This is exported so declaration emit works (if it were not emitted,\n  declarations which fall back to it would not work). It is *not* intended for\n  public usage, and the specific mechanics it uses may change at any time.\n  The location of this export *is* part of the public API, because moving it\n  will break existing declarations, but is not legal for end users to import\n  themselves, so ***DO NOT RELY ON IT***.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 56,
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 79,
+      "description": "Given any allowed shorthand form of a signature, desugars it to its full\nexpanded type.",
+      "internal": "This is only exported so we can avoid duplicating it in\n  [Glint](https://github.com/typed-ember/glint) or other such tooling. It is\n  *not* intended for public usage, and the specific mechanics it uses may\n  change at any time. Although the signature produced by is part of Glimmer's\n  public API the existence and mechanics of this specific symbol are *not*,\n  so ***DO NOT RELY ON IT***.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 97,
+      "internal": "we use this type for convenience internally; inference means users\n  should not normally need to name it",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 103,
+      "description": "The `Component` class defines an encapsulated UI element that is rendered to\nthe DOM. A component is made up of a template and, optionally, this component\nobject.\n\n## Defining a Component\n\nTo define a component, subclass `Component` and add your own properties,\nmethods and lifecycle hooks:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n}\n```\n\n## Lifecycle Hooks\n\nLifecycle hooks allow you to respond to changes to a component, such as when\nit gets created, rendered, updated or destroyed. To add a lifecycle hook to a\ncomponent, implement the hook as a method on your component subclass.\n\nFor example, to be notified when Glimmer has rendered your component so you\ncan attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  didInsertElement() {\n    $(this.element).pickadate();\n  }\n}\n```\n\n## Data for Templates\n\n`Component`s have two different kinds of data, or state, that can be\ndisplayed in templates:\n\n1. Arguments\n2. Properties\n\nArguments are data that is passed in to a component from its parent\ncomponent. For example, if I have a `UserGreeting` component, I can pass it\na name and greeting to use:\n\n```hbs\n<UserGreeting @name=\"Ricardo\" @greeting=\"Olá\" />\n```\n\nInside my `UserGreeting` template, I can access the `@name` and `@greeting`\narguments that I've been given:\n\n```hbs\n{{@greeting}}, {{@name}}!\n```\n\nArguments are also available inside my component:\n\n```ts\nconsole.log(this.args.greeting); // prints \"Olá\"\n```\n\nProperties, on the other hand, are internal to the component and declared in\nthe class. You can use properties to store data that you want to show in the\ntemplate, or pass to another component as an argument.\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  user = {\n    name: 'Robbie'\n  }\n}\n```\n\nIn the above example, we've defined a component with a `user` property that\ncontains an object with its own `name` property.\n\nWe can render that property in our template:\n\n```hbs\nHello, {{user.name}}!\n```\n\nWe can also take that property and pass it as an argument to the\n`UserGreeting` component we defined above:\n\n```hbs\n<UserGreeting @greeting=\"Hello\" @name={{user.name}} />\n```\n\n## Arguments vs. Properties\n\nRemember, arguments are data that was given to your component by its parent\ncomponent, and properties are data your component has defined for itself.\n\nYou can tell the difference between arguments and properties in templates\nbecause arguments always start with an `@` sign (think \"A is for arguments\"):\n\n```hbs\n{{@firstName}}\n```\n\nWe know that `@firstName` came from the parent component, not the current\ncomponent, because it starts with `@` and is therefore an argument.\n\nOn the other hand, if we see:\n\n```hbs\n{{name}}\n```\n\nWe know that `name` is a property on the component. If we want to know where\nthe data is coming from, we can go look at our component class to find out.\n\nInside the component itself, arguments always show up inside the component's\n`args` property. For example, if `{{@firstName}}` is `Tom` in the template,\ninside the component `this.args.firstName` would also be `Tom`.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 227,
+      "description": "Constructs a new component and assigns itself the passed properties. You\nshould not construct new components yourself. Instead, Glimmer will\ninstantiate new components automatically as it renders.",
+      "params": [
+        {
+          "name": "owner",
+          "description": ""
+        },
+        {
+          "name": "args",
+          "description": ""
+        }
+      ],
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 248,
+      "description": "Named arguments passed to the component from its parent component.\nThey can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n\nSay you have the following component, which will have two `args`, `firstName` and `lastName`:\n\n```hbs\n<my-component @firstName=\"Arthur\" @lastName=\"Dent\" />\n```\n\nIf you needed to calculate `fullName` by combining both of them, you would do:\n\n```ts\ndidInsertElement() {\n  console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n}\n```\n\nWhile in the template you could do:\n\n```hbs\n<p>Welcome, {{@firstName}} {{@lastName}}!</p>\n```",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/component.ts",
+      "line": 282,
+      "description": "Called before the component has been removed from the DOM.",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/component/src/-private/ember-component-manager.ts",
+      "line": 24,
+      "description": "This component manager runs in Ember.js environments and extends the base component manager to:\n\n1. Properly destroy the component's associated `meta` data structure\n2. Schedule destruction using Ember's runloop",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/component"
+    },
+    {
+      "file": "packages/@glimmer/tracking/index.ts",
+      "line": 16,
+      "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```handlebars\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```\n\n```javascript\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```\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```javascript\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```",
+      "itemtype": "method",
+      "name": "tracked",
+      "static": 1,
+      "access": "public",
+      "tagname": "",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/tracking"
+    },
+    {
+      "file": "packages/@glimmer/tracking/index.ts",
+      "line": 150,
+      "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",
+      "static": 1,
+      "access": "public",
+      "tagname": "",
+      "class": "@glimmer/tracking",
+      "module": "@glimmer/tracking"
+    },
     {
       "file": "packages/ember-testing/lib/adapters/adapter.ts",
       "line": 20,
@@ -19471,6 +19791,42 @@
       "message": "unknown tag: internal",
       "line": " packages/@ember/runloop/index.ts:88"
     },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:10"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:62"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:74"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/dist/index.js:32"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/dist/index.js:49"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/dist/index.js:66"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/src/-private/component.ts:36"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/src/-private/component.ts:79"
+    },
+    {
+      "message": "unknown tag: internal",
+      "line": " packages/@glimmer/component/src/-private/component.ts:97"
+    },
     {
       "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:115"
@@ -20126,6 +20482,114 @@
     {
       "message": "Missing item type\nThis supports template blocks defined in class bodies.\n\nManual form:\n\n```ts\nclass MyComponent {\n  static {\n    template(templateContent, {\n      component: this,\n      eval: () => eval(arguments[0])\n    })\n  }\n}\n```\n\nGJS form (compiled to the manual form via `content-tag`):\n\n```ts\nclass MyComponent {\n  <template>Template Content</template>\n}\n```",
       "line": " packages/@ember/template-compiler/lib/types.ts:31"
+    },
+    {
+      "message": "Missing item type\nThis provides us a way to have a \"fallback\" which represents an empty object,\nwithout the downsides of how TS treats `{}`. Specifically: this will\ncorrectly leverage \"excess property checking\" so that, given a component\nwhich has no named args, if someone invokes it with any named args, they will\nget a type error.",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:10"
+    },
+    {
+      "message": "Missing item type",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:30"
+    },
+    {
+      "message": "Missing item type\nGiven any allowed shorthand form of a signature, desugars it to its full\nexpanded type.",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:62"
+    },
+    {
+      "message": "Missing item type",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:74"
+    },
+    {
+      "message": "Missing item type\nThe `Component` class defines an encapsulated UI element that is rendered to\nthe DOM. A component is made up of a template and, optionally, this component\nobject.\n\n## Defining a Component\n\nTo define a component, subclass `Component` and add your own properties,\nmethods and lifecycle hooks:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n}\n```\n\n## Lifecycle Hooks\n\nLifecycle hooks allow you to respond to changes to a component, such as when\nit gets created, rendered, updated or destroyed. To add a lifecycle hook to a\ncomponent, implement the hook as a method on your component subclass.\n\nFor example, to be notified when Glimmer has rendered your component so you\ncan attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  didInsertElement() {\n    $(this.element).pickadate();\n  }\n}\n```\n\n## Data for Templates\n\n`Component`s have two different kinds of data, or state, that can be\ndisplayed in templates:\n\n1. Arguments\n2. Properties\n\nArguments are data that is passed in to a component from its parent\ncomponent. For example, if I have a `UserGreeting` component, I can pass it\na name and greeting to use:\n\n```hbs\n<UserGreeting @name=\"Ricardo\" @greeting=\"Olá\" />\n```\n\nInside my `UserGreeting` template, I can access the `@name` and `@greeting`\narguments that I've been given:\n\n```hbs\n{{@greeting}}, {{@name}}!\n```\n\nArguments are also available inside my component:\n\n```ts\nconsole.log(this.args.greeting); // prints \"Olá\"\n```\n\nProperties, on the other hand, are internal to the component and declared in\nthe class. You can use properties to store data that you want to show in the\ntemplate, or pass to another component as an argument.\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  user = {\n    name: 'Robbie'\n  }\n}\n```\n\nIn the above example, we've defined a component with a `user` property that\ncontains an object with its own `name` property.\n\nWe can render that property in our template:\n\n```hbs\nHello, {{user.name}}!\n```\n\nWe can also take that property and pass it as an argument to the\n`UserGreeting` component we defined above:\n\n```hbs\n<UserGreeting @greeting=\"Hello\" @name={{user.name}} />\n```\n\n## Arguments vs. Properties\n\nRemember, arguments are data that was given to your component by its parent\ncomponent, and properties are data your component has defined for itself.\n\nYou can tell the difference between arguments and properties in templates\nbecause arguments always start with an `@` sign (think \"A is for arguments\"):\n\n```hbs\n{{@firstName}}\n```\n\nWe know that `@firstName` came from the parent component, not the current\ncomponent, because it starts with `@` and is therefore an argument.\n\nOn the other hand, if we see:\n\n```hbs\n{{name}}\n```\n\nWe know that `name` is a property on the component. If we want to know where\nthe data is coming from, we can go look at our component class to find out.\n\nInside the component itself, arguments always show up inside the component's\n`args` property. For example, if `{{@firstName}}` is `Tom` in the template,\ninside the component `this.args.firstName` would also be `Tom`.",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:79"
+    },
+    {
+      "message": "Missing item type\nConstructs a new component and assigns itself the passed properties. You\nshould not construct new components yourself. Instead, Glimmer will\ninstantiate new components automatically as it renders.",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:203"
+    },
+    {
+      "message": "Missing item type\nNamed arguments passed to the component from its parent component.\nThey can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n\nSay you have the following component, which will have two `args`, `firstName` and `lastName`:\n\n```hbs\n<my-component @firstName=\"Arthur\" @lastName=\"Dent\" />\n```\n\nIf you needed to calculate `fullName` by combining both of them, you would do:\n\n```ts\ndidInsertElement() {\n  console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n}\n```\n\nWhile in the template you could do:\n\n```hbs\n<p>Welcome, {{@firstName}} {{@lastName}}!</p>\n```",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:212"
+    },
+    {
+      "message": "Missing item type\nCalled before the component has been removed from the DOM.",
+      "line": " packages/@glimmer/component/dist/-private/component.d.ts:239"
+    },
+    {
+      "message": "Missing item type\nThis component manager runs in Ember.js environments and extends the base component manager to:\n\n1. Properly destroy the component's associated `meta` data structure\n2. Schedule destruction using Ember's runloop",
+      "line": " packages/@glimmer/component/dist/-private/ember-component-manager.d.ts:4"
+    },
+    {
+      "message": "Missing item type\nThis provides us a way to have a \"fallback\" which represents an empty object,\nwithout the downsides of how TS treats `{}`. Specifically: this will\ncorrectly leverage \"excess property checking\" so that, given a component\nwhich has no named args, if someone invokes it with any named args, they will\nget a type error.",
+      "line": " packages/@glimmer/component/dist/index.js:32"
+    },
+    {
+      "message": "Missing item type",
+      "line": " packages/@glimmer/component/dist/index.js:47"
+    },
+    {
+      "message": "Missing item type\nGiven any allowed shorthand form of a signature, desugars it to its full\nexpanded type.",
+      "line": " packages/@glimmer/component/dist/index.js:49"
+    },
+    {
+      "message": "Missing item type",
+      "line": " packages/@glimmer/component/dist/index.js:66"
+    },
+    {
+      "message": "Missing item type\nThe `Component` class defines an encapsulated UI element that is rendered to\nthe DOM. A component is made up of a template and, optionally, this component\nobject.\n\n## Defining a Component\n\nTo define a component, subclass `Component` and add your own properties,\nmethods and lifecycle hooks:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n}\n```\n\n## Lifecycle Hooks\n\nLifecycle hooks allow you to respond to changes to a component, such as when\nit gets created, rendered, updated or destroyed. To add a lifecycle hook to a\ncomponent, implement the hook as a method on your component subclass.\n\nFor example, to be notified when Glimmer has rendered your component so you\ncan attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  didInsertElement() {\n    $(this.element).pickadate();\n  }\n}\n```\n\n## Data for Templates\n\n`Component`s have two different kinds of data, or state, that can be\ndisplayed in templates:\n\n1. Arguments\n2. Properties\n\nArguments are data that is passed in to a component from its parent\ncomponent. For example, if I have a `UserGreeting` component, I can pass it\na name and greeting to use:\n\n```hbs\n<UserGreeting @name=\"Ricardo\" @greeting=\"Olá\" />\n```\n\nInside my `UserGreeting` template, I can access the `@name` and `@greeting`\narguments that I've been given:\n\n```hbs\n{{@greeting}}, {{@name}}!\n```\n\nArguments are also available inside my component:\n\n```ts\nconsole.log(this.args.greeting); // prints \"Olá\"\n```\n\nProperties, on the other hand, are internal to the component and declared in\nthe class. You can use properties to store data that you want to show in the\ntemplate, or pass to another component as an argument.\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  user = {\n    name: 'Robbie'\n  }\n}\n```\n\nIn the above example, we've defined a component with a `user` property that\ncontains an object with its own `name` property.\n\nWe can render that property in our template:\n\n```hbs\nHello, {{user.name}}!\n```\n\nWe can also take that property and pass it as an argument to the\n`UserGreeting` component we defined above:\n\n```hbs\n<UserGreeting @greeting=\"Hello\" @name={{user.name}} />\n```\n\n## Arguments vs. Properties\n\nRemember, arguments are data that was given to your component by its parent\ncomponent, and properties are data your component has defined for itself.\n\nYou can tell the difference between arguments and properties in templates\nbecause arguments always start with an `@` sign (think \"A is for arguments\"):\n\n```hbs\n{{@firstName}}\n```\n\nWe know that `@firstName` came from the parent component, not the current\ncomponent, because it starts with `@` and is therefore an argument.\n\nOn the other hand, if we see:\n\n```hbs\n{{name}}\n```\n\nWe know that `name` is a property on the component. If we want to know where\nthe data is coming from, we can go look at our component class to find out.\n\nInside the component itself, arguments always show up inside the component's\n`args` property. For example, if `{{@firstName}}` is `Tom` in the template,\ninside the component `this.args.firstName` would also be `Tom`.",
+      "line": " packages/@glimmer/component/dist/index.js:71"
+    },
+    {
+      "message": "Missing item type\nConstructs a new component and assigns itself the passed properties. You\nshould not construct new components yourself. Instead, Glimmer will\ninstantiate new components automatically as it renders.",
+      "line": " packages/@glimmer/component/dist/index.js:195"
+    },
+    {
+      "message": "Missing item type\nNamed arguments passed to the component from its parent component.\nThey can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n\nSay you have the following component, which will have two `args`, `firstName` and `lastName`:\n\n```hbs\n<my-component @firstName=\"Arthur\" @lastName=\"Dent\" />\n```\n\nIf you needed to calculate `fullName` by combining both of them, you would do:\n\n```ts\ndidInsertElement() {\n  console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n}\n```\n\nWhile in the template you could do:\n\n```hbs\n<p>Welcome, {{@firstName}} {{@lastName}}!</p>\n```",
+      "line": " packages/@glimmer/component/dist/index.js:212"
+    },
+    {
+      "message": "Missing item type\nCalled before the component has been removed from the DOM.",
+      "line": " packages/@glimmer/component/dist/index.js:244"
+    },
+    {
+      "message": "Missing item type\nThis component manager runs in Ember.js environments and extends the base component manager to:\n\n1. Properly destroy the component's associated `meta` data structure\n2. Schedule destruction using Ember's runloop",
+      "line": " packages/@glimmer/component/dist/index.js:279"
+    },
+    {
+      "message": "Missing item type\nThis provides us a way to have a \"fallback\" which represents an empty object,\nwithout the downsides of how TS treats `{}`. Specifically: this will\ncorrectly leverage \"excess property checking\" so that, given a component\nwhich has no named args, if someone invokes it with any named args, they will\nget a type error.",
+      "line": " packages/@glimmer/component/src/-private/component.ts:36"
+    },
+    {
+      "message": "Missing item type",
+      "line": " packages/@glimmer/component/src/-private/component.ts:56"
+    },
+    {
+      "message": "Missing item type\nGiven any allowed shorthand form of a signature, desugars it to its full\nexpanded type.",
+      "line": " packages/@glimmer/component/src/-private/component.ts:79"
+    },
+    {
+      "message": "Missing item type",
+      "line": " packages/@glimmer/component/src/-private/component.ts:97"
+    },
+    {
+      "message": "Missing item type\nThe `Component` class defines an encapsulated UI element that is rendered to\nthe DOM. A component is made up of a template and, optionally, this component\nobject.\n\n## Defining a Component\n\nTo define a component, subclass `Component` and add your own properties,\nmethods and lifecycle hooks:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n}\n```\n\n## Lifecycle Hooks\n\nLifecycle hooks allow you to respond to changes to a component, such as when\nit gets created, rendered, updated or destroyed. To add a lifecycle hook to a\ncomponent, implement the hook as a method on your component subclass.\n\nFor example, to be notified when Glimmer has rendered your component so you\ncan attach a legacy jQuery plugin, implement the `didInsertElement()` method:\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  didInsertElement() {\n    $(this.element).pickadate();\n  }\n}\n```\n\n## Data for Templates\n\n`Component`s have two different kinds of data, or state, that can be\ndisplayed in templates:\n\n1. Arguments\n2. Properties\n\nArguments are data that is passed in to a component from its parent\ncomponent. For example, if I have a `UserGreeting` component, I can pass it\na name and greeting to use:\n\n```hbs\n<UserGreeting @name=\"Ricardo\" @greeting=\"Olá\" />\n```\n\nInside my `UserGreeting` template, I can access the `@name` and `@greeting`\narguments that I've been given:\n\n```hbs\n{{@greeting}}, {{@name}}!\n```\n\nArguments are also available inside my component:\n\n```ts\nconsole.log(this.args.greeting); // prints \"Olá\"\n```\n\nProperties, on the other hand, are internal to the component and declared in\nthe class. You can use properties to store data that you want to show in the\ntemplate, or pass to another component as an argument.\n\n```ts\nimport Component from '@glimmer/component';\n\nexport default class extends Component {\n  user = {\n    name: 'Robbie'\n  }\n}\n```\n\nIn the above example, we've defined a component with a `user` property that\ncontains an object with its own `name` property.\n\nWe can render that property in our template:\n\n```hbs\nHello, {{user.name}}!\n```\n\nWe can also take that property and pass it as an argument to the\n`UserGreeting` component we defined above:\n\n```hbs\n<UserGreeting @greeting=\"Hello\" @name={{user.name}} />\n```\n\n## Arguments vs. Properties\n\nRemember, arguments are data that was given to your component by its parent\ncomponent, and properties are data your component has defined for itself.\n\nYou can tell the difference between arguments and properties in templates\nbecause arguments always start with an `@` sign (think \"A is for arguments\"):\n\n```hbs\n{{@firstName}}\n```\n\nWe know that `@firstName` came from the parent component, not the current\ncomponent, because it starts with `@` and is therefore an argument.\n\nOn the other hand, if we see:\n\n```hbs\n{{name}}\n```\n\nWe know that `name` is a property on the component. If we want to know where\nthe data is coming from, we can go look at our component class to find out.\n\nInside the component itself, arguments always show up inside the component's\n`args` property. For example, if `{{@firstName}}` is `Tom` in the template,\ninside the component `this.args.firstName` would also be `Tom`.",
+      "line": " packages/@glimmer/component/src/-private/component.ts:103"
+    },
+    {
+      "message": "Missing item type\nConstructs a new component and assigns itself the passed properties. You\nshould not construct new components yourself. Instead, Glimmer will\ninstantiate new components automatically as it renders.",
+      "line": " packages/@glimmer/component/src/-private/component.ts:227"
+    },
+    {
+      "message": "Missing item type\nNamed arguments passed to the component from its parent component.\nThey can be accessed in JavaScript via `this.args.argumentName` and in the template via `@argumentName`.\n\nSay you have the following component, which will have two `args`, `firstName` and `lastName`:\n\n```hbs\n<my-component @firstName=\"Arthur\" @lastName=\"Dent\" />\n```\n\nIf you needed to calculate `fullName` by combining both of them, you would do:\n\n```ts\ndidInsertElement() {\n  console.log(`Hi, my full name is ${this.args.firstName} ${this.args.lastName}`);\n}\n```\n\nWhile in the template you could do:\n\n```hbs\n<p>Welcome, {{@firstName}} {{@lastName}}!</p>\n```",
+      "line": " packages/@glimmer/component/src/-private/component.ts:248"
+    },
+    {
+      "message": "Missing item type\nCalled before the component has been removed from the DOM.",
+      "line": " packages/@glimmer/component/src/-private/component.ts:282"
+    },
+    {
+      "message": "Missing item type\nThis component manager runs in Ember.js environments and extends the base component manager to:\n\n1. Properly destroy the component's associated `meta` data structure\n2. Schedule destruction using Ember's runloop",
+      "line": " packages/@glimmer/component/src/-private/ember-component-manager.ts:24"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-source",
-  "version": "6.3.0-beta.1",
+  "version": "6.3.0",
   "description": "A JavaScript framework for creating ambitious web applications",
   "keywords": [
     "ember-addon"
@@ -399,9 +399,6 @@
     "node": "16.20.0",
     "pnpm": "8.10.0"
   },
-  "_originalVersion": "6.3.0-beta.1",
-  "_versionPreviouslyCalculated": true,
-  "publishConfig": {
-    "tag": "beta"
-  }
+  "_originalVersion": "6.3.0",
+  "_versionPreviouslyCalculated": true
 }