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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-source",
-  "version": "7.2.0-beta.1",
+  "version": "7.3.0-alpha.2",
   "description": "A JavaScript framework for creating ambitious web applications",
   "type": "module",
   "keywords": [
@@ -92,7 +92,7 @@
     "@embroider/vite": "^1.7.2",
     "@eslint/js": "^9.21.0",
     "@glimmer/component": "workspace:*",
-    "@octokit/rest": "^20.1.2",
+    "@octokit/rest": "^22.0.0",
     "@rollup/plugin-babel": "^6.0.4",
     "@simple-dom/document": "^1.4.0",
     "@swc-node/register": "^1.6.8",
@@ -123,8 +123,8 @@
     "expect-type": "^0.15.0",
     "fs-extra": "^11.1.1",
     "git-repo-info": "^2.1.1",
-    "glob": "^8.0.3",
-    "globals": "^16.0.0",
+    "glob": "^13.0.0",
+    "globals": "^17.0.0",
     "kill-port-process": "^3.2.1",
     "mitata": "^1.0.34",
     "mocha": "^11.0.0",
@@ -367,9 +367,9 @@
     }
   },
   "packageManager": "pnpm@10.33.2",
-  "_originalVersion": "7.2.0-beta.1",
+  "_originalVersion": "7.3.0-alpha.1",
   "_versionPreviouslyCalculated": true,
   "publishConfig": {
-    "tag": "beta"
+    "tag": "alpha"
   }
 }

package/types/stable/@ember/-internals/deprecations/index.d.ts

@@ -21,6 +21,12 @@ declare module '@ember/-internals/deprecations' {
             isEnabled: boolean;
             isRemoved: boolean;
         };
+        DEPRECATE_COMPARABLE_MIXIN: {
+            options: DeprecationOptions;
+            test: boolean;
+            isEnabled: boolean;
+            isRemoved: boolean;
+        };
     };
     export function deprecateUntil(message: string, deprecation: DeprecationObject): void;
     export {};

package/types/stable/@ember/-internals/glimmer/lib/base-renderer.d.ts

