@solidjs/signals 2.0.0-beta.19 → 2.0.0-beta.21

package/dist/prod/affects.js

@@ -1,12 +1,12 @@
-import { forEachDependent, notifyStatus, addPendingSource, setPendingError, settlePendingSource } from "./core/async.js";
+import { addPendingSource, setPendingError, settlePendingSource, forEachDependent, notifyStatus } from "./core/async.js";
 
-import { $REFRESH, STATUS_PENDING } from "./core/constants.js";
+import { STATUS_PENDING, $REFRESH } from "./core/constants.js";
 
 import { NotReadyError } from "./core/error.js";
 
 import "./core/core.js";
 
-import { globalQueue, schedule, GlobalQueue, shiftAffectsMarks } from "./core/scheduler.js";
+import { GlobalQueue, shiftAffectsMarks, globalQueue, schedule } from "./core/scheduler.js";
 
 import "./core/verdict.js";
 
@@ -68,7 +68,7 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
     const t = getAffectsSentinel(e);
     const r = new NotReadyError(t);
     forEachDependent(e, e => {
-        if (e.m !== t && !e.M?.has(t)) {
+        if (!e.m?.has(t)) {
             notifyStatus(e, STATUS_PENDING, r);
         }
     });
@@ -84,7 +84,7 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
     let r = false;
     for (let f = 0; f < t.length; f++) {
         const o = t[f];
-        if (!o.P) continue;
+        if (!o.M) continue;
         const s = getAffectsSentinel(o);
         if (addPendingSource(e, s)) {
             e.i |= STATUS_PENDING;
@@ -92,7 +92,7 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
             r = true;
         }
     }
-    if (r && GlobalQueue._ !== null) GlobalQueue._(e);
+    if (r && GlobalQueue.P !== null) GlobalQueue.P(e);
 }
 
 /**
@@ -101,24 +101,24 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * bumps the refcount and pokes the node's verdict companions so an
  * already-materialized `false` flips reactively.
  */ function markAffects(e) {
-    e.P = (e.P || 0) + 1;
+    e.M = (e.M || 0) + 1;
     shiftAffectsMarks(1);
     // Companions only exist once the verdict layer (isPending/latest) loaded;
     // without them there is no materialized verdict to flip.
-        if (e.P === 1 && GlobalQueue._ !== null) GlobalQueue._(e);
+        if (e.M === 1 && GlobalQueue.P !== null) GlobalQueue.P(e);
 }
 
 /**
  * Registers one `affects()` mark on a node: counts it, records the
  * registration with the current transaction (after initTransition the queue's
- * array aliases the active transition's, mirroring `_optimisticNodes`), and
+ * batch IS the active transition, mirroring `_optimisticNodes`), and
  * propagates STATUS_PENDING downstream on the status rails so everything
  * DERIVED from the marked data reads pending too. Propagation runs on every
  * registration (not just the first): subscribers gained since an earlier
  * overlapping registration get covered, and dedup stops re-descent early.
  */ function registerAffectsMark(e) {
     markAffects(e);
-    globalQueue.N.push(e);
+    globalQueue.N._.push(e);
     propagateAffectsMark(e);
     schedule();
 }
