From 4eb777637a730425b6a34bdd9e0b511849f07721 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Sun, 19 Jan 2025 12:38:52 -0500
Subject: [PATCH 01/22] The Cell

---
 text/0000-cell.md | 167 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 text/0000-cell.md

diff --git a/text/0000-cell.md b/text/0000-cell.md
new file mode 100644
index 0000000000..fc0569854c
--- /dev/null
+++ b/text/0000-cell.md
@@ -0,0 +1,167 @@
+---
+stage: accepted
+start-date: 2025-01-19T00:00:00.000Z
+release-date: # In format YYYY-MM-DDT00:00:00.000Z
+release-versions:
+teams: # delete teams that aren't relevant
+  - cli
+  - data
+  - framework
+  - learning
+  - steering
+  - typescript
+prs:
+  accepted: # Fill this in with the URL for the Proposal RFC PR
+project-link:
+suite: 
+---
+
+<!--- 
+Directions for above: 
+
+stage: Leave as is
+start-date: Fill in with today's date, 2032-12-01T00:00:00.000Z
+release-date: Leave as is
+release-versions: Leave as is
+teams: Include only the [team(s)](README.md#relevant-teams) for which this RFC applies
+prs:
+  accepted: Fill this in with the URL for the Proposal RFC PR
+project-link: Leave as is
+suite: Leave as is
+-->
+
+<-- Replace "RFC title" with the title of your RFC -->
+# Introduce `Cell` 
+
+## Summary
+
+This RFC introduces a new tracking primitive, which represents a single value, the `Cell`.
+
+## Motivation
+
+The `Cell` is part of the "spreadsheet analogy" when talking about reactivity -- it represents a single tracked value, and can be created without the use of a class, making it a primate candidate for demos[^demos] and for creating reactive values in function-based APIs, such as _helpers_, _modifiers_, or _resources_. They also provide a benefit in testing as well, since tests tend to want to work with some state, the `Cell` is wholly encapsulated, and can be quickly created with 0 ceremony. 
+
+This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. 
+
+The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamentals/cells.html) and has been available for folks to try out in ember via [ember-resources](https://github.com/NullVoxPopuli/ember-resources/tree/main/docs/docs). 
+
+[^demos]: demos _must_ over simplify to bring attention to a specific concept. Too much syntax getting in the way easily distracts from what is trying to be demoed. This has benefits for actual app development as well though, as we're, by focusing on concise demo-ability, gradually removing the amount of typing needed to create features. 
+
+## Detailed design
+
+
+### Types 
+
+Some interfaces to share with future low-level reactive primitives:
+
+```ts
+
+interface Reactive<Value> {
+    /**
+    * The underlying value
+    */
+    current: Value;
+    /**
+    * Returns the underlying value
+    */
+    read(): Value;
+}
+
+interface ReadOnlyReactive<Value> extends Reactive<Value> {
+    /**
+    * The underlying value.
+    * Cannot be set.
+    */
+    readonly current: Value;
+
+    /**
+    * Returns the underlying value
+    */
+    read(): Value;
+}
+
+interface Cell<Value> extends Reactive<Value> {
+    /**
+    * Utility to create a Cell without the caller using the `new` keyword.
+    */
+    static create<T>(initialValue: T): Cell<T>;
+
+    /**
+    * Function short-hand of updating the current value
+    * of the Cell
+    */
+    set: (value: Value) => boolean;
+    /**
+    * Function short-hand for using the current value to 
+    * update the state of the Cell
+    */
+    update: (fn: (value: Value) => Value) => void;
+
+    /**
+     * Prevents further updates, making the Cell
+     * behave as a ReadOnlyReactive
+     */
+    freeze: () => void;
+}
+```
+
+
+### Usage
+
+Incrementing a count with local state.
+
+```gjs
+import { Cell } from '@glimmer/tracking';
+
+const increment = (cell) => cell.current++;
+
+<template>
+    {{#let (Cell.create @initialCount) as |count|}}
+       Count is: {{count.current}} 
+
+        <button {{on "click" (fn increment count)}}>add one</button>
+    {{/let}}
+</template>
+```
+
+Incrementing a count with module state.
+This is already common in demos.
+
+```gjs
+import { Cell } from '@glimmer/tracking';
+
+const count = Cell.create(0);
+const increment => count.current++;
+
+<template>
+   Count is: {{count.current}} 
+
+    <button {{on "click" increment}}>add one</button>
+</template>
+```
+
+
+### Re-implementing `@tracked` 
+
+
+## How we teach this
+
+The `Cell` is a primitive, and for most real applications, folks should continue to use classes, with `@tracked`, as the combination of classes with decorators provide unparalleled ergonomics in state management. 
+
+However, developers may think of `@tracked` (or decorators in general) as magic -- we can utilize `Cell` as a storytelling tool to demystify how `@tracked` works -- since `Cell` will be public API, we can easily explain how `Cell` is used to _create the `@tracked` decorator_.
+
+We can even use the example over-simplified implementation of `@tracked` from the _Detailed Design_ section above.
+
+
+## Drawbacks
+
+- another API
+
+## Alternatives
+
+- don't do it, we have tracked storage (tho, it is not implemented at the time of writing this RFC)
+
+## Unresolved questions
+
+- none yet
+

From c0b20b68f370d6baf787cb1e479610c71ccf2d50 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Sun, 19 Jan 2025 13:37:12 -0500
Subject: [PATCH 02/22] Update meta

---
 text/{0000-cell.md => 1071-cell.md} | 73 ++++++++++++++++++++++++++++-
 1 file changed, 72 insertions(+), 1 deletion(-)
 rename text/{0000-cell.md => 1071-cell.md} (79%)

diff --git a/text/0000-cell.md b/text/1071-cell.md
similarity index 79%
rename from text/0000-cell.md
rename to text/1071-cell.md
index fc0569854c..f67434c7f7 100644
--- a/text/0000-cell.md
+++ b/text/1071-cell.md
@@ -11,7 +11,7 @@ teams: # delete teams that aren't relevant
   - steering
   - typescript
 prs:
-  accepted: # Fill this in with the URL for the Proposal RFC PR
+  accepted: https://github.com/emberjs/rfcs/pull/1071
 project-link:
 suite: 
 ---
@@ -140,9 +140,80 @@ const increment => count.current++;
 </template>
 ```
 
+Using private mutable properties providing public read-only access:
+
+```gjs
+export class MyAPI {
+    #state = Cell.create(0);
+
+    get myValue() {
+        return this.#state;
+    }
+
+    doTheThing() {
+        this.#state = secretFunctionFromSomewhere(); 
+    }
+}
+```
+
 
 ### Re-implementing `@tracked` 
 
+For most current ember projects, using the TC39 Stage 1 implementation of decorators:
+
+```js
+function tracked(target, key, { initializer }) {
+  let cells = new WeakMap();
+
+  function getCell(obj) {
+    let cell = cells.get(obj);
+
+    if (cell === undefined) {
+      cell = Cell.create(initializer.call(this), () => false);
+      cells.set(this, cell);
+    }
+
+    return cell;
+  };
+
+  return {
+    get() {
+      return getCell(this).read();
+    },
+
+    set(value) {
+      getCell(this).set(value);
+    },
+  };
+}
+```
+
+<details><summary>Using spec / standards-decorators</summary>
+
+```js
+import { Cell } from '@glimmer/tracking';
+    
+export function tracked(target, context) {
+  const { get } = target;
+
+  return {
+    get() {
+      return get.call(this).read();
+    },
+
+    set(value) {
+      get.call(this).set(value);
+    },
+
+    init(value) {
+      return Cell.create(value);
+    },
+  };
+}
+```
+
+</details>
+
 
 ## How we teach this
 

From 7b9e4b753cca51bae963c7f49816d7de7edb652b Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Sun, 19 Jan 2025 13:54:54 -0500
Subject: [PATCH 03/22] The Cell

---
 text/1071-cell.md | 44 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index f67434c7f7..86f29375cd 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -84,7 +84,12 @@ interface Cell<Value> extends Reactive<Value> {
     /**
     * Utility to create a Cell without the caller using the `new` keyword.
     */
-    static create<T>(initialValue: T): Cell<T>;
+    static create<T>(initialValue: T, equals?: (a: T, b: T) => boolean): Cell<T>;
+
+    /**
+    * The constructor takes an optional initial value and optional equals function.
+    */
+    constructor(initialValue?: Value, equals?: (a: Value, b: Value) => boolean): {}
 
     /**
     * Function short-hand of updating the current value
@@ -105,6 +110,41 @@ interface Cell<Value> extends Reactive<Value> {
 }
 ```
 
+Behaviorally, the `Cell` behaves almost the same as this function:
+```js
+class CellPolyfill {
+    @tracked current;
+    #isFrozen = false;
+
+    constructor(initialValue) {
+        this.current = initialValue;
+    }
+
+    read() {
+        return this.current;
+    }
+
+    set(value) {
+        assert(`Cannot set a frozen Cell`, !this.#isFrozen);
+        this.current = value;
+    }
+
+    update(updater) {
+        assert(`Cannot update a frozen Cell`, !this.#isFrozen);
+        this.set(updater(this.read()));
+    }
+
+    freeze() {
+        this.#isFrozen = true;
+    }
+}
+```
+
+The key difference is that with a primitive, we expose a new way for developers to decide when their value becomes dirty.
+The above example, and the default value, would use the "always dirty" behavior of `() => false`.
+
+This default value allows the `Cell` to be the backing implementation if `@tracked`, as `@tracked` values do not have equalty checking to decide when to become dirty.
+
 
 ### Usage
 
@@ -230,7 +270,7 @@ We can even use the example over-simplified implementation of `@tracked` from th
 
 ## Alternatives
 
-- don't do it, we have tracked storage (tho, it is not implemented at the time of writing this RFC)
+- Have the cell's equality function check value-equality of primitives, rather than _always_ dirty. This may mean that folks apps could subtly break if we changed the `@tracked` implementation. But we could maybe provide a different tracked implementation from a different import, if we want to pursue this equality checking without breaking folks existing apps.
 
 ## Unresolved questions
 

From 21cef4c605f07fbef6cc6e171a948d8bb07711f5 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Sun, 19 Jan 2025 13:57:25 -0500
Subject: [PATCH 04/22] The Cell

---
 text/1071-cell.md | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 86f29375cd..271cad85a5 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -145,6 +145,24 @@ The above example, and the default value, would use the "always dirty" behavior
 
 This default value allows the `Cell` to be the backing implementation if `@tracked`, as `@tracked` values do not have equalty checking to decide when to become dirty.
 
+For example, with this Cell and equality function:
+
+```gjs
+const value = Cell.create(0, (a, b) => a === b);
+
+const selfAssign = () => value.current = value.current;
+
+<template>
+    <output>{{value}}</output>
+
+    <button {{on 'click' selfAssign}}>Click me</button> 
+</template>
+```
+
+The contents of the `output` element would never re-render due to the value never changing. 
+
+This differs from `@tracked`, as the contents of `output` would always re-render.
+
 
 ### Usage
 

From 3aee4a253c57e141f09fd9741f20ca40066995cd Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Sun, 9 Feb 2025 15:53:37 -0500
Subject: [PATCH 05/22] Update text/1071-cell.md

---
 text/1071-cell.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 271cad85a5..b01d222b0e 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -89,7 +89,7 @@ interface Cell<Value> extends Reactive<Value> {
     /**
     * The constructor takes an optional initial value and optional equals function.
     */
-    constructor(initialValue?: Value, equals?: (a: Value, b: Value) => boolean): {}
+    constructor(initialValue: Value, equals?: (a: Value, b: Value) => boolean): {}
 
     /**
     * Function short-hand of updating the current value

From 0d7b5e10970c207fbed4896fc833e59d2853c965 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Sun, 9 Feb 2025 16:04:59 -0500
Subject: [PATCH 06/22] Update from todos

---
 text/1071-cell.md | 27 ++++++++++++++++++---------
 1 file changed, 18 insertions(+), 9 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index b01d222b0e..63730fb964 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -84,7 +84,7 @@ interface Cell<Value> extends Reactive<Value> {
     /**
     * Utility to create a Cell without the caller using the `new` keyword.
     */
-    static create<T>(initialValue: T, equals?: (a: T, b: T) => boolean): Cell<T>;
+    static create<T>(initialValue: T, equals?: (a: T, b: T) => boolean, description?: string): Cell<T>;
 
     /**
     * The constructor takes an optional initial value and optional equals function.
@@ -113,25 +113,34 @@ interface Cell<Value> extends Reactive<Value> {
 Behaviorally, the `Cell` behaves almost the same as this function:
 ```js
 class CellPolyfill {
-    @tracked current;
     #isFrozen = false;
+    #value;
 
-    constructor(initialValue) {
-        this.current = initialValue;
+    constructor(initialValue, equals, description) {
+        this.#value = initialValue;
+        // ...
+    }
+
+    get current() {
+        // + consume
+        return this.#value;
     }
 
     read() {
-        return this.current;
+        // + consume
+        return this.#value;
     }
 
     set(value) {
         assert(`Cannot set a frozen Cell`, !this.#isFrozen);
-        this.current = value;
+        // + dirty
+        this.#value = value;
     }
 
     update(updater) {
         assert(`Cannot update a frozen Cell`, !this.#isFrozen);
-        this.set(updater(this.read()));
+        // #value is not tracked
+        this.set(updater(this.#value));
     }
 
     freeze() {
@@ -227,7 +236,7 @@ function tracked(target, key, { initializer }) {
     let cell = cells.get(obj);
 
     if (cell === undefined) {
-      cell = Cell.create(initializer.call(this), () => false);
+      cell = Cell.create(initializer.call(this), null, `tracked:${key}`);
       cells.set(this, cell);
     }
 
@@ -264,7 +273,7 @@ export function tracked(target, context) {
     },
 
     init(value) {
-      return Cell.create(value);
+      return Cell.create(value, null, `tracked:${key}`);
     },
   };
 }

From 99e40db520dc77ddc926a7261005a634db5a0465 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Tue, 11 Feb 2025 15:31:46 -0500
Subject: [PATCH 07/22] Apply performance feedback around class instantiation,
 reducing allocations, and ensuring that there is only one in-memory copy of
 the class by making all arguments required

---
 text/1071-cell.md | 56 +++++++++++++++++++++++++++++++++--------------
 1 file changed, 40 insertions(+), 16 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 63730fb964..3c1797a93c 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -80,16 +80,34 @@ interface ReadOnlyReactive<Value> extends Reactive<Value> {
     read(): Value;
 }
 
-interface Cell<Value> extends Reactive<Value> {
-    /**
-    * Utility to create a Cell without the caller using the `new` keyword.
-    */
-    static create<T>(initialValue: T, equals?: (a: T, b: T) => boolean, description?: string): Cell<T>;
+/**
+* Utility to create a Cell without the caller using the `new` keyword.
+* exists as a separate function so that in memory, there is only one copy of the Cell class,
+* with a single constructor.
+*/
+function cell<Value>(
+  initialValue: Value,
+  options?: { equals: (a: Value, b: Value) => boolean, description?: string } = {}
+) {
+  return new Cell(
+    initialValue,
+    {
+      equals: options?.equals ?? Object.is,
+      description: options?.description
+    }
+  );
+}
 
+interface Cell<Value> extends Reactive<Value> {
     /**
     * The constructor takes an optional initial value and optional equals function.
     */
-    constructor(initialValue: Value, equals?: (a: Value, b: Value) => boolean): {}
+    constructor(
+      initialValue: Value,
+      options: {
+        equals: (a: Value, b: Value) => boolean;
+        description: string
+      }): {}
 
     /**
     * Function short-hand of updating the current value
@@ -112,12 +130,18 @@ interface Cell<Value> extends Reactive<Value> {
 
 Behaviorally, the `Cell` behaves almost the same as this function:
 ```js
+function cell(initial, { equals, description ) = {}) {
+  return new CellPolyfill(initial, { equals, description });
+}
+
 class CellPolyfill {
     #isFrozen = false;
     #value;
 
-    constructor(initialValue, equals, description) {
+    constructor(initialValue, options) {
         this.#value = initialValue;
+        this.#equals = options.equals;
+        this.#description = options.description;
         // ...
     }
 
@@ -157,7 +181,7 @@ This default value allows the `Cell` to be the backing implementation if `@track
 For example, with this Cell and equality function:
 
 ```gjs
-const value = Cell.create(0, (a, b) => a === b);
+const value = cell(0, { equals (a, b) => a === b });
 
 const selfAssign = () => value.current = value.current;
 
@@ -178,12 +202,12 @@ This differs from `@tracked`, as the contents of `output` would always re-render
 Incrementing a count with local state.
 
 ```gjs
-import { Cell } from '@glimmer/tracking';
+import { cell } from '@glimmer/tracking';
 
-const increment = (cell) => cell.current++;
+const increment = (c) => c.current++;
 
 <template>
-    {{#let (Cell.create @initialCount) as |count|}}
+    {{#let (cell @initialCount) as |count|}}
        Count is: {{count.current}} 
 
         <button {{on "click" (fn increment count)}}>add one</button>
@@ -195,9 +219,9 @@ Incrementing a count with module state.
 This is already common in demos.
 
 ```gjs
-import { Cell } from '@glimmer/tracking';
+import { cell } from '@glimmer/tracking';
 
-const count = Cell.create(0);
+const count = cell(0);
 const increment => count.current++;
 
 <template>
@@ -211,7 +235,7 @@ Using private mutable properties providing public read-only access:
 
 ```gjs
 export class MyAPI {
-    #state = Cell.create(0);
+    #state = cell(0);
 
     get myValue() {
         return this.#state;
@@ -236,7 +260,7 @@ function tracked(target, key, { initializer }) {
     let cell = cells.get(obj);
 
     if (cell === undefined) {
-      cell = Cell.create(initializer.call(this), null, `tracked:${key}`);
+      cell = new Cell(initializer.call(this), { equals: null, description: `tracked:${key}` });
       cells.set(this, cell);
     }
 
@@ -273,7 +297,7 @@ export function tracked(target, context) {
     },
 
     init(value) {
-      return Cell.create(value, null, `tracked:${key}`);
+      return new Cell(value, { equals: null, description: `tracked:${key}` });
     },
   };
 }

From 40744af0ecc565052e462568e2975c8a9f3979ae Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Thu, 13 Feb 2025 16:47:13 -0500
Subject: [PATCH 08/22] Update 1071-cell.md

---
 text/1071-cell.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 3c1797a93c..e9233e7309 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -99,9 +99,6 @@ function cell<Value>(
 }
 
 interface Cell<Value> extends Reactive<Value> {
-    /**
-    * The constructor takes an optional initial value and optional equals function.
-    */
     constructor(
       initialValue: Value,
       options: {

From ec260e2c0f4333ca9ae5e6b19d795e655fabaf27 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 14 Feb 2025 14:57:56 -0500
Subject: [PATCH 09/22] Update Cell to mention that it supercedes tracked
 storage

---
 text/1071-cell.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index e9233e7309..5e85e0a3e1 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -41,7 +41,7 @@ This RFC introduces a new tracking primitive, which represents a single value, t
 
 The `Cell` is part of the "spreadsheet analogy" when talking about reactivity -- it represents a single tracked value, and can be created without the use of a class, making it a primate candidate for demos[^demos] and for creating reactive values in function-based APIs, such as _helpers_, _modifiers_, or _resources_. They also provide a benefit in testing as well, since tests tend to want to work with some state, the `Cell` is wholly encapsulated, and can be quickly created with 0 ceremony. 
 
-This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. 
+This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use.  The `Cell` aims to replace the still unilimited tracked storage primitives, and  `Cell` can be what provides the implementation of `TrackedArray`, etc
 
 The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamentals/cells.html) and has been available for folks to try out in ember via [ember-resources](https://github.com/NullVoxPopuli/ember-resources/tree/main/docs/docs). 
 

From 54f5d89c2fb27b838b5ce61ef26138d03582ab42 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Thu, 20 Feb 2025 18:08:03 -0500
Subject: [PATCH 10/22] Clarify that only 'cell' is exported as a value

---
 text/1071-cell.md | 35 ++++++++++++++++++++++++++---------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 5e85e0a3e1..d4132cdc2a 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -41,7 +41,7 @@ This RFC introduces a new tracking primitive, which represents a single value, t
 
 The `Cell` is part of the "spreadsheet analogy" when talking about reactivity -- it represents a single tracked value, and can be created without the use of a class, making it a primate candidate for demos[^demos] and for creating reactive values in function-based APIs, such as _helpers_, _modifiers_, or _resources_. They also provide a benefit in testing as well, since tests tend to want to work with some state, the `Cell` is wholly encapsulated, and can be quickly created with 0 ceremony. 
 
-This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use.  The `Cell` aims to replace the still unilimited tracked storage primitives, and  `Cell` can be what provides the implementation of `TrackedArray`, etc
+This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. 
 
 The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamentals/cells.html) and has been available for folks to try out in ember via [ember-resources](https://github.com/NullVoxPopuli/ember-resources/tree/main/docs/docs). 
 
@@ -49,19 +49,32 @@ The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamenta
 
 ## Detailed design
 
+> [!NOTE]  
+> Only `cell` will be importable as a value. The types will also be importable, but the `Cell` class is private. 
 
 ### Types 
 
 Some interfaces to share with future low-level reactive primitives:
 
-```ts
-
+~~~ts
 interface Reactive<Value> {
-    /**
+   /**
     * The underlying value
+    *
+    * Allows easy usage of reactive values in templates.
+    *
+    * @example
+    *
+    * ```gjs
+    * const myCell = cell(0);
+    * <template>
+    *   {{myCell.current}}
+    * </template>
+    * ```
     */
     current: Value;
-    /**
+
+   /**
     * Returns the underlying value
     */
     read(): Value;
@@ -86,8 +99,11 @@ interface ReadOnlyReactive<Value> extends Reactive<Value> {
 * with a single constructor.
 */
 function cell<Value>(
-  initialValue: Value,
-  options?: { equals: (a: Value, b: Value) => boolean, description?: string } = {}
+    initialValue: Value,
+    options?: { 
+        equals: (a: Value, b: Value) => boolean, 
+        description?: string 
+    } = {}
 ) {
   return new Cell(
     initialValue,
@@ -123,7 +139,7 @@ interface Cell<Value> extends Reactive<Value> {
      */
     freeze: () => void;
 }
-```
+~~~
 
 Behaviorally, the `Cell` behaves almost the same as this function:
 ```js
@@ -160,7 +176,8 @@ class CellPolyfill {
 
     update(updater) {
         assert(`Cannot update a frozen Cell`, !this.#isFrozen);
-        // #value is not tracked
+        // #value is not tracked, 
+        // so update reads without consuming
         this.set(updater(this.#value));
     }
 

From 9f32baca1ed69227a3ce2986939f20daa7bd078e Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 21 Feb 2025 14:50:45 -0500
Subject: [PATCH 11/22] Update 1071-cell.md

---
 text/1071-cell.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index d4132cdc2a..736878cf71 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -31,7 +31,7 @@ suite: Leave as is
 -->
 
 <-- Replace "RFC title" with the title of your RFC -->
-# Introduce `Cell` 
+# Introduce `cell` 
 
 ## Summary
 

From 9de5ab18b5c364187228e15de8973e4eb42ee987 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 21 Feb 2025 15:04:56 -0500
Subject: [PATCH 12/22] Update 1071-cell.md

---
 text/1071-cell.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 736878cf71..df940bf96e 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -41,7 +41,7 @@ This RFC introduces a new tracking primitive, which represents a single value, t
 
 The `Cell` is part of the "spreadsheet analogy" when talking about reactivity -- it represents a single tracked value, and can be created without the use of a class, making it a primate candidate for demos[^demos] and for creating reactive values in function-based APIs, such as _helpers_, _modifiers_, or _resources_. They also provide a benefit in testing as well, since tests tend to want to work with some state, the `Cell` is wholly encapsulated, and can be quickly created with 0 ceremony. 
 
-This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. 
+This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. This RFC intends to replace the unimplemented storage-primitives. 
 
 The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamentals/cells.html) and has been available for folks to try out in ember via [ember-resources](https://github.com/NullVoxPopuli/ember-resources/tree/main/docs/docs). 
 

From 5004f230409cf13a97a93435cbfa5f1ac21af29a Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 21 Feb 2025 15:10:54 -0500
Subject: [PATCH 13/22] Remove constructor from the public interface

---
 text/1071-cell.md | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index df940bf96e..814c293759 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -115,13 +115,6 @@ function cell<Value>(
 }
 
 interface Cell<Value> extends Reactive<Value> {
-    constructor(
-      initialValue: Value,
-      options: {
-        equals: (a: Value, b: Value) => boolean;
-        description: string
-      }): {}
-
     /**
     * Function short-hand of updating the current value
     * of the Cell

From a6acfb5aa2479ec389d5c73adf40ad92bda0a611 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 21 Feb 2025 15:11:10 -0500
Subject: [PATCH 14/22] Remove boilerplate

---
 text/1071-cell.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 814c293759..2d058a3761 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -30,7 +30,6 @@ project-link: Leave as is
 suite: Leave as is
 -->
 
-<-- Replace "RFC title" with the title of your RFC -->
 # Introduce `cell` 
 
 ## Summary

From e7170ccf7c538c11bc3ef9fb1d5f922c0a928465 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 21 Feb 2025 18:57:33 -0500
Subject: [PATCH 15/22] Add explicit examples

---
 text/1071-cell.md | 86 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 2d058a3761..fc42fc7963 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -320,6 +320,92 @@ However, developers may think of `@tracked` (or decorators in general) as magic
 
 We can even use the example over-simplified implementation of `@tracked` from the _Detailed Design_ section above.
 
+### When to use `current`
+
+Allows for easy use in templates as well as assignment
+
+```gjs
+import { cell } from '@glimmer/tracking';
+
+const increment = (c) => c.current++;
+
+<template>
+    {{#let (cell @initialCount) as |count|}}
+       Count is: {{count.current}} 
+
+        <button {{on "click" (fn increment count)}}>add one</button>
+    {{/let}}
+</template>
+```
+
+### When to use `read()`
+
+Useful for when you want to explicitly entangle with tracking, and doesn't get flagged by linters as a no-op (as just accessing `.current` would as a lone expression):
+```gjs
+import { cell } from '@glimmer/tracking';
+
+let num = cell(0);
+
+export class Demo extends Component {
+    get foo() {
+        num.read();
+        // ...
+    }
+
+    <template>
+        {{this.foo}}
+    </template>
+}
+
+```
+
+### When to use `set()`
+
+Allows partial application, e.g.:
+
+```gjs
+import { cell } from '@glimmer/tracking';
+
+<template>
+    {{#let (cell @initialCount) as |count|}}
+       Count is: {{count.current}} 
+
+        <button {{on "click" (fn count.set 1)}}>set one</button>
+        <button {{on "click" (fn count.set 2)}}>set two</button>
+    {{/let}}
+</template>
+```
+
+### When to use `update()`
+
+Allows updating a value without consuming/entangling with the current value.
+Can be useful for changing the initial value once.
+
+
+```gjs
+import { cell } from '@glimmer/tracking';
+
+let num = cell(0);
+
+export class Demo extends Component {
+    constructor() {
+        super(...arguments);
+
+        num.update((previous) => previous + 1);
+    }
+
+    <template>
+        {{num.current}} => renders 1
+    </template>
+}
+
+```
+
+
+### When to use `freeze()`
+
+Prevents further updates to the Cell. 
+
 
 ## Drawbacks
 

From 6968d73599e6b818ccb0161eca9b28e10e5af556 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 7 Mar 2025 14:36:56 -0500
Subject: [PATCH 16/22] Update 1071-cell.md

---
 text/1071-cell.md | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index fc42fc7963..c32ebbf987 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -154,6 +154,11 @@ class CellPolyfill {
         // + consume
         return this.#value;
     }
+    set current(value) {
+        assert(`Cannot set a frozen Cell`, !this.#isFrozen);
+        // + dirty
+        this.#value = value;
+    } 
 
     read() {
         // + consume
@@ -161,16 +166,13 @@ class CellPolyfill {
     }
 
     set(value) {
-        assert(`Cannot set a frozen Cell`, !this.#isFrozen);
-        // + dirty
-        this.#value = value;
+        this.current = value;
     }
 
     update(updater) {
-        assert(`Cannot update a frozen Cell`, !this.#isFrozen);
         // #value is not tracked, 
         // so update reads without consuming
-        this.set(updater(this.#value));
+        this.current = updater(this.#value);
     }
 
     freeze() {

From 300cfd877c5304c37595f6f7f889a58a71a9fae2 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Fri, 7 Mar 2025 14:44:25 -0500
Subject: [PATCH 17/22] Remove .read()

---
 text/1071-cell.md | 40 ++--------------------------------------
 1 file changed, 2 insertions(+), 38 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index c32ebbf987..d84887cc67 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -72,11 +72,6 @@ interface Reactive<Value> {
     * ```
     */
     current: Value;
-
-   /**
-    * Returns the underlying value
-    */
-    read(): Value;
 }
 
 interface ReadOnlyReactive<Value> extends Reactive<Value> {
@@ -85,11 +80,6 @@ interface ReadOnlyReactive<Value> extends Reactive<Value> {
     * Cannot be set.
     */
     readonly current: Value;
-
-    /**
-    * Returns the underlying value
-    */
-    read(): Value;
 }
 
 /**
@@ -160,11 +150,6 @@ class CellPolyfill {
         this.#value = value;
     } 
 
-    read() {
-        // + consume
-        return this.#value;
-    }
-
     set(value) {
         this.current = value;
     }
@@ -277,7 +262,7 @@ function tracked(target, key, { initializer }) {
 
   return {
     get() {
-      return getCell(this).read();
+      return getCell(this).current;
     },
 
     set(value) {
@@ -297,7 +282,7 @@ export function tracked(target, context) {
 
   return {
     get() {
-      return get.call(this).read();
+      return get.call(this).current;
     },
 
     set(value) {
@@ -340,27 +325,6 @@ const increment = (c) => c.current++;
 </template>
 ```
 
-### When to use `read()`
-
-Useful for when you want to explicitly entangle with tracking, and doesn't get flagged by linters as a no-op (as just accessing `.current` would as a lone expression):
-```gjs
-import { cell } from '@glimmer/tracking';
-
-let num = cell(0);
-
-export class Demo extends Component {
-    get foo() {
-        num.read();
-        // ...
-    }
-
-    <template>
-        {{this.foo}}
-    </template>
-}
-
-```
-
 ### When to use `set()`
 
 Allows partial application, e.g.:

From 97619f9f9e7a5712d40ccef1e4e8f2d258e9b4ec Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Tue, 5 Aug 2025 12:38:30 -0400
Subject: [PATCH 18/22] Cover naming

---
 text/1071-cell.md | 218 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 218 insertions(+)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index d84887cc67..eb9bfb702a 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -107,6 +107,9 @@ interface Cell<Value> extends Reactive<Value> {
     /**
     * Function short-hand of updating the current value
     * of the Cell
+    *
+    * This is a convience method for different usage-styles, and is functionally the same as
+    * assigning the `.current` value.
     */
     set: (value: Value) => boolean;
     /**
@@ -118,6 +121,8 @@ interface Cell<Value> extends Reactive<Value> {
     /**
      * Prevents further updates, making the Cell
      * behave as a ReadOnlyReactive
+     *
+     * This is an optimization that avoids update-checking later.
      */
     freeze: () => void;
 }
@@ -298,6 +303,73 @@ export function tracked(target, context) {
 
 </details>
 
+### Usage as "side-signals"
+
+Side-signals are the reactive approach used in tracked-bulit-ins, and other reactive-collections, where the Signal/Cell/tracked value isn't relevant / not used, and the reactive collection only uses the reactive structure for telling the renderer when to update/render/etc.
+
+This can often be done with proxies:
+```ts
+import { cell } from '@glimmer/tracking';
+
+const nonReactiveObject = {};
+
+let cache = new WeakMap<object, Map<key, Cell>>();
+
+function getReactivity(obj) {
+    if (cache.has(obj)) {
+        return reactiveCache.get(obj);
+    }
+
+    let cacheForObj = new Map();
+    reactiveCache.set(obj, cacheForObj);
+    return cacheForObj;
+}
+
+function consume(cacheForObj, key) {
+    let cache = keyCache(cacheForObj, key);
+
+    cache.read();
+}
+
+function dirty(cacheForObj, key) {
+    let cache = keyCache(cacheForObj, key);
+
+    cache.set(null);
+}
+
+function keyCache(obj, key) {
+    let existing = cacheForObj.get(key);
+
+    if (existing) {
+        return existing;
+    }
+
+    existing = cell(null, { equals: () => false });
+    cacheForObj.set(existing, key);
+    return existing;
+}
+
+const myReactiveObject = new Proxy(nonReactiveObject, {
+    get(target, key) {
+        let reactiveValues = getReactivity(target);
+
+        consume(reactiveValues, key);
+
+        return Refluct.get(...arguments);
+    },
+    set(target, key, value) {
+        let reactiveValues = getReactivity(target);
+
+        dirty(reactiveValues, key);
+
+        return Refluct.set(...arguments);
+    }
+});
+
+// now using `myReactiveObject` is reactive
+myReactiveObject.foo = 2; 
+```
+
 
 ## How we teach this
 
@@ -385,3 +457,149 @@ Prevents further updates to the Cell.
 
 - none yet
 
+## Appendix
+
+### Naming
+
+Naming in the broader context of the JavaScript ecosystem, and why we're using "Cell"[^other-rfcs-pending][^relationships-for-demonstration-only]:
+
+
+[^other-rfcs-pending]: Other RFCs are pending for this all to be fully coherent and make sense. For example, we need [RFC #1122: Resources](https://github.com/emberjs/rfcs/pull/1122) as well as a (at the time of writing) not yet submitted RFC for how we adapt with TC39 Signals, and the other reactive ecosystems[^implementation-details].
+
+
+[^relationships-for-demonstration-only]: The relationships shown between TC39 and the respective frameworks here are speculative, and while we can prepare for reactive programming making in to _THE PLATFORM_ and have what's going on in the broader ecosystem, it is too early to _formally support_ something like TC39 Signals. But this is not to say we can't have interop with something generic in the future (so if folks wanted to use something they're actively told not use in production, they could)
+
+[^implementation-details]: the details of how Cell gets implemented _could_ be the glue that holds all ecosystems together. More on that in another RFC (see also: [Starbeam](https://starbeamjs.com/)).
+
+```mermaid
+---
+title: "Reactive primitive naming"
+---
+flowchart LR
+    tracked("@tracked")
+    subgraph TC39
+        Signal("Signal.State")
+        Computed("Signal.Computed")
+    end
+
+    subgraph "Framework Wrappers"
+        subgraph "Vue"
+            ref
+            reactiveVue("reactive()")
+            computedVue("computed()")
+        end
+
+        subgraph "Svelte"
+            state("$state")
+            reactiveSvelte("reactive()")
+            derived("$derived.by()")
+        end
+
+        subgraph "Ember"
+            cell
+            tracked
+            reactiveEmber("reactive{Object,etc}()")
+            cached("@cached")
+        end
+
+        subgraph "Solid"
+            createSignal
+            createMemo
+        end
+    end
+
+    TC39-->Vue
+    TC39-->Svelte
+    TC39-->Solid
+    TC39-->Ember
+```
+
+#### TC39
+
+Current proposed namespace is `Signal`, but an individual state value _is_ called a `Signal`.
+
+#### Vue
+
+Vue uses `ref` for state and `computed()` for cached values.
+
+```mermaid
+flowchart LR
+    subgraph TC39
+        Signal("Signal.State")
+        Computed("Signal.Computed")
+    end
+
+    subgraph "Vue"
+        Signal-->ref
+        Signal-->reactiveVue("reactive()")
+        Computed-->computedVue("computed()")
+    end
+```
+
+
+#### Svelte
+
+Svelte uses _runes_, and changes semantics of syntax of runtime javascript, to help its developers type less (at the cost of learning magic behavior).
+
+But they use `$state` and `$derived` for their state + cache concepts.
+
+```mermaid
+flowchart LR
+    subgraph TC39
+        Signal("Signal.State")
+        Computed("Signal.Computed")
+    end
+
+    subgraph "Svelte"
+        Signal-->state("$state")
+        Signal-->reactiveSvelte("reactive()")
+        Computed-->derived("$derived.by()")
+    end
+```
+
+#### Solid
+
+Solid has a slight SEO situation as their primitive value is _also_ called a Signal conflates TC39's Signal with its own Signals. This can be an SEO problem, as folks searching for "JavaScript Signals" can find results for both TC39 Signals and Solid Signals.
+
+This brings up something we need to consider when naming -- the intent of what we're using in our reactive programs/apps vs what the name of the actual APIs. 
+
+```mermaid
+flowchart LR
+    subgraph TC39
+        Signal("Signal.State")
+        Computed("Signal.Computed")
+    end
+
+    subgraph "Solid"
+        Signal-->createSignal
+        Computed-->createMemo
+    end
+```
+
+#### Ember
+
+We have a strong case for using `cell` in Ember, because of the aforementioned "spreadsheet analogy".
+
+`cell` is a single value, and it isn't currently used by any of the other reactive frameworks, thus helping with our SEO (avoiding conflation, as we'd have with `Signal`, or if we chose any other name, we'd conflict and be conflated with the other frameworks).
+
+TC39 has chosen _computed_ for its cache, which we _cannot_ use due to our historical use of `computed()` and `@computed` in pre-Octane-era Ember (pre 2019), so sticking to `@cached` makes sense for us long-term.
+
+```mermaid
+flowchart LR
+    tracked("@tracked")
+    subgraph TC39
+        Signal("Signal.State")
+        Computed("Signal.Computed")
+    end
+
+    subgraph "Ember"
+        Signal-->cell
+        Signal-->tracked
+        Signal-->reactiveEmber("reactive{Object,etc}()")
+        Computed-->cached("@cached")
+    end
+```
+
+> [!IMPORTANT]
+> We have no intention of renaming our our core utilities in ember as that would cause a ton of unneeded churn for no value. This deos not mean that at some point in the future, all the other framework's utilities wouldn't be usable in ember. We want our specific names (Cell, etc), to be unique to ember for both SEO reasons, and for future conflict avoidance reasons (which are currently outside the scope of this RFC)
+

From 8a758f1ea3c1915c4641a095f86bd20cbd2a7ecd Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Tue, 5 Aug 2025 13:05:41 -0400
Subject: [PATCH 19/22] updates

---
 text/1071-cell.md | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index eb9bfb702a..38e444fada 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -51,6 +51,12 @@ The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamenta
 > [!NOTE]  
 > Only `cell` will be importable as a value. The types will also be importable, but the `Cell` class is private. 
 
+```ts
+import { cell, type Cell } from '@glimmer/tracking';
+// and/or
+import { cell, type Cell } from '@ember/reactive';
+```
+
 ### Types 
 
 Some interfaces to share with future low-level reactive primitives:
@@ -255,14 +261,14 @@ function tracked(target, key, { initializer }) {
   let cells = new WeakMap();
 
   function getCell(obj) {
-    let cell = cells.get(obj);
+    let myCell = cells.get(obj);
 
-    if (cell === undefined) {
-      cell = new Cell(initializer.call(this), { equals: null, description: `tracked:${key}` });
-      cells.set(this, cell);
+    if (myCell === undefined) {
+      myCell = cell(initializer.call(this), { equals: null, description: `tracked:${key}` });
+      cells.set(this, myCell);
     }
 
-    return cell;
+    return myCell;
   };
 
   return {
@@ -280,7 +286,7 @@ function tracked(target, key, { initializer }) {
 <details><summary>Using spec / standards-decorators</summary>
 
 ```js
-import { Cell } from '@glimmer/tracking';
+import { cell } from '@glimmer/tracking';
     
 export function tracked(target, context) {
   const { get } = target;
@@ -295,7 +301,7 @@ export function tracked(target, context) {
     },
 
     init(value) {
-      return new Cell(value, { equals: null, description: `tracked:${key}` });
+      return cell(value, { equals: null, description: `tracked:${key}` });
     },
   };
 }

From c7786b69f7a40a9439296c9e0464917181cdcf37 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Tue, 5 Aug 2025 13:55:18 -0400
Subject: [PATCH 20/22] updates

---
 text/1071-cell.md | 48 ++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 37 insertions(+), 11 deletions(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 38e444fada..dd453d6b76 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -40,20 +40,20 @@ This RFC introduces a new tracking primitive, which represents a single value, t
 
 The `Cell` is part of the "spreadsheet analogy" when talking about reactivity -- it represents a single tracked value, and can be created without the use of a class, making it a primate candidate for demos[^demos] and for creating reactive values in function-based APIs, such as _helpers_, _modifiers_, or _resources_. They also provide a benefit in testing as well, since tests tend to want to work with some state, the `Cell` is wholly encapsulated, and can be quickly created with 0 ceremony. 
 
-This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md). The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. This RFC intends to replace the unimplemented storage-primitives. 
+This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md)[^tracked-storage-future]. The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. This RFC intends to replace the unimplemented storage-primitives. 
 
 The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamentals/cells.html) and has been available for folks to try out in ember via [ember-resources](https://github.com/NullVoxPopuli/ember-resources/tree/main/docs/docs). 
 
 [^demos]: demos _must_ over simplify to bring attention to a specific concept. Too much syntax getting in the way easily distracts from what is trying to be demoed. This has benefits for actual app development as well though, as we're, by focusing on concise demo-ability, gradually removing the amount of typing needed to create features. 
 
+[^tracked-storage-future]: This may likely be deprecated at some point -- especially since it was never implemented, and `cell` is a better successor to it (in general). The library itself will need to be converted to a v2 addon, and then at some point we can add a message to the top of the README stating that we don't intend to implement it in Ember (but the library will still exist, and builts on top of public APIs, so the library itself does not need to be deprecated). Any actoun around this is outside the scope of this RFC.
+
 ## Detailed design
 
 > [!NOTE]  
 > Only `cell` will be importable as a value. The types will also be importable, but the `Cell` class is private. 
 
 ```ts
-import { cell, type Cell } from '@glimmer/tracking';
-// and/or
 import { cell, type Cell } from '@ember/reactive';
 ```
 
@@ -206,7 +206,7 @@ This differs from `@tracked`, as the contents of `output` would always re-render
 Incrementing a count with local state.
 
 ```gjs
-import { cell } from '@glimmer/tracking';
+import { cell } from '@ember/reactive';
 
 const increment = (c) => c.current++;
 
@@ -223,7 +223,7 @@ Incrementing a count with module state.
 This is already common in demos.
 
 ```gjs
-import { cell } from '@glimmer/tracking';
+import { cell } from '@ember/reactive';
 
 const count = cell(0);
 const increment => count.current++;
@@ -286,7 +286,7 @@ function tracked(target, key, { initializer }) {
 <details><summary>Using spec / standards-decorators</summary>
 
 ```js
-import { cell } from '@glimmer/tracking';
+import { cell } from '@ember/reactive';
     
 export function tracked(target, context) {
   const { get } = target;
@@ -315,7 +315,7 @@ Side-signals are the reactive approach used in tracked-bulit-ins, and other reac
 
 This can often be done with proxies:
 ```ts
-import { cell } from '@glimmer/tracking';
+import { cell } from '@ember/reactive';
 
 const nonReactiveObject = {};
 
@@ -390,7 +390,7 @@ We can even use the example over-simplified implementation of `@tracked` from th
 Allows for easy use in templates as well as assignment
 
 ```gjs
-import { cell } from '@glimmer/tracking';
+import { cell } from '@ember/reactive';
 
 const increment = (c) => c.current++;
 
@@ -408,7 +408,7 @@ const increment = (c) => c.current++;
 Allows partial application, e.g.:
 
 ```gjs
-import { cell } from '@glimmer/tracking';
+import { cell } from '@ember/reactive';
 
 <template>
     {{#let (cell @initialCount) as |count|}}
@@ -427,7 +427,7 @@ Can be useful for changing the initial value once.
 
 
 ```gjs
-import { cell } from '@glimmer/tracking';
+import { cell } from '@ember/reactive';
 
 let num = cell(0);
 
@@ -465,7 +465,7 @@ Prevents further updates to the Cell.
 
 ## Appendix
 
-### Naming
+### Naming: Cell
 
 Naming in the broader context of the JavaScript ecosystem, and why we're using "Cell"[^other-rfcs-pending][^relationships-for-demonstration-only]:
 
@@ -609,3 +609,29 @@ flowchart LR
 > [!IMPORTANT]
 > We have no intention of renaming our our core utilities in ember as that would cause a ton of unneeded churn for no value. This deos not mean that at some point in the future, all the other framework's utilities wouldn't be usable in ember. We want our specific names (Cell, etc), to be unique to ember for both SEO reasons, and for future conflict avoidance reasons (which are currently outside the scope of this RFC)
 
+
+### Naming: current
+
+Other proposed options from comments were: `value`.
+
+However, `current` communicates more meaning than `value` as `current` implies that the value is specifically up to date and cannot be out of date. `value` alone has no implications of history, up-to-date-ness, etc.
+
+Arguments for `value`:
+- Other state containers use `value`
+- `current` has other meanings (electricity)  
+    (so does value, though)
+- supposed vibes with streams and `rx`   
+    (not sure if this is a bad thing?)
+
+
+### Naming: _avoiding_ `get`, favoring `read` 
+
+- `get` implies that you are always going to do something with what is given to you
+- `read` somewhat implies that you want to see the state of cell, but is ambigous about if you want to do anything with that information
+
+This is useful in the "side-signals" example above, where we "read", but don't use the value.
+
+### Naming: `set`
+
+- `set` implies mutation and potential side-effectful behavior, which is exactly what is happening
+- `write` implies that data is being _written_ somewhere, which may not be true, depending on your point of view. There may also not even be state within the cell (as in the case of the "side-signals" example)

From de0b419e64caa3954ef24bbb748b8e21e8625a7d Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Tue, 5 Aug 2025 14:08:02 -0400
Subject: [PATCH 21/22] Example

---
 text/1071-cell.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index dd453d6b76..4cfa5a949e 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -635,3 +635,32 @@ This is useful in the "side-signals" example above, where we "read", but don't u
 
 - `set` implies mutation and potential side-effectful behavior, which is exactly what is happening
 - `write` implies that data is being _written_ somewhere, which may not be true, depending on your point of view. There may also not even be state within the cell (as in the case of the "side-signals" example)
+
+### Extension
+
+If folks wanted, they could make their own cell with previous or historical values. This could be useful for extremely expensive operations that depend on previous computations. 
+To do this, folks would need to implement their own class:
+```js
+class HistoryCell {
+    #previous;
+    #current = cell();
+
+    get current() {
+        return this.#current.current;
+    }
+    set current(value) {
+        this.#previous = this.#current.current;
+        this.$current.current = value;
+    }
+
+    get previous() {
+        return this.#previous;
+    }
+
+    set(value) {
+        this.current = value; 
+    }
+
+    // ...
+}
+```

From 5d89900f519bf25e53dc4954232fd1f96f9ba2b0 Mon Sep 17 00:00:00 2001
From: NullVoxPopuli <199018+NullVoxPopuli@users.noreply.github.com>
Date: Wed, 6 Aug 2025 13:03:10 -0400
Subject: [PATCH 22/22] Mention formula's in a footnote

---
 text/1071-cell.md | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/text/1071-cell.md b/text/1071-cell.md
index 4cfa5a949e..84579d6062 100644
--- a/text/1071-cell.md
+++ b/text/1071-cell.md
@@ -38,7 +38,7 @@ This RFC introduces a new tracking primitive, which represents a single value, t
 
 ## Motivation
 
-The `Cell` is part of the "spreadsheet analogy" when talking about reactivity -- it represents a single tracked value, and can be created without the use of a class, making it a primate candidate for demos[^demos] and for creating reactive values in function-based APIs, such as _helpers_, _modifiers_, or _resources_. They also provide a benefit in testing as well, since tests tend to want to work with some state, the `Cell` is wholly encapsulated, and can be quickly created with 0 ceremony. 
+The `Cell` is part of the "spreadsheet analogy"[^formula] when talking about reactivity -- it represents a single tracked value, and can be created without the use of a class, making it a primate candidate for demos[^demos] and for creating reactive values in function-based APIs, such as _helpers_, _modifiers_, or _resources_. They also provide a benefit in testing as well, since tests tend to want to work with some state, the `Cell` is wholly encapsulated, and can be quickly created with 0 ceremony. 
 
 This is not too dissimilar to the [Tracked Storage Primitive in RFC#669](https://github.com/emberjs/rfcs/blob/master/text/0669-tracked-storage-primitive.md)[^tracked-storage-future]. The `Cell` provides more ergonomic benefits as it doesn't require 3 imports to use. This RFC intends to replace the unimplemented storage-primitives. 
 
@@ -48,6 +48,8 @@ The `Cell` was prototyped in [Starbeam](https://starbeamjs.com/guides/fundamenta
 
 [^tracked-storage-future]: This may likely be deprecated at some point -- especially since it was never implemented, and `cell` is a better successor to it (in general). The library itself will need to be converted to a v2 addon, and then at some point we can add a message to the top of the README stating that we don't intend to implement it in Ember (but the library will still exist, and builts on top of public APIs, so the library itself does not need to be deprecated). Any actoun around this is outside the scope of this RFC.
 
+[^formula]: a subsequent RFC (depending on this one) would be a better version of today's `createCache` + `getValue` pairing, `Formula`
+
 ## Detailed design
 
 > [!NOTE]