@@ -0,0 +1,150 @@
+declare module '@ember/-internals/glimmer/lib/base-renderer' {
+    import type { Cursor, DebugRenderTree, Environment, RenderResult as GlimmerRenderResult, EvaluationContext, TreeBuilder, ClassicResolver } from "@glimmer/interfaces";
+    import type { SimpleDocument, SimpleElement } from "@simple-dom/interface";
+    export type IBuilder = (env: Environment, cursor: Cursor) => TreeBuilder;
+    export function errorLoopTransaction(fn: () => void): () => void;
+    /**
+     * The interface the `RendererState` needs from a render root. The base
+     * renderer only ever creates `ComponentRootState`s; the classic renderer
+     * (`./renderer`) adds `ClassicRootState` for outlet/classic-component roots.
+     */
+    export interface RendererRoot {
+        readonly type: string;
+        readonly result: GlimmerRenderResult | undefined;
+        readonly destroyed: boolean;
+        render(): void;
+        destroy(): void;
+        isFor(possibleRoot: unknown): boolean;
+    }
+    export class ComponentRootState implements RendererRoot {
+        #private;
+        readonly type = "component";
+        constructor(state: RendererState, definition: object, options: {
+            into: Cursor;
+            args?: Record<string, unknown>;
+        });
+        isFor(_possibleRoot: unknown): boolean;
+        render(): void;
+        destroy(): void;
+        get destroyed(): boolean;
+        get result(): GlimmerRenderResult | undefined;
+    }
+    export function _resetRenderers(): void;
+    export function renderSettled(): Promise<void>;
+    type Resolver = ClassicResolver;
+    interface RendererData {
+        owner: object;
+        context: EvaluationContext;
+        builder: IBuilder;
+    }
+    export class RendererState {
+        #private;
+        static create(data: RendererData, renderer: BaseRenderer): RendererState;
+        private constructor();
+        get debug(): {
+            roots: RendererRoot[];
+            inRenderTransaction: boolean;
+            isInteractive: boolean;
+        };
+        get roots(): RendererRoot[];
+        get owner(): object;
+        get builder(): IBuilder;
+        get context(): EvaluationContext;
+        get env(): Environment;
+        get isInteractive(): boolean;
+        renderRoot(root: RendererRoot, renderer: BaseRenderer): RendererRoot;
+        renderRoots(renderer: BaseRenderer): void;
+        scheduleRevalidate(renderer: BaseRenderer): void;
+        isValid(): boolean;
+        revalidate(renderer: BaseRenderer): void;
+        clearAllRoots(renderer: BaseRenderer): void;
+    }
+    type IntoTarget = Cursor | Element | SimpleElement;
+    /**
+     * The returned object from `renderComponent`
+     * @public
+     * @module @ember/renderer
+     */
+    export interface RenderResult {
+        /**
+         * Destroys the render tree and removes all rendered content from the element rendered into
+         */
+        destroy(): void;
+    }
+    /**
+     * Render a component into a DOM element.
+     *
+     * @method renderComponent
+     * @static
+     * @for @ember/renderer
+     * @param {Object} component The component to render.
+     * @param {Object} options
+     * @param {Element} options.into Where to render the component in to.
+     * @param {Object} [options.owner] Optionally specify the owner to use. This will be used for injections, and overall cleanup.
+     * @param {Object} [options.env] Optional renderer configuration
+     * @param {Object} [options.args] Optionally pass args in to the component. These may be reactive as long as it is an object or object-like
+     * @public
+     */
+    export function renderComponent(
+        /**
+         * The component definition to render.
+         *
+         * Any component that has had its manager registered is valid.
+         * For the component-types that ship with ember, manager registration
+         * does not need to be worried about.
+         */
+        component: object,
+        { owner, env, into, args, }: {
+            /**
+             * The element to render the component in to.
+             */
+            into: IntoTarget;
+            /**
+             * 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.
+             */
+            owner?: object;
+            /**
+             * Optionally configure the rendering environment
+             */
+            env?: {
+                /**
+                 * When false, modifiers will not run.
+                 */
+                isInteractive?: boolean;
+                /**
+                 * All other options are forwarded to the underlying renderer.
+                 * (its API is currently private and out of scope for this RFC,
+                 *  so passing additional things here is also considered private API)
+                 */
+                [rendererOption: string]: unknown;
+            };
+            /**
+             * These args get passed to the rendered component
+             *
+             * If your args are reactive, re-rendering will happen automatically.
+             *
+             */
+            args?: Record<string, unknown>;
+        }
+    ): RenderResult;
+    export class BaseRenderer {
+        static strict(owner: object, document: SimpleDocument | Document, options: {
+            isInteractive: boolean;
+            hasDOM?: boolean;
+        }): BaseRenderer;
+        readonly state: RendererState;
+        constructor(owner: object, envOptions: {
+            isInteractive: boolean;
+            hasDOM: boolean;
+        }, document: SimpleDocument, resolver: Resolver, builder: IBuilder);
+        get debugRenderTree(): DebugRenderTree;
+        isValid(): boolean;
+        destroy(): void;
+        render(component: object, options: {
+            into: IntoTarget;
+            args?: Record<string, unknown>;
+        }): RendererRoot;
+        rerender(): void;
+    }
+    export {};
+}

package/types/stable/@ember/-internals/glimmer/lib/component-managers/curly-brand.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/-internals/glimmer/lib/component-managers/curly-brand' {
+    /**
+     * The brand for the curly component manager lives in its own module so that
+     * code which only needs to *detect* the curly manager (e.g. the resolver)
+     * does not have to import the manager itself (and with it the classic
+     * component machinery).
+     */
+    export const CURLY_MANAGER_BRAND: unique symbol;
+    export function isCurlyManager(manager: object): boolean;
+}

package/types/stable/@ember/-internals/glimmer/lib/component-managers/curly.d.ts

