@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/prod/core/async.js

@@ -10,7 +10,7 @@ import { enqueueSub } from "./heap.js";
 
 import { cleanup } from "./owner.js";
 
-import { question, MAINLINE_QUESTION, passLane, joinFuture, clock, schedule, flush, liveTx, holdNode, globalQueue, txOf, GlobalQueue, queuePendingNode } from "./scheduler.js";
+import { question, MAINLINE_QUESTION, passLane, joinFuture, clock, schedule, flush, globalQueue, txOf, GlobalQueue, queuePendingNode } 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 —
@@ -42,7 +42,7 @@ function clearPendingSources(e) {
 // (pending sources propagate the origin node, so this covers any depth).
 // Also guards branch-local recovery: another dependency may still need the source.
 function retryReaches(e, t) {
-    for (let n = e._; n; n = n.p) {
+    for (let n = e.p; n; n = n._) {
         const e = n.I;
         if (e === t || e.m?.Se?.has(t)) return true;
     }
@@ -56,32 +56,32 @@ function retryReaches(e, t) {
  * with NO read-visible pending status and no downstream propagation. Commit
  * #0 keeps serving.
  */ function parkLoadingWindow(e, t) {
-    ext(e).Ie = true;
+    ext(e).de = true;
     if (t.source) addPendingSource(e, t.source);
     // A settled error is the node's answer ("the error stays the answer until
     // this retry can actually run") — the park must not replace it: reads
     // throw `_error` while STATUS_ERROR is set, and overwriting it here leaks
     // a pending-class NotReadyError from a read-invisible park (#2989).
-        if (!(e.G & STATUS_ERROR)) setPendingError(e, t.source, t);
+        if (!(e.S & STATUS_ERROR)) setPendingError(e, t.source, t);
 }
 
 function setPendingError(e, t, n) {
     if (!t) {
-        if (e.m !== null) e.m.V = null;
+        if (e.m !== null) e.m.F = null;
         return;
     }
     if (n instanceof NotReadyError && n.source === t) {
-        ext(e).V = n;
+        ext(e).F = n;
         return;
     }
-    const r = e.m?.V;
+    const r = e.m?.F;
     if (!(r instanceof NotReadyError) || r.source !== t) {
-        ext(e).V = new NotReadyError(t);
+        ext(e).F = new NotReadyError(t);
     }
 }
 
 function forEachDependent(e, t) {
-    for (let n = e.t; n !== null; n = n.l) t(n.o, n);
+    for (let n = e.t; n !== null; n = n.o) t(n.l, n);
 }
 
 // Queue a node to re-run on the next flush (used both when a pending source
@@ -95,7 +95,7 @@ function forEachDependent(e, t) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.re && e.u & CONFIG_AUTO_DISPOSE && !e.t && !(e.R & REACTIVE_ZOMBIE) && !(e.G & STATUS_PENDING) && unobserved(e);
+    e.ee && e.i & CONFIG_AUTO_DISPOSE && !e.t && !(e.R & REACTIVE_ZOMBIE) && !(e.S & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -108,7 +108,7 @@ function releaseSettledDependents(e) {
     const visit = e => {
         if (n.has(e)) return;
         n.add(e);
-        if (!e.t && e.u & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        if (!e.t && e.i & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
         forEachDependent(e, visit);
     };
     forEachDependent(e, visit);
@@ -136,7 +136,7 @@ function settleErroredDependents(e, t) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e.m?.V === t) {
+        if (e.m?.F === t) {
             enqueueSub(e);
             n = true;
         }
@@ -171,35 +171,35 @@ function settlePendingSource(e, t = e) {
         // when the source went pending, `propagateStatus`), and a landing
         // equal to the committed value notifies nobody — the source settling
         // is its verdict changing: it runs again.
-        return f.u & CONFIG_VERDICT && enqueueSub(f);
+        return f.i & CONFIG_VERDICT && enqueueSub(f);
         o.add(f);
-        f.Ne = clock;
+        f.Ie = clock;
         const u = f.m?.Se?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
         // otherwise): the settled error stays the answer through the settle —
         // nulling it here would have reads throw `null` until the re-enqueued
         // retry lands, or lose it entirely if that retry parks again (#2989).
-                const i = f.G & STATUS_ERROR;
+                const i = f.S & STATUS_ERROR;
         if (u) {
             if (!i) setPendingError(f, u);
         } else {
-            f.G &= ~STATUS_PENDING;
+            f.S &= ~STATUS_PENDING;
             if (!i) setPendingError(f);
             // L2: a landing resumes the transaction waiting on it (maintainer: "it
             // resumes the sync frame") — a held reader's re-pass over the landed
             // value is that transaction's work, and the flush that carries it
             // parks into it.
-                        if (f.u & CONFIG_HELD) joinFuture(txOf(f));
-            if (f.m?.Ie) {
+                        if (f.i & CONFIG_HELD) joinFuture(txOf(f));
+            if (f.m?.de) {
                 enqueueSub(f);
                 n = true;
             }
-            if (f.m !== null) f.m.Ie = false;
+            if (f.m !== null) f.m.de = false;
             // Fully settled with nobody watching: release candidate (#2934). Checked
             // again at release time — deferred so unobserved() can't unlink subs
             // lists this walk is still iterating.
-                        if (!f.t && f.u & CONFIG_AUTO_DISPOSE) (r ??= []).push(f);
+                        if (!f.t && f.i & CONFIG_AUTO_DISPOSE) (r ??= []).push(f);
         }
         forEachDependent(f, settle);
     };
@@ -216,9 +216,9 @@ function isThenable(e) {
 }
 
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
-    const t = e.m?.Te;
+    const t = e.m?.Ne;
     if (t != null) {
-        e.m.Te = null;
+        e.m.Ne = null;
         t();
     }
 }
@@ -238,9 +238,9 @@ r) {
         });
     }
     if (!f && !o) {
-        if (e.m !== null) e.m.De = null;
+        if (e.m !== null) e.m.Te = null;
         // A sync landing is the first real answer for a loadingValue node.
-                e._e = false;
+                e.De = false;
         return t;
     }
     // Flight replacement relies on recompute's supersede release for iterator
@@ -248,10 +248,10 @@ r) {
     // self-registration — runs during a recompute of `el`, which has already
     // fired _flightTeardown. A future non-recompute registration path must
     // release it here before overwriting _inFlight.
-        ext(e).De = t;
+        ext(e).Te = t;
     // The question this flight answers (A18 provenance, lanes.ts): the action
     // whose slice asked it; mainline is always the current question.
-        e.m.Oe = question || MAINLINE_QUESTION;
+        e.m._e = question || MAINLINE_QUESTION;
     // The run that asked this flight read every input without throwing: an
     // input still in flight was masked for it (an active override, A17), so
     // pending state those inputs propagated onto the node earlier does not
@@ -261,17 +261,17 @@ r) {
         e.m.Se = undefined;
     let u;
     const handleError = n => {
-        if (e.m?.De !== t) return;
+        if (e.m?.Te !== t) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let o = n instanceof NotReadyError;
-        if (o && e._e) {
+        if (o && e.De) {
             // Loading window: the flight died waiting on an unready source. Keep
             // serving commit #0 — same parking as recompute's catch for sync
             // dependency throws. The dead flight is released so the clock-gated
             // error-retry pull (updateIfNecessary) can also re-ask.
-            if (e.m !== null) e.m.De = null;
+            if (e.m !== null) e.m.Te = null;
             parkLoadingWindow(e, n);
-            e.Ne = clock;
+            e.Ie = clock;
             return;
         }
         notifyStatus(e, o ? STATUS_PENDING : STATUS_ERROR, n);
@@ -279,7 +279,7 @@ r) {
         // rejected flight will never settle its self entry, so transfer ownership
         // after notifyStatus has propagated the replacement source.
                 if (o) settlePendingSource(e);
-        e.Ne = clock;
+        e.Ie = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
         // the error twin of settlePendingSource's release (#2934).
@@ -287,12 +287,12 @@ r) {
         r?.(n, o);
     };
     const asyncWrite = (r, o) => {
-        if (e.m?.De !== t) return;
+        if (e.m?.Te !== t) 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.R & REACTIVE_DIRTY) return;
-        const f = !!(e.G & STATUS_UNINITIALIZED);
+        const f = !!(e.S & STATUS_UNINITIALIZED);
         landStatus(e);
         if (n) {
             try {
@@ -305,11 +305,8 @@ r) {
         } else {
             // CARVE 2: the override-covered landing (hold + A18 supersession) and the
             // lane-routed landing (derived override, lane effect queue) went with
-            // the optimistic engine; every landing is the plain setSignal. A first
-            // answer born into a hold still live lands into it (A29, #3800).
-            let t = e.m.Re;
-            e.m.Re = null;
-            if (f && t && (t = liveTx(t))) holdNode(e, t);
+            // the optimistic engine; every landing is the plain setSignal. A node
+            // already held stages its answer into that hold (`setSignal`).
             try {
                 setSignal(e, () => r);
             } catch (t) {
@@ -323,8 +320,8 @@ r) {
         // (`_pendingValue` set inside setSignal) is not — commitPendingNode closes
         // the window when the flush commits it, so no one-frame pulse can leak to
         // observers between the landing and its commit (#2990).
-                if (e.Ae === NOT_PENDING) {
-            e._e = false;
+                if (e.Oe === NOT_PENDING) {
+            e.De = false;
             // The landing published: the dependency tail the flight's pass left
             // linked goes now (A30, #3410). A staged landing has not replaced the
             // committed frame yet; `commitPendingNode` trims it.
@@ -343,7 +340,7 @@ r) {
     // Returns whether the node released, so the iterator branch can stop
     // pulling values instead of pumping an unobserved stream forever (#2935).
         const settleAutodispose = () => {
-        if (e.u & CONFIG_AUTO_DISPOSE && !e.t && !(e.G & STATUS_PENDING)) {
+        if (e.i & CONFIG_AUTO_DISPOSE && !e.t && !(e.S & STATUS_PENDING)) {
             unobserved(e);
             return true;
         }
@@ -377,7 +374,7 @@ r) {
         // Flight-identity cancellation (#3122): the registration above is the
         // owner-death backstop; the teardown slot fires at the _inFlight release
         // sites so supersede stops this stream immediately.
-                ext(e).Te = close;
+                ext(e).Ne = close;
         // Release check before each next pull: an unobserved lazy node must tear
         // down (its close above runs via disposal, closing the iterator) instead
         // of pumping the stream forever with zero subscribers (#2935).
@@ -392,10 +389,10 @@ r) {
             // buffered (seroval's deserialized streams do), so a bare result is
             // assimilated as an already-settled step instead of crashing on `.then`.
                         const S = o.next();
-            const d = isThenable(S) ? S : {
+            const E = isThenable(S) ? S : {
                 then: e => void e(S)
             };
-            d.then(r => {
+            E.then(r => {
                 // The sync stash only serves the INITIAL drain (handleAsync's caller
                 // consumes syncValue / throws NotReady from it). A sync-settled step
                 // after an async gap — seroval buffering values between pulls, a
@@ -407,7 +404,7 @@ r) {
                     n = r;
                     l = true;
                     if (r.done) i = true;
-                } else if (e.m?.De !== t) {
+                } else if (e.m?.Te !== t) {
                     return;
                 } else if (!r.done) {
                     f = true;
@@ -427,7 +424,7 @@ r) {
                 if (c && s) {
                     r = n;
                     a = true;
-                } else if (e.m?.De === t) {
+                } else if (e.m?.Te === t) {
                     i = true;
                     handleError(n);
                     settleAutodispose();
@@ -483,13 +480,13 @@ r) {
         // have put it. Only a flight that actually flattens becomes
         // disposal-bearing.
                 const registerDeferredClose = t => {
-            if (!e.Pe) e.Pe = t; else if (Array.isArray(e.Pe)) e.Pe.push(t); else e.Pe = [ e.Pe, t ];
+            if (!e.Re) e.Re = t; else if (Array.isArray(e.Re)) e.Re.push(t); else e.Re = [ e.Re, t ];
         };
         t.then(r => {
             if (f) {
                 u = r;
                 n = true;
-            } else if (e.m?.De === t && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
+            } else if (e.m?.Te === t && !(e.R & REACTIVE_DISPOSED) && flattenIfIterable(r, registerDeferredClose)) ; else {
                 asyncWrite(r);
                 settleAutodispose();
             }
@@ -514,11 +511,11 @@ r) {
             // work on a loadingValue node is loading-class (invisible to
             // boundaries); the flight itself is already registered in _inFlight and
             // lands through asyncWrite.
-            if (e._e) return e.pe;
+            if (e.De) return e.Ae;
             throw new NotReadyError(context);
         } else if (!flattenIfIterable(u)) {
             // Synchronously-resolved promise: the first real answer landed.
-            e._e = false;
+            e.De = false;
         }
         // A sync-resolved promise holding an AsyncIterable flattened LIVE (we
         // are still inside the synchronous read): full initial-drain semantics
@@ -528,21 +525,21 @@ r) {
     if (i !== null) {
         if (!i) {
             // Loading window: serve commit #0 (see the promise branch above).
-            if (e._e) return e.pe;
+            if (e.De) return e.Ae;
             throw new NotReadyError(context);
         }
         // A sync first yield (or immediate empty completion) is the first real
         // answer; async yields clear inside asyncWrite.
-                e._e = false;
+                e.De = false;
     }
     return u;
 }
 
 function clearStatus(e, t = false) {
     if (e.m?.Se) clearPendingSources(e);
-    if (e.m?.Ie) if (e.m !== null) e.m.Ie = false;
-    e.G = t ? 0 : e.G & STATUS_UNINITIALIZED;
-    if (e.m?.V) setPendingError(e);
+    if (e.m?.de) if (e.m !== null) e.m.de = false;
+    e.S = t ? 0 : e.S & STATUS_UNINITIALIZED;
+    if (e.m?.F) setPendingError(e);
     const n = statusNotifierOf(e);
     if (n) n.call(e);
 }
@@ -575,8 +572,8 @@ function clearStatus(e, t = false) {
     const n = e.m?.Se;
     // (The full clear below drops the set whether or not self was retired first.)
         if (n && (n.delete(e), n.size)) {
-        e.m.Ie = false;
-        if (t) e.G = STATUS_PENDING;
+        e.m.de = false;
+        if (t) e.S = STATUS_PENDING;
         setPendingError(e, n.values().next().value);
     } else clearStatus(e, t);
 }
@@ -589,14 +586,14 @@ function notifyStatus(e, t, n, r) {
         {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.G = STATUS_PENDING | e.G & STATUS_UNINITIALIZED;
+            e.S = STATUS_PENDING | e.S & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so readers park on
             // the distinct pending source.
                         setPendingError(e, o, n);
         } else {
             clearPendingSources(e);
-            e.G = t | (t !== STATUS_ERROR ? e.G & STATUS_UNINITIALIZED : 0);
-            ext(e).V = n;
+            e.S = t | (t !== STATUS_ERROR ? e.S & STATUS_UNINITIALIZED : 0);
+            ext(e).F = n;
         }
     }
     // Lanes: a written guess is an optimistic boundary (A17 — "the optimistic
@@ -605,7 +602,7 @@ function notifyStatus(e, t, n, r) {
     // transition's to wait on — the frame it was asked in holds (A17: "a
     // transition whose optimistic node is still pending on its own fetch is
     // not complete"), through the node itself (`blocked`).
-        if (t === STATUS_PENDING && e.u & CONFIG_GUESS) {
+        if (t === STATUS_PENDING && e.i & CONFIG_GUESS) {
         if (passLane === null) joinFuture(null);
         return;
     }
@@ -626,7 +623,7 @@ function notifyStatus(e, t, n, r) {
  * (store/projection.ts `wakeFamily`), exactly as a memo's would reach its. */ function propagateStatus(e, t, n, r) {
     const o = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
     forEachDependent(e, (r, f) => {
-        r.Ne = clock;
+        r.Ie = clock;
         // A pending mark on a kept-tail link re-derives the subscriber instead of
         // marking it (A30, #3494 review; fuzzer latest-1 #2141; #3519 review).
         // Past `_depsTail` lie the committed frame's deps, kept by A30 because
@@ -646,7 +643,7 @@ function notifyStatus(e, t, n, r) {
         // Inheriting the error would make a probe's reader errored. A boundary's
         // output (CONFIG_REDERIVE, boundaries.ts) the same: content or fallback
         // is its pass's call.
-                if (r.u & (CONFIG_REDERIVE | CONFIG_VERDICT) || t === STATUS_PENDING && f.Ue !== r.Ge) {
+                if (r.i & (CONFIG_REDERIVE | CONFIG_VERDICT) || t === STATUS_PENDING && f.Pe !== r.pe) {
             enqueueSub(r);
             schedule();
             return;
@@ -659,24 +656,24 @@ function notifyStatus(e, t, n, r) {
         // shape: the unmount it stages makes the observer a zombie whose say is
         // moot for this transaction, A15 #3463).
                 if (t === STATUS_PENDING && o && r.m?.Se?.has(o)) {
-            if (passLane === null && (r.u & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.ee) joinFuture(txOf(r));
+            if (passLane === null && (r.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && globalQueue.X) joinFuture(txOf(r));
             return;
         }
-        if (t === STATUS_PENDING && o || t !== STATUS_PENDING && (r.m?.V !== n || r.m?.Se)) {
+        if (t === STATUS_PENDING && o || t !== STATUS_PENDING && (r.m?.F !== n || r.m?.Se)) {
             // The marked subscriber is queued for the commit sweep so its status
             // bookkeeping (loading window, uninitialized clear) runs with the flush
             // — with the lane, when the pass propagating is the lane's work and
             // the dependent's pending is the lane's own flight (`laneStage`).
             {
                 // (No answer: a pending propagation leaves a written guess a guess.)
-                if (passLane !== null) GlobalQueue.M(r, passLane, true, e); else {
+                if (passLane !== null) GlobalQueue.W(r, passLane, true, e); else {
                     queuePendingNode(r);
                     // A15 (#3443): pending propagates onto a held memo without
                     // recomputing it, and the propagation itself enters the memo's
                     // transaction — the flight flows into a memo that transaction
                     // holds, so the write that started it is held with it. A render
                     // effect's membership is its pass's (`notify`), never sticky.
-                                        if (t === STATUS_PENDING && (r.u & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !r.i) joinFuture(txOf(r));
+                                        if (t === STATUS_PENDING && (r.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && !r.u) joinFuture(txOf(r));
                 }
             }
             notifyStatus(r, t, n);

package/dist/prod/core/constants.js

@@ -97,7 +97,7 @@ const CONFIG_SYNC = 1 << 6;
 // CONFIG_HELD_CHILDREN, CONFIG_INPUTS_PUBLISHED and CONFIG_ADOPTED_UNFLUSHED
 // (transaction holds, zombies, until()'s authoritative view) went with the
 // transactions.
-// L2 (step 2): three bits, all maintained by the node's commit.
+// L2 (step 2): four bits, all maintained by the node's commit.
 /** The node has a pass awaiting commit: its live children (and `_disposal`)
  * are that pass's and were never shown — a re-pass tears them down on the
  * spot, while the frame parked on `_x._pendingFirstChild` keeps waiting for
@@ -110,6 +110,11 @@ const CONFIG_SYNC = 1 << 6;
  * parking flush they see the committed value and hold nothing, and are
  * re-derived at the landing. Set at the park seam on every staged node. */ const CONFIG_HELD = 1 << 8;
 
+/** A member of the uncommitted frame a held pass built (ruling A): set at
+ * the park seam on every computed under a staged node (`holdFrame`). Never
+ * shown, it has no screen: its reads are its transaction's, whichever flush
+ * runs it (`bornInto`, #4010). Cleared by its commit. */ const CONFIG_HELD_FRAME = 1 << 20;
+
 /** A15's reveal corollary (#3305): a commit published this flight's inputs
  * beneath it — the node was pending, nothing staged, when it committed — so
  * its committed value is torn against the visible frame. A render effect
@@ -209,4 +214,4 @@ const defaultContext = {};
  * @internal
  */ const $REFRESH = Symbol("refresh");
 
-export { $REFRESH, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };
+export { $REFRESH, CONFIG_AUTHORITATIVE, CONFIG_AUTO_DISPOSE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_FRESH_READ, CONFIG_GUESS, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, CONFIG_HELD_FRAME, CONFIG_INPUTS_PUBLISHED, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_MANUAL_WRITE, CONFIG_NO_SNAPSHOT, CONFIG_OVERRIDE, CONFIG_OWNED_WRITE, CONFIG_PROMOTED, CONFIG_REDERIVE, CONFIG_SLOT_NODE, CONFIG_STAGED, CONFIG_SYNC, CONFIG_TRANSPARENT, CONFIG_VERDICT, EFFECT_RENDER, EFFECT_TRACKED, EFFECT_USER, NOT_PENDING, NO_SNAPSHOT, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_DISPOSED, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_JOINED, REACTIVE_LANE_DIRTY, REACTIVE_LANE_READ, REACTIVE_LAZY, REACTIVE_MANUAL_WRITE, REACTIVE_MISSED_WAKE, REACTIVE_NONE, REACTIVE_PROBED, REACTIVE_PROBE_UNANSWERED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, REACTIVE_SCREEN_READ, REACTIVE_SNAPSHOT_STALE, REACTIVE_STAGED_READ, REACTIVE_ZOMBIE, STATUS_ERROR, STATUS_PENDING, STATUS_UNINITIALIZED, SUPPORTS_PROXY, defaultContext };

package/dist/prod/core/context.js

@@ -30,7 +30,7 @@ import { getOwner } from "./owner.js";
         throw new NoOwnerError;
     }
     // `undefined` alone means unset — a provided `null` is a value (no `??`).
-        let r = t.U[e.id];
+        let r = t.D[e.id];
     if (r === undefined) r = e.defaultValue;
     if (r === undefined) {
         throw new ContextNotFoundError;
@@ -52,8 +52,8 @@ import { getOwner } from "./owner.js";
     }
     // We're creating a new object to avoid child context values being exposed to parent owners. If
     // we don't do this, everything will be a singleton and all hell will break lose.
-        r.U = {
-        ...r.U,
+        r.D = {
+        ...r.D,
         [e.id]: t === undefined ? e.defaultValue : t
     };
 }