Move get onto ReadOnlyReactive per RFC review

No new public CachedValue type: get() joins the ReadOnlyReactive
interface (an RFC 1071 oversight) and both cachedValue() and the
cached() overload return ReadOnlyReactive<Value>. The CachedValue
class stays as an internal implementation detail.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: NullVoxPopuli-ai-agent

packages/@ember/-internals/metal/lib/cached.ts

@@ -3,7 +3,8 @@
 // of @cached, so any changes made to one should also be made to the other
 import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-import { type CachedValue, cachedValue } from '@glimmer/validator/lib/cached-value';
+import { cachedValue } from '@glimmer/validator/lib/cached-value';
+import type { ReadOnlyReactive } from '@glimmer/validator/lib/tracked-value';
 import { createCache, getValue } from '@glimmer/validator/lib/tracking';
 
 /**
@@ -142,16 +143,19 @@ export function cached<T>(
  * `cached` as a standalone cached reactive value, usable outside of classes:
  * `const doubled = cached(() => count.value * 2)`.
  */
-export function cached<Value>(fn: () => Value, options?: CachedValueOptions): CachedValue<Value>;
-export function cached(...args: any[]): CachedValue<unknown> | void {
+export function cached<Value>(
+  fn: () => Value,
+  options?: CachedValueOptions
+): ReadOnlyReactive<Value>;
+export function cached(...args: any[]): ReadOnlyReactive<unknown> | void {
   const [target, key, descriptor] = args;
 
   // Error on `@cached()`, `@cached(...args)`, and `@cached propName = value;`
   if (DEBUG && target === undefined) throwCachedExtraneousParens();
 
   if (typeof target === 'function' && args.length <= 2) {
     /*
-      Standalone form. Returns a read-only `CachedValue` usable outside of
+      Standalone form. Returns a `ReadOnlyReactive` usable outside of
       classes. A legacy decorator invocation always receives three arguments,
       so it can never land in this branch.
 

packages/@glimmer/tracking/index.ts

@@ -6,7 +6,6 @@ export type {
   ReadOnlyReactive,
   TrackedValue,
 } from '@glimmer/validator/lib/tracked-value';
-export type { CachedValue } from '@glimmer/validator/lib/cached-value';
 
 /**
   In order to tell Ember a value might change, we need to mark it as trackable.

packages/@glimmer/validator/index.ts

@@ -8,7 +8,7 @@ if (Reflect.has(globalThis, GLIMMER_VALIDATOR_REGISTRATION)) {
 
 Reflect.set(globalThis, GLIMMER_VALIDATOR_REGISTRATION, true);
 
-export { CachedValue, cachedValue } from './lib/cached-value';
+export { cachedValue } from './lib/cached-value';
 export { trackedArray } from './lib/collections/array';
 export { trackedMap } from './lib/collections/map';
 export { trackedObject } from './lib/collections/object';

packages/@glimmer/validator/lib/cached-value.ts

@@ -9,7 +9,7 @@ import { type Cache, createCache, getValue } from './tracking';
  * re-invokes the wrapped function when tracked state it previously read has
  * changed.
  */
-export class CachedValue<Value = unknown> implements ReadOnlyReactive<Value> {
+class CachedValue<Value = unknown> implements ReadOnlyReactive<Value> {
   readonly #cache: Cache<Value>;
 
   constructor(fn: () => Value, options?: { description?: string }) {
@@ -35,6 +35,6 @@ export class CachedValue<Value = unknown> implements ReadOnlyReactive<Value> {
 export function cachedValue<Value>(
   fn: () => Value,
   options?: { description?: string }
-): CachedValue<Value> {
+): ReadOnlyReactive<Value> {
   return new CachedValue(fn, options);
 }

packages/@glimmer/validator/lib/tracked-value.ts

@@ -20,6 +20,11 @@ export interface Reactive<Value> {
  */
 export interface ReadOnlyReactive<Value> extends Reactive<Value> {
   readonly value: Value;
+
+  /**
+   * Function short-hand for reading `value`.
+   */
+  get: () => Value;
 }
 
 export class TrackedValue<Value = unknown> implements Reactive<Value> {

type-tests/@glimmer/tracking-test.ts

@@ -1,5 +1,5 @@
 import { cached, tracked } from '@glimmer/tracking';
-import type { CachedValue, Reactive, ReadOnlyReactive, TrackedValue } from '@glimmer/tracking';
+import type { Reactive, ReadOnlyReactive, TrackedValue } from '@glimmer/tracking';
 import { expectTypeOf } from 'expect-type';
 
 // ------- public types -------
@@ -53,12 +53,11 @@ expectTypeOf(tracked({ value: 'Zoey' }, {})).toMatchTypeOf<Reactive<Record<strin
 // ------- cached: standalone form -------
 const doubled = cached(() => count.value * 2);
 
-expectTypeOf(doubled).toMatchTypeOf<ReadOnlyReactive<number>>();
-expectTypeOf(doubled).toMatchTypeOf<CachedValue<number>>();
+expectTypeOf(doubled).toEqualTypeOf<ReadOnlyReactive<number>>();
 expectTypeOf(doubled.value).toEqualTypeOf<number>();
 expectTypeOf(doubled.get()).toEqualTypeOf<number>();
 
-// @ts-expect-error -- a CachedValue is read-only
+// @ts-expect-error -- the returned value is read-only
 doubled.value = 4;
 
 // ------- cached: standalone form with options -------