@@ -7,6 +7,7 @@ declare module '@ember/-internals/glimmer/lib/component-managers/curly' {
     import type { DynamicScope } from "@ember/-internals/glimmer/lib/renderer";
     import type RuntimeResolver from "@ember/-internals/glimmer/lib/resolver";
     import ComponentStateBucket from "@ember/-internals/glimmer/lib/utils/curly-component-state-bucket";
+    import { CURLY_MANAGER_BRAND } from "@ember/-internals/glimmer/lib/component-managers/curly-brand";
     export function getComponentCapturedArgs(component: object): CapturedArguments["named"] | undefined;
     export const DIRTY_TAG: unique symbol;
     export const IS_DISPATCHING_ATTRS: unique symbol;
@@ -20,6 +21,7 @@ declare module '@ember/-internals/glimmer/lib/component-managers/curly' {
         positionalParams: string | string[] | undefined | null;
     };
     export default class CurlyComponentManager implements WithCreateInstance<ComponentStateBucket>, WithDynamicLayout<ComponentStateBucket, RuntimeResolver>, WithDynamicTagName<ComponentStateBucket> {
+        readonly [CURLY_MANAGER_BRAND] = true;
         protected templateFor(component: Component): CompilableProgram | null;
         getDynamicLayout(bucket: ComponentStateBucket): CompilableProgram | null;
         getTagName(state: ComponentStateBucket): Nullable<string>;
@@ -39,6 +41,5 @@ declare module '@ember/-internals/glimmer/lib/component-managers/curly' {
     export function processComponentInitializationAssertions(component: Component, props: any): void;
     export function initialRenderInstrumentDetails(component: any): any;
     export const CURLY_COMPONENT_MANAGER: CurlyComponentManager;
-    export function isCurlyManager(manager: object): boolean;
-    export {};
+    export { isCurlyManager } from "@ember/-internals/glimmer/lib/component-managers/curly-brand";
 }

package/types/stable/@ember/-internals/glimmer/lib/glimmer-tracking-docs.d.ts

@@ -149,6 +149,74 @@ declare module '@ember/-internals/glimmer/lib/glimmer-tracking-docs' {
       });
       ```
 
+      Calling `tracked` with an initial value creates a standalone reactive
+      value, usable outside of classes:
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+
+      const count = tracked(0);
+
+      count.value;                // read the value, entangling with any tracking context
+      count.value = 1;            // write the value, notifying consumers
+      count.get();                // function shorthand for reading
+      count.set(2);               // function shorthand for writing
+      count.update((n) => n + 1); // write based on the current value, without entangling
+      count.freeze();             // prevent all future writes
+      ```
+
+      Reading `value` in a template (or in a getter used by a template) will
+      rerender just like a `@tracked` property:
+
+      ```gjs
+      import { tracked } from '@glimmer/tracking';
+      import { on } from '@ember/modifier';
+
+      const count = tracked(0);
+      const increment = () => count.value++;
+
+      <template>
+        Count is: {{count.value}}
+
+        <button {{on "click" increment}}>add one</button>
+      </template>
+      ```
+
+      This form accepts an options object containing an `equals` function, which
+      decides whether a written value should notify consumers (it defaults to
+      `Object.is`), and a `description` used for debugging:
+
+      ```js
+      const count = tracked(0, { equals: (a, b) => a === b });
+
+      count.value = 0; // does not notify consumers, the value did not change
+      ```
+
+      Note: when `tracked` is called with a single plain object whose keys are all
+      drawn from `value`, `initializer`, `equals`, and `description`, it is treated
+      as the configuration object for a decorator (or classic-class field), not as a
+      standalone value wrapping that object. To create a standalone reactive value
+      around such an object, pass it as an initial value and include a (possibly
+      empty) options argument: `tracked({ value: 5 }, {})`.
+
+      The `@tracked` decorator accepts the same options. By default, setting a
+      `@tracked` property always notifies consumers, even when setting the
+      property to the same value; passing `equals` opts in to equality-based
+      notification instead:
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+
+      class Counter {
+        @tracked({ equals: (a, b) => a === b }) count = 0;
+
+        noop = () => {
+          // does not notify consumers, the value did not change
+          this.count = this.count;
+        };
+      }
+      ```
+
       @method tracked
       @static
       @for @glimmer/tracking

package/types/stable/@ember/-internals/glimmer/lib/helper-brand.d.ts

@@ -0,0 +1,10 @@
+declare module '@ember/-internals/glimmer/lib/helper-brand' {
+    /**
+     * The brand for classic (class-based) helpers lives in its own module so that
+     * code which only needs to *detect* classic helpers (e.g. the resolver) does
+     * not have to import the classic `Helper` base class (and with it the classic
+     * object model: `EmberObject`, `Mixin`, meta, etc.).
+     */
+    export const IS_CLASSIC_HELPER: unique symbol;
+    export function isClassicHelper(obj: object): boolean;
+}

package/types/stable/@ember/-internals/glimmer/lib/helper.d.ts

@@ -4,6 +4,8 @@ declare module '@ember/-internals/glimmer/lib/helper' {
     */
     import { FrameworkObject } from "@ember/object/-internals";
     import type { DirtyableTag } from "@glimmer/interfaces";
+    import { IS_CLASSIC_HELPER } from "@ember/-internals/glimmer/lib/helper-brand";
+    export { isClassicHelper } from "@ember/-internals/glimmer/lib/helper-brand";
     const RECOMPUTE_TAG: unique symbol;
     type GetOr<T, K, Else> = K extends keyof T ? T[K] : Else;
     type Args<S> = GetOr<S, "Args", {}>;
@@ -20,7 +22,6 @@ declare module '@ember/-internals/glimmer/lib/helper' {
         destroy(): void;
         [RECOMPUTE_TAG]: DirtyableTag;
     }
-    const IS_CLASSIC_HELPER: unique symbol;
     export interface SimpleHelper<S> {
         compute: (positional: Positional<S>, named: Named<S>) => Return<S>;
     }
@@ -31,7 +32,7 @@ declare module '@ember/-internals/glimmer/lib/helper' {
 
       ```app/templates/application.gjs
       import Cost from '../components/cost';
-        
+
       <template>
         <Cost @cents={{230}} />
       </template>
@@ -39,7 +40,7 @@ declare module '@ember/-internals/glimmer/lib/helper' {
 
       ```app/components/cost.gjs
       import formatCurrency from '../helpers/format-currency';
-        
+
       <template>
         <div>{{formatCurrency @cents currency="$"}}</div>
       </template>
@@ -140,8 +141,6 @@ declare module '@ember/-internals/glimmer/lib/helper' {
         */
         recompute(): void;
     }
-    export function isClassicHelper(obj: object): boolean;
-    export const CLASSIC_HELPER_MANAGER: import("@glimmer/interfaces").Helper<object> | import("@glimmer/manager").CustomHelperManager<object>;
     /**
      * The type of a function-based helper.
      *
@@ -181,5 +180,4 @@ declare module '@ember/-internals/glimmer/lib/helper' {
         Return: R;
     }>;
     export function helper<S>(helperFn: (positional: Positional<S>, named: Named<S>) => Return<S>): FunctionBasedHelper<S>;
-    export {};
 }

package/types/stable/@ember/-internals/glimmer/lib/renderer.d.ts

@@ -1,18 +1,19 @@
 declare module '@ember/-internals/glimmer/lib/renderer' {
     import type { InternalOwner } from "@ember/-internals/owner";
-    import type { Bounds, Cursor, DebugRenderTree, Environment, DynamicScope as GlimmerDynamicScope, RenderResult as GlimmerRenderResult, Template, TemplateFactory, EvaluationContext, TreeBuilder, ClassicResolver } from "@glimmer/interfaces";
+    import type { Bounds, DynamicScope as GlimmerDynamicScope, TemplateFactory, EvaluationContext } from "@glimmer/interfaces";
     import type { Nullable } from "@ember/-internals/utility-types";
     import type { Reference } from "@glimmer/reference/lib/reference";
     import type { CurriedValue } from "@glimmer/runtime/lib/curried-value";
     import { clientBuilder } from "@glimmer/runtime/lib/vm/element-builder";
     import type { SimpleDocument, SimpleElement, SimpleNode } from "@simple-dom/interface";
-    import type Component from "@ember/-internals/glimmer/lib/component";
     import type ClassicComponent from "@ember/-internals/glimmer/lib/component";
     import { BOUNDS } from "@ember/-internals/glimmer/lib/component-managers/curly";
-    import ResolverImpl from "@ember/-internals/glimmer/lib/resolver";
+    import RouterResolver from "@ember/-internals/glimmer/lib/router-resolver";
     import type { OutletState } from "@ember/-internals/glimmer/lib/utils/outlet";
     import OutletView from "@ember/-internals/glimmer/lib/views/outlet";
-    export type IBuilder = (env: Environment, cursor: Cursor) => TreeBuilder;
+    import type { RendererRoot } from "@ember/-internals/glimmer/lib/base-renderer";
+    import { BaseRenderer } from "@ember/-internals/glimmer/lib/base-renderer";
+    export { type IBuilder, type RendererRoot, type RenderResult, BaseRenderer, ComponentRootState, errorLoopTransaction, renderComponent, renderSettled, _resetRenderers, } from "@ember/-internals/glimmer/lib/base-renderer";
     export interface View {
         parentView: Nullable<View>;
         renderer: Renderer;
@@ -30,157 +31,10 @@ declare module '@ember/-internals/glimmer/lib/renderer' {
         get(key: "outletState"): Reference<OutletState | undefined>;
         set(key: "outletState", value: Reference<OutletState | undefined>): Reference<OutletState | undefined>;
     }
-    type RootState = ClassicRootState | ComponentRootState;
-    class ComponentRootState {
-        #private;
-        readonly type = "component";
-        constructor(state: RendererState, definition: object, options: {
-            into: Cursor;
-            args?: Record<string, unknown>;
-        });
-        isFor(_component: ClassicComponent): boolean;
-        render(): void;
-        destroy(): void;
-        get destroyed(): boolean;
-        get result(): GlimmerRenderResult | undefined;
-    }
-    class ClassicRootState {
-        root: Component | OutletView;
-        readonly type = "classic";
-        id: string;
-        result: GlimmerRenderResult | undefined;
-        destroyed: boolean;
-        render: () => void;
-        readonly env: Environment;
-        constructor(root: Component | OutletView, context: EvaluationContext, owner: object, template: Template, self: Reference<unknown>, parentElement: SimpleElement, dynamicScope: DynamicScope, builder: IBuilder);
-        isFor(possibleRoot: unknown): boolean;
-        destroy(): void;
-    }
-    export function _resetRenderers(): void;
-    export function renderSettled(): Promise<void>;
     interface ViewRegistry {
         [viewId: string]: unknown;
     }
-    type Resolver = ClassicResolver;
-    interface RendererData {
-        owner: object;
-        context: EvaluationContext;
-        builder: IBuilder;
-    }
-    class RendererState {
-        #private;
-        static create(data: RendererData, renderer: BaseRenderer): RendererState;
-        private constructor();
-        get debug(): {
-            roots: RootState[];
-            inRenderTransaction: boolean;
-            isInteractive: boolean;
-        };
-        get roots(): RootState[];
-        get owner(): object;
-        get builder(): IBuilder;
-        get context(): EvaluationContext;
-        get env(): Environment;
-        get isInteractive(): boolean;
-        renderRoot(root: RootState, renderer: BaseRenderer): RootState;
-        renderRoots(renderer: BaseRenderer): void;
-        scheduleRevalidate(renderer: BaseRenderer): void;
-        isValid(): boolean;
-        revalidate(renderer: BaseRenderer): void;
-        clearAllRoots(renderer: BaseRenderer): void;
-    }
-    type IntoTarget = Cursor | Element | SimpleElement;
-    /**
-     * The returned object from `renderComponent`
-     * @public
-     * @module @ember/renderer
-     */
-    export interface RenderResult {
-        /**
-         * Destroys the render tree and removes all rendered content from the element rendered into
-         */
-        destroy(): void;
-    }
-    /**
-     * Render a component into a DOM element.
-     *
-     * @method renderComponent
-     * @static
-     * @for @ember/renderer
-     * @param {Object} component The component to render.
-     * @param {Object} options
-     * @param {Element} options.into Where to render the component in to.
-     * @param {Object} [options.owner] Optionally specify the owner to use. This will be used for injections, and overall cleanup.
-     * @param {Object} [options.env] Optional renderer configuration
-     * @param {Object} [options.args] Optionally pass args in to the component. These may be reactive as long as it is an object or object-like
-     * @public
-     */
-    export function renderComponent(
-        /**
-         * The component definition to render.
-         *
-         * Any component that has had its manager registered is valid.
-         * For the component-types that ship with ember, manager registration
-         * does not need to be worried about.
-         */
-        component: object,
-        { owner, env, into, args, }: {
-            /**
-             * The element to render the component in to.
-             */
-            into: IntoTarget;
-            /**
-             * 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.
-             */
-            owner?: object;
-            /**
-             * Optionally configure the rendering environment
-             */
-            env?: {
-                /**
-                 * When false, modifiers will not run.
-                 */
-                isInteractive?: boolean;
-                /**
-                 * All other options are forwarded to the underlying renderer.
-                 * (its API is currently private and out of scope for this RFC,
-                 *  so passing additional things here is also considered private API)
-                 */
-                [rendererOption: string]: unknown;
-            };
-            /**
-             * These args get passed to the rendered component
-             *
-             * If your args are reactive, re-rendering will happen automatically.
-             *
-             */
-            args?: Record<string, unknown>;
-        }
-    ): RenderResult;
-    class BaseRenderer {
-        static strict(owner: object, document: SimpleDocument | Document, options: {
-            isInteractive: boolean;
-            hasDOM?: boolean;
-        }): BaseRenderer;
-        readonly state: RendererState;
-        constructor(owner: object, envOptions: {
-            isInteractive: boolean;
-            hasDOM: boolean;
-        }, document: SimpleDocument, resolver: Resolver, builder: IBuilder);
-        get debugRenderTree(): DebugRenderTree;
-        isValid(): boolean;
-        destroy(): void;
-        render(component: object, options: {
-            into: IntoTarget;
-            args?: Record<string, unknown>;
-        }): RootState;
-        rerender(): void;
-    }
     export class Renderer extends BaseRenderer {
-        static strict(owner: object, document: SimpleDocument | Document, options: {
-            isInteractive: boolean;
-            hasDOM?: boolean;
-        }): BaseRenderer;
         private _rootTemplate;
         private _viewRegistry;
         static create(props: {
@@ -189,13 +43,13 @@ declare module '@ember/-internals/glimmer/lib/renderer' {
         constructor(owner: InternalOwner, document: SimpleDocument, env: {
             isInteractive: boolean;
             hasDOM: boolean;
-        }, rootTemplate: TemplateFactory, viewRegistry: ViewRegistry, builder?: typeof clientBuilder, resolver?: ResolverImpl);
+        }, rootTemplate: TemplateFactory, viewRegistry: ViewRegistry, builder?: typeof clientBuilder, resolver?: RouterResolver);
         appendOutletView(view: OutletView, target: SimpleElement): void;
         appendTo(view: ClassicComponent, target: SimpleElement): void;
         _appendDefinition(root: OutletView | ClassicComponent, definition: CurriedValue, target: SimpleElement): void;
         cleanupRootFor(component: ClassicComponent): void;
         remove(view: ClassicComponent): void;
-        get _roots(): RootState[];
+        get _roots(): RendererRoot[];
         get _inRenderTransaction(): boolean;
         get _isInteractive(): boolean;
         get _context(): EvaluationContext;
@@ -208,5 +62,4 @@ declare module '@ember/-internals/glimmer/lib/renderer' {
             lastNode: SimpleNode;
         };
     }
-    export {};
 }

package/types/stable/@ember/-internals/glimmer/lib/router-resolver.d.ts

@@ -0,0 +1,17 @@
+declare module '@ember/-internals/glimmer/lib/router-resolver' {
+    import type { HelperDefinitionState } from "@glimmer/interfaces";
+    import type { InternalOwner } from "@ember/-internals/owner";
+    import type { Nullable } from "@ember/-internals/utility-types";
+    import ResolverImpl from "@ember/-internals/glimmer/lib/resolver";
+    /**
+     * The resolver used by the classic application `Renderer`. It extends the
+     * shared `ResolverImpl` with the keywords that require the router and engine
+     * infrastructure (`{{outlet}}` and `{{mount}}`). Keeping these out of the
+     * base resolver means renderers that have no router (e.g. `renderComponent`)
+     * do not pull the outlet/engine machinery into the build.
+     */
+    export default class RouterResolver extends ResolverImpl {
+        lookupBuiltInHelper(name: string): Nullable<HelperDefinitionState>;
+        lookupHelper(name: string, owner: InternalOwner): Nullable<HelperDefinitionState>;
+    }
+}

package/types/stable/@ember/-internals/metal/lib/tracked.d.ts

@@ -1,4 +1,5 @@
 declare module '@ember/-internals/metal/lib/tracked' {
+    import { type TrackedValue } from "@glimmer/validator/lib/tracked-value";
     import type { ExtendedMethodDecorator, DecoratorPropertyDescriptor } from "@ember/-internals/metal/lib/decorator";
     /**
       @decorator
@@ -62,14 +63,59 @@ declare module '@ember/-internals/metal/lib/tracked' {
 
       @param dependencies Optional dependents to be tracked.
     */
-    export function tracked(
-      propertyDesc: {
-          value: any;
-          initializer: () => any;
-      }
-    ): ExtendedMethodDecorator;
+    /**
+     * Reactivity options for the standalone `tracked(value, options)` form.
+     *
+     * - `equals` decides whether writing a value notifies consumers; it defaults to
+     *   `Object.is`.
+     * - `description` is used in development for debugging.
+     *
+     * `equals` is a function-typed property (rather than method syntax) on purpose:
+     * this keeps its parameters checked strictly, so passing an `equals` typed for
+     * the wrong value type is a type error instead of being silently accepted.
+     */
+    interface TrackedValueOptions<Value> {
+        equals?: (a: Value, b: Value) => boolean;
+        description?: string;
+    }
+    /**
+     * Options for `tracked` used as a decorator, or as a field on a *classic* class
+     * (`EmberObject.extend({ foo: tracked({ value }) })`).
+     *
+     * All properties are optional because this single shape backs several usages:
+     * classic-field defaults (`tracked({ value })` / `tracked({ initializer })`) and
+     * options-only native decorators (`@tracked({ equals })`). The mutually
+     * exclusive combinations (e.g. both `value` and `initializer`) and the
+     * classic-only restriction on `value`/`initializer` are enforced at runtime via
+     * assertions rather than in the type, matching the runtime `isDecoratorOptions`
+     * check that accepts any object composed of these keys.
+     *
+     * - `value` / `initializer` supply a default value and are only valid on classic
+     *   classes; native classes use class field initializers instead.
+     * - `equals` / `description` configure reactivity, mirroring
+     *   {@link TrackedValueOptions}.
+     */
+    interface TrackedDecoratorOptions {
+        value?: any;
+        initializer?: () => any;
+        equals?(a: any, b: any): boolean;
+        description?: string;
+    }
+    /**
+     * `tracked` as a decorator factory: `@tracked({ equals })`, or on classic
+     * classes `tracked({ value })` / `tracked({ initializer })`.
+     */
+    export function tracked(propertyDesc: TrackedDecoratorOptions): ExtendedMethodDecorator;
+    /**
+     * `tracked` as a bare decorator: `@tracked foo = 1`.
+     */
     export function tracked(target: object, key: string): void;
     export function tracked(target: object, key: string, desc: DecoratorPropertyDescriptor): DecoratorPropertyDescriptor;
+    /**
+     * `tracked` as a standalone reactive value, usable outside of classes:
+     * `const count = tracked(0)`.
+     */
+    export function tracked<Value>(initialValue: Value, options?: TrackedValueOptions<Value>): TrackedValue<Value>;
     export class TrackedDescriptor {
         private _get;
         private _set;
@@ -77,4 +123,5 @@ declare module '@ember/-internals/metal/lib/tracked' {
         get(obj: object): unknown;
         set(obj: object, _key: string, value: unknown): void;
     }
+    export {};
 }