@@ -131,8 +131,8 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * can't open a fresh override window that would itself need settlement.
  */ function releaseAffectsMark(e) {
     shiftAffectsMarks(-1);
-    e.P--;
-    if (!e.P) {
+    e.M--;
+    if (!e.M) {
         const t = e.t;
         if (t) settlePendingSource(e, t, true);
         GlobalQueue.R !== null && GlobalQueue.R(e);
@@ -156,12 +156,12 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * keeps normal suspension semantics. Core's read path reaches this through
  * `GlobalQueue._onlyMarkPending`, gated on the `activeAffectsMarks` counter.
  */ function onlyMarkPending(e) {
-    const t = e.M;
+    const t = e.m;
     if (t) {
         for (const e of t) if (!e.l) return false;
         return true;
     }
-    return !!e.m?.l;
+    return false;
 }
 
 /**
@@ -175,14 +175,10 @@ import { $TARGET, getStoreAffectsNodes } from "./store/store.js";
  * the very status it reports on. Reached through
  * `GlobalQueue._collectMarkSources`, gated on `activeAffectsMarks`.
  */ function collectMarkSources(e, t) {
-    const r = e.m;
-    if (r) {
-        const e = r.l;
-        if (e && e.P) t.push(e);
-    } else if (e.M) {
-        for (const r of e.M) {
+    if (e.m) {
+        for (const r of e.m) {
             const e = r.l;
-            if (e && e.P) t.push(e);
+            if (e && e.M) t.push(e);
         }
     }
 }

package/dist/prod/core/action.js

@@ -4,23 +4,51 @@ import { isThenable } from "./async.js";
 
 import "./core.js";
 
-function restoreTransition(e, n) {
+function restoreTransition(e, r) {
     globalQueue.initTransition(e);
-    const t = n();
+    const t = r();
     flush();
     return t;
 }
 
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed
  * until the action either completes or the next `yield` resolves.
  *
- * Yield promises (or any awaitable) inside the generator — the action waits
- * for each before continuing, but the writes you made beforehand are already
- * visible (or held by `<Loading>` if optimistic). Yield bare values for
- * synchronous batched steps.
+ * `yield` is the transaction-safe suspension point: the action waits for a
+ * yielded promise and re-enters the transaction before running the code after
+ * it. A plain `await` does NOT — the runtime has no hook into an async
+ * generator's internal await continuations, so writes to fresh signals
+ * between an `await` and the next `yield` escape the transaction and commit
+ * immediately. `await` is still the ergonomic choice for typed results; just
+ * put a bare `yield` before any writes that follow it:
+ *
+ * ```ts
+ * const saved = await api.createTodo(text); // typed result
+ * yield; // re-enter the transaction before writing
+ * setTodos(t => { ... });
+ * ```
+ *
+ * (For the same reason, don't call `flush()` inside an action body — it
+ * drains the transaction mid-step.)
  *
  * Each call returns a `Promise` that resolves with the generator's return
  * value, or rejects if it throws. Pair with `createOptimistic` /
@@ -31,10 +59,11 @@ function restoreTransition(e, n) {
  * ```ts
  * const [todos, setTodos] = createOptimisticStore<Todo[]>([]);
  *
- * const addTodo = action(function* (text: string) {
+ * const addTodo = action(async function* (text: string) {
  *   const tempId = crypto.randomUUID();
  *   setTodos(t => { t.push({ id: tempId, text, pending: true }); }); // optimistic
- *   const saved = yield api.createTodo(text); // network round-trip
+ *   const saved = await api.createTodo(text); // network round-trip, typed
+ *   yield; // re-enter the transaction
  *   setTodos(t => {
  *     const i = t.findIndex(x => x.id === tempId);
  *     if (i >= 0) t[i] = saved;
@@ -45,23 +74,23 @@ function restoreTransition(e, n) {
  * await addTodo("buy milk");
  * ```
  */ function action(e) {
-    return (...n) => new Promise((t, r) => {
-        const i = e(...n);
+    return (...r) => new Promise((t, n) => {
+        const i = e(...r);
         globalQueue.initTransition();
         let o = activeTransition;
         o.Te.push(i);
-        const done = (e, n, s = false) => {
+        const done = (e, r, s = false) => {
             o = currentTransition(o);
             const u = o.Te.indexOf(i);
             if (u >= 0) o.Te.splice(u, 1);
             setActiveTransition(o);
             schedule();
-            s ? r(n) : t(e);
+            s ? n(r) : t(e);
         };
-        const step = (e, n) => {
+        const step = (e, r) => {
             let t;
             try {
-                t = n ? i.throw(e) : i.next(e);
+                t = r ? i.throw(e) : i.next(e);
             } catch (e) {
                 return done(undefined, e, true);
             }
@@ -73,7 +102,29 @@ function restoreTransition(e, n) {
         };
         const run = e => {
             if (e.done) return done(e.value);
-            if (isThenable(e.value)) return void e.value.then(e => restoreTransition(o, () => step(e)), e => restoreTransition(o, () => step(e, true)));
+            // Thenable assimilation can itself throw synchronously (a `then`
+            // getter, or a `then()` method that throws — #2918). Match `await`
+            // semantics: the failure is thrown back into the generator at the
+            // yield point (catchable there); if uncaught, step()'s guard settles
+            // the action so its iterator never leaks in the transition. The
+            // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+            // already called a callback is ignored.
+                        let r = false;
+            try {
+                if (isThenable(e.value)) return void e.value.then(e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e));
+                }, e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e, true));
+                });
+            } catch (e) {
+                if (r) return;
+                r = true;
+                return void restoreTransition(o, () => step(e, true));
+            }
             restoreTransition(o, () => step(e.value));
         };
         step();

package/dist/prod/core/async.js

@@ -14,42 +14,28 @@ import { resolveTransition, hasActiveOverride, assignOrMergeLane, resolveLane }
 
 import { cleanup } from "./owner.js";
 
-import { globalQueue, GlobalQueue, clock, schedule, queuePendingNode, flush, insertSubs } from "./scheduler.js";
+import { globalQueue, GlobalQueue, clock, schedule, flush, queuePendingNode, insertSubs } from "./scheduler.js";
 
+// The lazily-created Set is the ONE container for pending sources. Its
+// predecessor — a singular slot promoted to a Set on the second source —
+// created dual state whose migration invariant was easy to break: a third
+// overlapping source landed beside the Set and removePendingSource refused
+// to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(e, n) {
-    if (e.m === n || e.M?.has(n)) return false;
-    // Once the Set exists it is THE container — the singular slot stays empty
-    // from migration until removePendingSource collapses back to one entry.
-    // Landing a third source in the singular slot instead created dual state
-    // that removePendingSource refused to clear, stranding the Set members'
-    // pending forever (#2893).
-        if (e.M) e.M.add(n); else if (!e.m) e.m = n; else {
-        e.M = new Set([ e.m, n ]);
-        e.m = undefined;
-    }
+    if (e.m?.has(n)) return false;
+    (e.m ??= new Set).add(n);
     return true;
 }
 
 function removePendingSource(e, n) {
-    if (e.m) {
-        if (e.m !== n) return false;
-        e.m = undefined;
-        return true;
-    }
-    if (!e.M?.delete(n)) return false;
-    if (e.M.size === 1) {
-        e.m = e.M.values().next().value;
-        e.M = undefined;
-    } else if (e.M.size === 0) {
-        e.M = undefined;
-    }
+    if (!e.m?.delete(n)) return false;
+    if (e.m.size === 0) e.m = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
+    e.m?.clear();
     e.m = undefined;
-    e.M?.clear();
-    e.M = undefined;
 }
 
 function setPendingError(e, n, r) {
@@ -84,21 +70,21 @@ function settlePendingSource(e, n = e,
 // open a fresh transition-scoped override window that nothing reverts.
 r = false) {
     let t = false;
-    const u = new Set;
+    const o = new Set;
     // Companion updates no-op without the verdict layer (null hooks).
-        const o = r ? GlobalQueue.R : GlobalQueue._;
+        const u = r ? GlobalQueue.R : GlobalQueue.P;
     const settle = e => {
-        if (u.has(e) || !removePendingSource(e, n)) return;
-        u.add(e);
+        if (o.has(e) || !removePendingSource(e, n)) return;
+        o.add(e);
         e.Ie = clock;
-        const r = e.m ?? e.M?.values().next().value;
+        const r = e.m?.values().next().value;
         if (r) {
             setPendingError(e, r);
-            o !== null && o(e);
+            u !== null && u(e);
         } else {
             e.i &= ~STATUS_PENDING;
             setPendingError(e);
-            o !== null && o(e);
+            u !== null && u(e);
             if (e.Re) {
                 enqueueSub(e);
                 t = true;
@@ -118,19 +104,19 @@ function isThenable(e) {
 
 function handleAsync(e, n, r) {
     let t = false;
-    let u = false;
+    let o = false;
     if (typeof n === "object" && n !== null) {
         untrack(() => {
             t = n[Symbol.asyncIterator];
-            u = !t && isThenable(n);
+            o = !t && isThenable(n);
         });
     }
-    if (!u && !t) {
+    if (!o && !t) {
         e.Ae = null;
         return n;
     }
     e.Ae = n;
-    let o;
+    let u;
     const handleError = r => {
         if (e.Ae !== n) return;
         globalQueue.initTransition(resolveTransition(e));
@@ -138,21 +124,21 @@ function handleAsync(e, n, r) {
                 notifyStatus(e, r instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, r);
         e.Ie = clock;
     };
-    const asyncWrite = (t, u) => {
+    const asyncWrite = (t, o) => {
         if (e.Ae !== n) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
                 if (e.u & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         globalQueue.initTransition(resolveTransition(e));
-        const o = !!(e.i & STATUS_UNINITIALIZED);
+        const u = !!(e.i & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const l = resolveLane(e);
         if (l) l.Pe.delete(e);
         if (r) {
             r(t);
-            if (o) clearStatus(e, true);
+            if (u) clearStatus(e, true);
         } else if (e.be !== undefined) {
             // Optimistic node — resting OR covered by an active override — holds
             // through the shared pending-node path, exactly like a plain async memo,
@@ -179,9 +165,9 @@ function handleAsync(e, n, r) {
             // Route through lane's effect queue for independent flushing
             const n = e.De;
             const r = e.Ue;
-            const u = e.Ge;
+            const o = e.Ge;
             try {
-                if (!n && o || !u || !u(t, r)) {
+                if (!n && u || !o || !o(t, r)) {
                     e.Ue = t;
                     e.Ie = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
@@ -209,18 +195,18 @@ function handleAsync(e, n, r) {
         settlePendingSource(e);
         schedule();
         flush();
-        u?.();
+        o?.();
     };
-    if (u) {
-        let r = false, t = false, u, l = true;
+    if (o) {
+        let r = false, t = false, o, l = true;
         n.then(e => {
             if (l) {
-                o = e;
+                u = e;
                 r = true;
             } else asyncWrite(e);
         }, e => {
             if (l) {
-                u = e;
+                o = e;
                 t = true;
             } else handleError(e);
         });
@@ -229,8 +215,8 @@ function handleAsync(e, n, r) {
             // Settle through the same status path an async rejection uses, then
             // unwind the in-progress synchronous read so the errored node isn't
             // momentarily read as `undefined`.
-            handleError(u);
-            throw u;
+            handleError(o);
+            throw o;
         } else if (!r) {
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
@@ -239,11 +225,11 @@ function handleAsync(e, n, r) {
     if (t) {
         const r = n[Symbol.asyncIterator]();
         let t = false;
-        let u = false;
+        let o = false;
         let l = true;
         cleanup(() => {
-            if (u) return;
-            u = true;
+            if (o) return;
+            o = true;
             try {
                 const e = r.return?.();
                 if (isThenable(e)) e.then(undefined, () => {});
@@ -255,14 +241,14 @@ function handleAsync(e, n, r) {
                 if (c) {
                     i = r;
                     f = true;
-                    if (r.done) u = true;
+                    if (r.done) o = true;
                 } else if (e.Ae !== n) {
                     return;
                 } else if (!r.done) {
                     t = true;
                     asyncWrite(r.value, iterate);
                 } else {
-                    u = true;
+                    o = true;
                     if (t) {
                         schedule();
                         flush();
@@ -276,20 +262,20 @@ function handleAsync(e, n, r) {
                     s = r;
                     a = true;
                 } else if (e.Ae === n) {
-                    u = true;
+                    o = true;
                     handleError(r);
                 }
             });
             c = false;
             if (a) {
                 // Match the promise branch, but only rethrow during the initial read.
-                u = true;
+                o = true;
                 handleError(s);
                 if (l) throw s;
                 return true;
             }
             if (f && !i.done) {
-                o = i.value;
+                u = i.value;
                 t = true;
                 return iterate();
             }
@@ -303,11 +289,11 @@ function handleAsync(e, n, r) {
             throw new NotReadyError(context);
         }
     }
-    return o;
+    return u;
 }
 
 function clearStatus(e, n = false) {
-    if (e.m || e.M) clearPendingSources(e);
+    if (e.m) clearPendingSources(e);
     if (e.Re) e.Re = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
@@ -317,50 +303,50 @@ function clearStatus(e, n = false) {
     if (e.k) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.ye || e.pe) GlobalQueue._(e);
+        if (e.ye || e.pe) GlobalQueue.P(e);
     if (e.G && GlobalQueue.me !== null) GlobalQueue.me(e);
     if (e.C) e.C();
 }
 
-function notifyStatus(e, n, r, t, u) {
+function notifyStatus(e, n, r, t, o) {
     // Wrap regular errors to track source node
     if (n === STATUS_ERROR && !(r instanceof StatusError) && !(r instanceof NotReadyError)) r = new StatusError(e, r);
-    const o = n === STATUS_PENDING && r instanceof NotReadyError ? r.source : undefined;
+    const u = n === STATUS_PENDING && r instanceof NotReadyError ? r.source : undefined;
     // Mark-sourced propagation must not capture subscribers into the marking
     // action's transaction (#2893): they carry no held value needing a
     // transition-scheduled commit, and stamping `_transition` on them would
     // freeze unrelated writes that share a downstream memo until the action
     // settles. Real async keeps queuing (its commits ride the transition).
-        const l = o?.l !== undefined;
+        const l = u?.l !== undefined;
     // A real error is a settled verdict a mark must not erase (#2893): landing
     // STATUS_PENDING here would clobber `_error` with the sentinel's
     // NotReadyError, and unlike real async there is no arriving value whose
     // recompute would surface the error again. Descent stops too — everything
     // downstream holds the propagated error for the same reason.
         if (l && e.i & STATUS_ERROR) return;
-    const i = o === e;
+    const i = u === e;
     const s = n === STATUS_PENDING && e.be !== undefined && !i;
     const f = s && hasActiveOverride(e);
     if (!t) {
-        if (n === STATUS_PENDING && o) {
-            addPendingSource(e, o);
+        if (n === STATUS_PENDING && u) {
+            addPendingSource(e, u);
             e.i = STATUS_PENDING | e.i & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
-                        setPendingError(e, o, r);
+                        setPendingError(e, u, r);
         } else {
             clearPendingSources(e);
             e.i = n | (n !== STATUS_ERROR ? e.i & STATUS_UNINITIALIZED : 0);
             e.k = r;
         }
-        GlobalQueue._ !== null && GlobalQueue._(e);
+        GlobalQueue.P !== null && GlobalQueue.P(e);
         if (e.G && GlobalQueue.me !== null) GlobalQueue.me(e);
     }
-    if (u && !t) {
-        assignOrMergeLane(e, u);
+    if (o && !t) {
+        assignOrMergeLane(e, o);
     }
     const a = t || f;
-    const c = t || s ? undefined : u;
+    const c = t || s ? undefined : o;
     if (e.C) {
         if (t && n === STATUS_PENDING) {
             return;
@@ -374,7 +360,7 @@ function notifyStatus(e, n, r, t, u) {
     }
     forEachDependent(e, (e, t) => {
         e.Ie = clock;
-        if (n === STATUS_PENDING && o && e.m !== o && !e.M?.has(o) || n !== STATUS_PENDING && (e.k !== r || e.m || e.M)) {
+        if (n === STATUS_PENDING && u && !e.m?.has(u) || n !== STATUS_PENDING && (e.k !== r || e.m)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`

package/dist/prod/core/constants.js

@@ -61,6 +61,20 @@ const NOT_PENDING = {};
 
 const NO_SNAPSHOT = {};
 
+/**
+ * Stand-in stored in `_overrideValue` for an optimistic write of literal
+ * `undefined` (#2898). The slot doubles as the optimistic-node brand
+ * (`undefined` = not optimistic, `NOT_PENDING` = at rest), so the raw value
+ * would erase the node's optimistic identity: the write turns invisible and
+ * follow-up writes route off the optimistic path and commit permanently.
+ * Same shape as NO_SNAPSHOT. Sites that surface the override VALUE unwrap
+ * via `visibleOverrideValue`; slot identity tests stay raw.
+ */ const OVERRIDE_UNDEFINED = {};
+
+/** Unwrap an active override's stored value for surfacing to readers (#2898). */ function unwrapOverride(E) {
+    return E === OVERRIDE_UNDEFINED ? undefined : E;
+}
+
 const STORE_SNAPSHOT_PROPS = "sp";
 
 const SUPPORTS_PROXY = typeof Proxy === "function";
@@ -75,4 +89,4 @@ const defaultContext = {};
  * @internal
  */ const $REFRESH = Symbol("refresh");
 
-export { $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext };
+export { $REFRESH, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_NO_SNAPSHOT, CONFIG_OWNED_WRITE, CONFIG_SYNC, CONFIG_TRANSPARENT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, OVERRIDE_UNDEFINED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_NONE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SNAPSHOT_STALE, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, STORE_SNAPSHOT_PROPS, SUPPORTS_PROXY, defaultContext, unwrapOverride };