@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
 import { notifyStatus, releaseFlightTeardown, handleAsync, clearStatus, parkLoadingWindow, stageError, settlePendingSource, releaseIfSettledUnobserved, settleErroredDependents } from "./async.js";
 
-import { STATUS_UNINITIALIZED, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, CONFIG_HELD, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_DIRTY, CONFIG_OVERRIDE, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_SNAPSHOT_STALE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_VERDICT, STATUS_PENDING, REACTIVE_LANE_DIRTY, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_LAGS, EFFECT_RENDER, CONFIG_HELD_FRAME, EFFECT_TRACKED, CONFIG_STAGED, CONFIG_STAGED_ERROR, REACTIVE_ZOMBIE, REACTIVE_MISSED_WAKE, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_PROBED, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_SCREEN_READ, REACTIVE_PROBE_UNANSWERED, CAUGHT_REARMED, CONFIG_PROMOTED, CONFIG_INPUTS_PUBLISHED, CONFIG_FRESH_READ, REACTIVE_IN_HEAP_HEIGHT, CONFIG_SLOT_NODE, EFFECT_USER, STATUS_NONE } from "./constants.js";
+import { STATUS_UNINITIALIZED, REACTIVE_LAZY, REACTIVE_NONE, defaultContext, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_AUTO_DISPOSE, CONFIG_SYNC, CONFIG_NO_SNAPSHOT, CONFIG_IN_SNAPSHOT_SCOPE, NOT_PENDING, CONFIG_HELD, REACTIVE_MANUAL_WRITE, STATUS_ERROR, REACTIVE_DIRTY, CONFIG_OVERRIDE, NO_SNAPSHOT, CONFIG_HAS_SNAPSHOT, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_IN_HEAP, REACTIVE_REASK, REACTIVE_SNAPSHOT_STALE, CONFIG_CHILDREN_FORBIDDEN, CONFIG_VERDICT, STATUS_PENDING, REACTIVE_LANE_DIRTY, CONFIG_GUESS, REACTIVE_RECOMPUTING_DEPS, CONFIG_LAGS, EFFECT_RENDER, CONFIG_HELD_FRAME, EFFECT_TRACKED, CONFIG_STAGED, CONFIG_STAGED_ERROR, REACTIVE_ZOMBIE, REACTIVE_MISSED_WAKE, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_PROBED, REACTIVE_FRAME_READ, REACTIVE_LANE_READ, REACTIVE_SCREEN_READ, REACTIVE_PROBE_UNANSWERED, CAUGHT_REARMED, CONFIG_PROMOTED, CONFIG_INPUTS_PUBLISHED, CONFIG_FRESH_READ, REACTIVE_IN_HEAP_HEIGHT, CONFIG_SLOT_NODE, EFFECT_USER, NewSet, STATUS_NONE } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -24,7 +24,7 @@ GlobalQueue._e = e => {
     if (e.i === EFFECT_TRACKED) {
         deleteFromHeap(e, dirtyQueue);
         e.Ae = true;
-        globalQueue.enqueue(EFFECT_USER, e.M);
+        globalQueue.enqueue(EFFECT_USER, e.Z);
     }
     // L2: a zombie's fate is the seam's — its owner's commit disposes it, or
     // the park cancels the pass (the write that dirtied it is held). It runs
@@ -51,7 +51,7 @@ GlobalQueue._e = e => {
  * hole's render effect). */ function laneFrameMember(e) {
     let t = e._parent;
     while (t.R & REACTIVE_ZOMBIE) t = t._parent;
-    return (t.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE || t.i && t.T?.Re?.v;
+    return (t.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE || t.i && t.T?.Re?.P;
 }
 
 GlobalQueue.Ce = disposeChildren;
@@ -78,11 +78,23 @@ function ownerInSnapshotScope(e) {
 
 function setSnapshotCapture(e) {
     snapshotCaptureActive = e;
-    if (e && !snapshotSources) snapshotSources = new Set;
+    if (e && !snapshotSources) snapshotSources = new NewSet;
 }
 
-function markSnapshotScope(e) {
-    e.Oe = true;
+/**
+ * Marks `owner` a snapshot scope: while capture is on, the readers created
+ * under it serve each source's snapshot (the value it had when hydration
+ * began) and replay at `releaseSnapshotScope`.
+ *
+ * With `served` (hydration), `owner` is instead a hydrated computed and
+ * `served` its server answer — what the server rendered every reader of the
+ * node with — landing after the node was created pending (so the creation
+ * arm skipped it). It becomes the node's snapshot when it has none, whether
+ * the node committed the answer or a client write had already taken its
+ * compute over. A claim made later reads the value its markup shows, and
+ * replays the node's own value at its release, as for a written signal.
+ */ function markSnapshotScope(e, t) {
+    if (arguments.length < 2) e.Oe = true; else if (snapshotCaptureActive && e.T?.De === undefined) takeSnapshot(e, t);
 }
 
 function releaseSnapshotScope(e) {
@@ -92,10 +104,10 @@ function releaseSnapshotScope(e) {
 }
 
 function releaseSubtree(e) {
-    let t = e.De;
+    let t = e.pe;
     while (t) {
         if (t.Oe) {
-            t = t.pe;
+            t = t.Ge;
             continue;
         }
         if (t.X) {
@@ -104,12 +116,12 @@ function releaseSubtree(e) {
             if (e.R & REACTIVE_SNAPSHOT_STALE) {
                 e.R &= ~REACTIVE_SNAPSHOT_STALE;
                 e.R |= REACTIVE_DIRTY;
-                if (dirtyQueue.Ge > e.Fe) dirtyQueue.Ge = e.Fe;
+                if (dirtyQueue.Fe > e.he) dirtyQueue.Fe = e.he;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.pe;
+        t = t.Ge;
     }
 }
 
@@ -121,7 +133,7 @@ function clearSnapshots() {
             // `!== undefined` — assign, don't `delete`: deleting a field pushes the
             // object to dictionary mode for every later read of every field.
             const t = e.T;
-            if (t != null) t.Pe = undefined;
+            if (t != null) t.De = undefined;
         }
         snapshotSources = null;
     }
@@ -156,14 +168,14 @@ function recompute(e, t = false) {
     // content creates is that mount's too (#4166). Lanes only, like the seat.
         const s = laneRoot;
     const i = laneStageHook && (laneRoot = t && (E || s));
-    setPassLane(!laneStageHook ? null : (e.R & REACTIVE_LANE_DIRTY || (e.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) && e.T?.Re?.v ? e.T.Re : // Loose `!=`: false with no creator lane (undefined == null).
-    t && E?._parent.he != E && creatorPass(context)?.R & REACTIVE_RECOMPUTING_DEPS ? E : null);
+    setPassLane(!laneStageHook ? null : (e.R & REACTIVE_LANE_DIRTY || (e.l & (CONFIG_OVERRIDE | CONFIG_GUESS)) === CONFIG_OVERRIDE) && e.T?.Re?.P ? e.T.Re : // Loose `!=`: false with no creator lane (undefined == null).
+    t && E?._parent.Pe != E && creatorPass(context)?.R & REACTIVE_RECOMPUTING_DEPS ? E : null);
     // CARVE 2: lane posture resolution (OPTIMISTIC_DIRTY, derived-override
     // re-derivation, lane adoption through deps) went with the optimistic engine.
         if (!t) {
         deleteFromHeap(e, dirtyQueue);
         if (e.T !== null) {
-            e.T.Se = null;
+            e.T.Ee = null;
             // Supersede is where an iterator flight dies (#3122): close it now.
             // Idempotent with the cleanup-channel close.
                         releaseFlightTeardown(e);
@@ -179,6 +191,8 @@ function recompute(e, t = false) {
         // A29, or mounted by a pass of it still awaiting its commit, #4010) keeps
         // staging: live writes keep it current, it effects at the swap (ruling
         // A).
+        // A boundary's structure (CONFIG_FRAME) is the frame like a render
+        // effect: it publishes mainline outside its transaction's flush (#4283).
         // A pending flight is the transition's own work (#3884). A probe on an
         // earlier pass left CONFIG_VERDICT, and a frame read here would serve the
         // committed screen, settle the flight and drop the hold — a superseding
@@ -192,15 +206,19 @@ function recompute(e, t = false) {
             // world (`read`), and has left it otherwise.
             // An answered deferred node's re-pass is a lagging question (D-40):
             // it joins nothing, so the write that reached it commits mainline.
-                        if (t.v || e.l & CONFIG_LAGS) ; else if (n !== EFFECT_RENDER && !(e.l & CONFIG_VERDICT)) joinPassTx(t, freshHook?.(e, e.m & STATUS_UNINITIALIZED)); else if (t !== flushTransaction && !(e.m & STATUS_UNINITIALIZED || e.l & CONFIG_HELD_FRAME)) {
+            // `EFFECT_RENDER << 23` is CONFIG_FRAME (a render effect, a boundary's
+            // tree and output), spelled from the effect type as at creation.
+                        if (t.P || e.l & CONFIG_LAGS) ; else if (!(e.l & (CONFIG_VERDICT | EFFECT_RENDER << 23))) joinPassTx(t, freshHook?.(e, e.m & STATUS_UNINITIALIZED)); else if (t !== flushTransaction && !(e.m & STATUS_UNINITIALIZED || e.l & CONFIG_HELD_FRAME)) {
                 // Published mainline, it is not held: the frame this pass builds is
                 // replaced on the spot (#3404) — this flush's commit retires the
                 // committed frame the held pass had parked (`commitPendingNode`),
                 // after the new frame's first runs, and the held pass's own
                 // children die below (`disposeChildren`). The landing re-derives a
                 // fresh held frame for the reveal (`_reruns`).
-                e.se = NOT_PENDING;
-                if (n === EFFECT_RENDER) e.l &= ~CONFIG_HELD;
+                // Not held any more, whichever frame reader it is: its readers read
+                // the value this pass publishes.
+                e.ie = NOT_PENDING;
+                e.l &= ~CONFIG_HELD;
             }
         }
         // The previous pass's frame. If that pass is still awaiting its commit
@@ -217,11 +235,11 @@ function recompute(e, t = false) {
             deferReleases(o = []);
             disposeChildren(e);
             deferReleases(t);
-        } else if (e.De !== null || e.He !== null) parkChildren(e);
+        } else if (e.pe !== null || e.He !== null) parkChildren(e);
         // An error a pass staged (D-41) is replaced by this pass's answer: a
         // value, a flight, or an error of its own (#4109, #4145).
                 if (e.l & CONFIG_STAGED_ERROR) {
-            e.se = NOT_PENDING;
+            e.ie = NOT_PENDING;
             e.l ^= CONFIG_STAGED_ERROR;
         }
     }
@@ -229,16 +247,16 @@ function recompute(e, t = false) {
     // Capture both error and pending status before the compute clears them.
     // A conditional can drop its pending source and recover to an unchanged
     // value, leaving blocked dependents outside that source’s settle walk.
-        const r = e.m & STATUS_ERROR ? e.T?.F : undefined;
+        const r = e.m & STATUS_ERROR ? e.T?.U : undefined;
     const u = (e.m & STATUS_PENDING) !== 0;
-    const _ = u ? e.T?.fe : undefined;
+    const a = u ? e.T?.fe : undefined;
     // Pending SOURCE-hood, captured before the compute clears status: a node
     // whose own flight parked dependents self-registers in _pendingSources
     // (notifyStatus, isSource). If this recompute supersedes that flight and
     // settles synchronously, those dependents settle HERE — asyncWrite's
     // settlePendingSource walk never runs for a landing that was preempted
     // (#3181).
-        const a = e.T?.fe?.has(e);
+        const _ = e.T?.fe?.has(e);
     // D-41: this pass's error is staged, not published (`stageError`).
         let I = false;
     // A19 exc. 2: a `refresh()` re-asks the question already answered — quiet
@@ -254,11 +272,11 @@ function recompute(e, t = false) {
     // live writes until the commit that disposes it, so every per-pass wipe
     // — here, the finally below, updateIfNecessary — carries it (#3543).
         e.R = REACTIVE_RECOMPUTING_DEPS | e.R & (REACTIVE_ZOMBIE | REACTIVE_REASK);
-    e.ie = clock;
+    e.Se = clock;
     // The pass's previous value: its staging, else a lane node's lane value
     // when it has one (lanes.ts), else the committed one.
-        let T = e.se !== NOT_PENDING ? e.se : e.l & CONFIG_OVERRIDE && e.T.v !== NOT_PENDING ? e.T.v : e.Ie;
-    let S = e.Fe;
+        let T = e.ie !== NOT_PENDING ? e.ie : e.l & CONFIG_OVERRIDE && e.T.P !== NOT_PENDING ? e.T.P : e.le;
+    let S = e.he;
     let c = false;
     // L2: did this pass read the future (REACTIVE_JOINED, set by read) — or,
     // a lane's mount, a staging of this flush (#3851, #4166)?
@@ -268,19 +286,19 @@ function recompute(e, t = false) {
     try {
         if (!false && e.l & CONFIG_SYNC) {
             T = e.X(T);
-            if (e.T !== null) e.T.Se = null;
+            if (e.T !== null) e.T.Ee = null;
             e.ce = false;
         } else {
             // A projection's body self-registers its flight through handleAsync
             // (with the commit as setter): its undefined return is not a sync
             // answer, and the outer handleAsync must not clobber the registration.
-            const t = e.T?.Se;
+            const t = e.T?.Ee;
             const n = e.X(T);
             const o = typeof n === "object" && n !== null;
-            const E = e.T?.Se !== t;
+            const E = e.T?.Ee !== t;
             T = E || !o ? n : handleAsync(e, n);
             if (!E && !o) {
-                if (e.T !== null) e.T.Se = null;
+                if (e.T !== null) e.T.Ee = null;
                 // A sync (non-object) return is the first real answer; async-shaped
                 // results clear inside handleAsync at their own landing points, and a
                 // self-registered flight clears when its own handleAsync lands.
@@ -307,11 +325,11 @@ function recompute(e, t = false) {
             // D-41: a pass of a held node, or one that read a staging of this
             // flush, stages its error (`stageError`).
             if (n || !(I = stageError(e, t, true))) {
-                if (n) ext(e).ue = true;
+                if (n) ext(e).se = true;
                 notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t);
                 // The replacement source is fully propagated now. If no new flight
                 // re-owned self, retire the superseded flight and its dependent copies.
-                                if (n && a && !e.T?.Se) settlePendingSource(e);
+                                if (n && _ && !e.T?.Ee) settlePendingSource(e);
             }
             // A re-park drops what the earlier pass carried (#3456): a source this
             // pass no longer reaches — its branch switched, or a fresh flight
@@ -322,7 +340,7 @@ function recompute(e, t = false) {
             // re-park twin of the unchanged-value recovery sweep below; dependents
             // with another path keep the source (retryReaches). A staged error
             // answered what the pass carried: the same.
-                        if ((n || I) && _) for (const t of _) if (t !== e && !e.T?.fe?.has(t)) settlePendingSource(e, t);
+                        if ((n || I) && a) for (const t of a) if (t !== e && !e.T?.fe?.has(t)) settlePendingSource(e, t);
         }
     } finally {
         tracking = R;
@@ -369,7 +387,7 @@ function recompute(e, t = false) {
     // attribution frame opened at the top is still closed.
         if (e.R & REACTIVE_DISPOSED) {
         clearDeps(e);
-        if (e.T !== null) e.T.Se = null;
+        if (e.T !== null) e.T.Ee = null;
         setPassLane(E);
         return;
     }
@@ -381,7 +399,7 @@ function recompute(e, t = false) {
         let C = !laneStageHook ? null : passLane;
     // Listed before its staging, a pending pass included (the lane's own
     // flight is the lane's); false: the pass left the lane (lanes.ts).
-        const d = !!e.T?.F || I;
+        const d = !!e.T?.U || I;
     if (laneStageHook && C !== null) {
         if (laneStageHook(e, C, t, d)) setPassLane(C); else C = null;
     }
@@ -390,9 +408,9 @@ function recompute(e, t = false) {
         // publishes to — the staged `_pendingValue` when staged; a lane node's
         // lane value (a node entering the lane this pass has none yet — its
         // committed value, `laneStage` having voided a frame staging).
-        const o = e.se !== NOT_PENDING ? e.se : e.l & CONFIG_OVERRIDE && e.T.v !== NOT_PENDING ? e.T.v : e.Ie;
+        const o = e.ie !== NOT_PENDING ? e.ie : e.l & CONFIG_OVERRIDE && e.T.P !== NOT_PENDING ? e.T.P : e.le;
         // A throwing comparator is contained inside `isSame` (A3, #2837; #4111).
-                const E = !n && l || !!e.T?.de || !isSame(e, o, T);
+                const E = !n && l || !!e.T?.Ie || !isSame(e, o, T);
         // Effects use `_equals: false` (no per-effect closure). The side effects that
         // the equals closure used to perform — flagging the effect dirty and enqueueing
         // its runner — happen here instead. `!create` matches the previous `initialized`
@@ -401,10 +419,10 @@ function recompute(e, t = false) {
                 if (n && E && 
         // A stale reader of a lane (REACTIVE_SCREEN_READ) that computed what it
         // last applied owes no run (lanes.ts).
-        !(e.R & REACTIVE_SCREEN_READ && !e.Ae && Object.is(e.ge, T)) && 
+        !(e.R & REACTIVE_SCREEN_READ && !e.Ae && Object.is(e.ke, T)) && 
         // A re-staging pass owes no run: the commit replays the effect (#3802).
-        e.se === NOT_PENDING) {
-            e.Ae = !e.T?.F;
+        e.ie === NOT_PENDING) {
+            e.Ae = !e.T?.U;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
             // Lane work's run is the lane's (released at its reveal) — a first
@@ -418,7 +436,8 @@ function recompute(e, t = false) {
         // confirm is a landing too — the lane's end commits it) and notifies
         // only a correction: an equal truth re-runs nothing (lanes.ts). (As the
         // lane's own work the lane judged it — `laneStage`.)
-                if (!t && C === null && e.l & CONFIG_GUESS && laneOutcomeHook(e, T, d)) ; else if (d) ; else if (E) {
+        // (The hook first: a build without lanes folds the arm away.)
+                if (laneOutcomeHook && !t && C === null && e.l & CONFIG_GUESS && laneOutcomeHook(e, T, d)) ; else if (d) ; else if (E) {
             // L2: a first pass is born held — staged, committed with the
             // transaction, its effect's first run the landing's (A29; `effect()`
             // skips the synchronous first run on a staged value) — when the flush
@@ -442,8 +461,8 @@ function recompute(e, t = false) {
                 // effect's value slot is private: the run the lane holds is what
                 // shows it — unless the effect was born held, whose first run is the
                 // commit's (A29): it re-stages, as below.
-                if (n && e.se === NOT_PENDING) e.Ie = T; else if (n || C.ke) e.se = T; else e.T.v = T;
-            } else if (t ? !((flushTransaction !== null || passTx !== null) && (A || creatorPass(f)?.R & REACTIVE_JOINED)) : n && e.se === NOT_PENDING) {
+                if (n && e.ie === NOT_PENDING) e.le = T; else if (n || C.ge) e.ie = T; else e.T.P = T;
+            } else if (t ? !((flushTransaction !== null || passTx !== null) && (A || creatorPass(f)?.R & REACTIVE_JOINED)) : n && e.ie === NOT_PENDING) {
                 // A first pass publishes directly. So does an effect: its value slot
                 // is private (only its own run reads it), and the staging round-trip
                 // (queuePendingNode + commitPendingNodes) paid per effect on the
@@ -454,9 +473,9 @@ function recompute(e, t = false) {
                 // sources commit) must see the fresh value while PLAIN reads stay
                 // committed until flush (#3009 purity). The pending round-trip is
                 // that separation; it cannot be skipped on any path a pull can reach.
-                e.Ie = T;
+                e.le = T;
             } else {
-                e.se = T;
+                e.ie = T;
                 // Born held: in the transaction from birth, so a read of it this
                 // tick is a read of its world (the mount-during-a-hold case), not
                 // only after the seam parks it.
@@ -484,7 +503,7 @@ function recompute(e, t = false) {
                 // Lane work re-staged: the lane's members re-derive as its work.
                                 if (C !== null) laneDirty(e, C);
             }
-        } else if (e.Fe != S) {
+        } else if (e.he != S) {
             for (let t = e.o; t !== null; t = t.t) insertIntoHeapHeight(t.u, dirtyQueue);
         }
         // Silent recovery: errored → unchanged value fires no notification, but
@@ -492,16 +511,16 @@ function recompute(e, t = false) {
         // in an errored run and may sit on stale commits (#2949). Changed-value
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
-                if (!E && !e.T?.F) {
+                if (!E && !e.T?.U) {
             if (r !== undefined) settleErroredDependents(e, r);
             // Self-registration (this node's own superseded flight) is the #3181
             // sweep's business below — retiring it here too would walk twice.
-                        if (_) for (const t of _) if (t !== e) settlePendingSource(e, t);
+                        if (a) for (const t of a) if (t !== e) settlePendingSource(e, t);
         }
         // #3181: a synchronous settle supersedes the old landing callback, so
         // recompute owns its pending-source sweep. An uninitialized node without
         // a replacement source still has no truth to reveal and must stay parked.
-                if (a && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
+                if (_ && !(e.m & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
     }
     // A first pass that went pending where the born-held arm would have held
     // its value (it read a held node, or a verdict lane's mount read a staging,
@@ -513,7 +532,7 @@ function recompute(e, t = false) {
     // re-armed by `on` owns what it collects outright (D-14): not held.
         if (t && C === null && A && e.m & STATUS_PENDING) {
         const t = flushTransaction ?? passTx;
-        if (t && !t.v && freshHook?.(e) !== CAUGHT_REARMED) holdNode(e, t);
+        if (t && !t.P && freshHook?.(e) !== CAUGHT_REARMED) holdNode(e, t);
     }
     // Dependencies are the committed frame's until it is replaced (A30, #3410):
     // a pass that staged its value leaves the previous pass's tail linked for
@@ -532,7 +551,7 @@ function recompute(e, t = false) {
     // kept at a park — one spurious recompute at most). A creation pass and a
     // tracked effect trim now: their frames are replaceable like a direct
     // commit, and a tracked effect's spurious run would be user-visible.
-        if (!e.T?.F && e.se === NOT_PENDING && !(n && e.Ae)) {
+        if (!e.T?.U && e.ie === NOT_PENDING && !(n && e.Ae)) {
         if (t || n === EFFECT_TRACKED) trimStaleDeps(e); else heldTrim(e);
     }
     // A staged value, a parked frame (L2: the commit retires it), or status the
@@ -540,7 +559,7 @@ function recompute(e, t = false) {
     // node for this flush's commit. A first pass queues only when pending or
     // born held: otherwise its value published directly. A queued pass's
     // children are uncommitted (CONFIG_STAGED) until that commit.
-        if (e.se !== NOT_PENDING || e.T !== null && (e.T.Ue !== null || e.T.me !== null) || (e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0 && (!t || (e.m & STATUS_PENDING) !== 0)) {
+        if (e.ie !== NOT_PENDING || e.T !== null && (e.T.Ue !== null || e.T.me !== null) || (e.m & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0 && (!t || (e.m & STATUS_PENDING) !== 0)) {
         e.l |= CONFIG_STAGED;
         // Lane work is the lane's to reveal (its seam), not this flush's commit.
                 if (C === null) queuePendingNode(e);
@@ -576,7 +595,7 @@ function updateIfNecessary(e) {
             }
         }
     }
-    if (e.R & REACTIVE_DIRTY || e.T?.F && e.ie < clock && !e.T?.Se) {
+    if (e.R & REACTIVE_DIRTY || e.T?.U && e.Se < clock && !e.T?.Ee) {
         recompute(e);
     }
     // The guard above refused an already-disposed node; the recompute it just
@@ -606,14 +625,14 @@ function computed(e, t) {
     // plus the slots.
         const E = {
         id: inheritId(t, n, context),
-        l: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.le ? CONFIG_NO_SNAPSHOT : 0) | (t?.Le ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        l: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.ue ? CONFIG_NO_SNAPSHOT : 0) | (t?.Le ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
         xe: t?.equals ?? isEqual,
         He: null,
         A: context?.A ?? defaultContext,
         ye: 0,
         X: e,
-        Ie: o ? t.loadingValue : undefined,
-        Fe: 0,
+        le: o ? t.loadingValue : undefined,
+        he: 0,
         be: undefined,
         We: null,
         C: null,
@@ -622,14 +641,14 @@ function computed(e, t) {
         o: null,
         ve: null,
         _parent: context,
-        pe: null,
+        Ge: null,
         Ze: null,
-        De: null,
+        pe: null,
         R: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         // A loadingValue node is born committed: commit #0 is already in _value.
         m: o ? 0 : STATUS_UNINITIALIZED,
-        ie: clock,
-        se: NOT_PENDING,
+        Se: clock,
+        ie: NOT_PENDING,
         Me: -1,
         ce: o,
         // Cold machinery (async slots) lives one hop away in the lazily-allocated extension — the core literal MUST
@@ -647,23 +666,23 @@ function computed(e, t) {
  * this; hot paths read `el._x?._field` gated by the _config presence bits.
  * Never call ext() just to store a field's default. */ function ext(e) {
     return e.T ??= {
-        Se: null,
+        Ee: null,
         ae: null,
-        F: undefined,
-        ue: undefined,
+        U: undefined,
+        se: undefined,
         fe: undefined,
         we: undefined,
-        Pe: undefined,
+        De: undefined,
         Ue: null,
         me: null,
         Re: null,
         Ve: false,
         je: NOT_PENDING,
         Be: -1,
-        Ee: 0,
-        v: NOT_PENDING,
+        Te: 0,
+        P: NOT_PENDING,
         I: 0,
-        de: undefined
+        Ie: undefined
     };
 }
 
@@ -727,10 +746,16 @@ function computed(e, t) {
     // read the screen. Lane work with no committed value yet reads a flight
     // as a mount's memo does: it enters, and the boundary it mounts catches
     // the pending (#3540).
+    // A boundary's tree and output (CONFIG_FRAME) read as a render effect
+    // does: structure, not a derivation of what it shows (#4283). A mount
+    // under a hold still enters it: the content memo it reads is born held,
+    // with no committed value to serve.
     // (Verdict readers and lanes exist only with their engines installed.)
     const n = observeFlightHook && e.l & CONFIG_VERDICT;
     const o = laneStageHook && passLane !== null;
-    if ((!o || e.m & STATUS_UNINITIALIZED && t.m & STATUS_PENDING) && !n && (e.i !== EFFECT_RENDER || t.l & CONFIG_INPUTS_PUBLISHED)) return false;
+    if ((!o || e.m & STATUS_UNINITIALIZED && t.m & STATUS_PENDING) && !n && (
+    // CONFIG_FRAME, spelled as at the effect's creation.
+    !(e.l & EFFECT_RENDER << 23) || t.l & CONFIG_INPUTS_PUBLISHED)) return false;
     const E = txOf(t);
     // Lane work and verdict readers are never the transaction's pass, whichever
     // flush runs it: a node T holds re-enters T when it re-runs (`recompute`'s
@@ -760,9 +785,9 @@ function computed(e, t) {
     markDisposal(e);
     const t = ext(e);
     t.me = e.He;
-    t.Ue = e.De;
+    t.Ue = e.pe;
     e.He = null;
-    e.De = null;
+    e.pe = null;
     e.ye = 0;
 }
 
@@ -780,14 +805,17 @@ function computed(e, t) {
     // the options to get it.
         const i = {
         id: inheritId(E, s, context),
-        l: (s ? CONFIG_TRANSPARENT : 0) | (E?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (E?.sync ? CONFIG_SYNC : 0) | (E?.Le ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        l: 
+        // CONFIG_FRAME for a render effect (EFFECT_RENDER = 1; a user
+        // effect's 1 << 24 is unused).
+        o << 23 | (s ? CONFIG_TRANSPARENT : 0) | (E?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (E?.sync ? CONFIG_SYNC : 0) | (E?.Le ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
         xe: false,
         He: null,
         A: context?.A ?? defaultContext,
         ye: 0,
         X: e,
-        Ie: undefined,
-        Fe: 0,
+        le: undefined,
+        he: 0,
         be: undefined,
         We: null,
         C: null,
@@ -796,17 +824,17 @@ function computed(e, t) {
         o: null,
         ve: null,
         _parent: context,
-        pe: null,
+        Ge: null,
         Ze: null,
-        De: null,
+        pe: null,
         R: REACTIVE_LAZY,
         m: STATUS_UNINITIALIZED,
-        ie: clock,
-        se: NOT_PENDING,
+        Se: clock,
+        ie: NOT_PENDING,
         Me: -1,
         ce: false,
         Ae: false,
-        ge: undefined,
+        ke: undefined,
         Ke: t,
         qe: n,
         Je: undefined,
@@ -839,7 +867,7 @@ function setEffectStatusNotify(e) {
  * 0, and only effect literals carry the field) get the shared notifier.
  * Presence doubles as the "display consumer" membership test in the status
  * walks, exactly as the per-node field did when every effect carried one. */ function statusNotifierOf(e) {
-    return e.i ? effectStatusNotify ?? undefined : undefined;
+    return e.i ? effectStatusNotify : null;
 }
 
 const lazyOptions = {
@@ -850,15 +878,11 @@ function setupComputedNode(e, t) {
     e.We = e;
     const n = context?.Qe ? context.Ye : context;
     if (context) linkChild(context, e);
-    if (n) e.Fe = n.Fe + 1;
+    if (n) e.he = n.he + 1;
     wireExternalSourceHook?.(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.m & STATUS_PENDING) && !(e.l & CONFIG_NO_SNAPSHOT)) {
-            ext(e).Pe = e.Ie === undefined ? NO_SNAPSHOT : e.Ie;
-            e.l |= CONFIG_HAS_SNAPSHOT;
-            snapshotSources.add(e);
-        }
+        if (!(e.m & STATUS_PENDING) && !(e.l & CONFIG_NO_SNAPSHOT)) takeSnapshot(e, e.le);
     }
 }
 
@@ -869,12 +893,12 @@ function signal(e, t) {
     // and staying null on internal signals — one shape either way).
     const n = {
         xe: t?.equals ?? isEqual,
-        l: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.le ? CONFIG_NO_SNAPSHOT : 0),
-        Ie: e,
+        l: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.ue ? CONFIG_NO_SNAPSHOT : 0),
+        le: e,
         o: null,
         ve: null,
-        ie: clock,
-        se: NOT_PENDING,
+        Se: clock,
+        ie: NOT_PENDING,
         // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
         // materialize one signal per touched leaf, so signal bytes are store
         // bytes. _time is write-only on signals (every read site is computed-
@@ -884,11 +908,7 @@ function signal(e, t) {
         T: null
     };
     if (t?.unobserved) ext(n).we = t.unobserved;
-    if (snapshotCaptureActive && !(n.l & CONFIG_NO_SNAPSHOT)) {
-        ext(n).Pe = e === undefined ? NO_SNAPSHOT : e;
-        n.l |= CONFIG_HAS_SNAPSHOT;
-        snapshotSources.add(n);
-    }
+    if (snapshotCaptureActive && !(n.l & CONFIG_NO_SNAPSHOT)) takeSnapshot(n, e);
     return n;
 }
 
@@ -910,11 +930,11 @@ function isEqual(e, t) {
     const s = {
         xe: t,
         l: CONFIG_OWNED_WRITE | CONFIG_SLOT_NODE,
-        Ie: e,
+        le: e,
         o: null,
         ve: null,
-        ie: clock,
-        se: NOT_PENDING,
+        Se: clock,
+        ie: NOT_PENDING,
         Me: -1,
         T: null,
         O: n,
@@ -1044,7 +1064,7 @@ function setVerdict(e) {
  *   never the graph — A32).
  * False means the reader derives from the staged value.
  */ function readerSeesCommitted(e, t) {
-    return !t || e.se === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN;
+    return !t || e.ie === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN;
 }
 
 /** A28 — set when a node is staged (queuePendingNode) OUTSIDE a flush;
@@ -1065,12 +1085,12 @@ function markUnflushedStaged() {
  * is unflushed. Exempt: promoted writes (A28 (4): a write issued inside a
  * recompute is promoted at that recompute's end — boundary and loading
  * machinery, signals declared for in-computation writes). */ function unflushedValue(e) {
-    if (globalQueue.q || e.se === NOT_PENDING || e.l & CONFIG_PROMOTED) return NOT_PENDING;
+    if (globalQueue.q || e.ie === NOT_PENDING || e.l & CONFIG_PROMOTED) return NOT_PENDING;
     // A held node (L2) carries a staged value between flushes too, but it was
     // flushed — and parked. Not an unflushed write — unless rewritten since:
     // then the flushed staging is what the world sees until the next flush.
         if (e.l & CONFIG_HELD) return e.T.Be === clock ? e.T.je : NOT_PENDING;
-    return e.Ie;
+    return e.le;
 }
 
 /** A28: a held node rewritten outside a flush keeps the staging the last
@@ -1078,7 +1098,7 @@ function markUnflushedStaged() {
  * stash is stamped with the clock, which that flush advances. */ function stashFlushed(e) {
     const t = e.T;
     if (t.Be !== clock) {
-        t.je = e.se;
+        t.je = e.ie;
         t.Be = clock;
         unflushedStaged = true;
     }
@@ -1107,7 +1127,7 @@ function resyncUnflushedCompanions() {
 /** A tracked read's pull of a computed: bring it current when the flush has
  * reached its height (or the reader is a fresh-pull waiter), and sit the
  * reader above it. */ function pullComputed(e, t) {
-    if (e.Fe >= dirtyQueue.Ge) {
+    if (e.he >= dirtyQueue.Fe) {
         markNode(t);
         markHeap(dirtyQueue);
         updateIfNecessary(e);
@@ -1119,9 +1139,9 @@ function resyncUnflushedCompanions() {
     // node no-ops and updateIfNecessary refuses disposed nodes (#2983) —
     // a dead target serves its last value, which is already quiescent.
      else if (t.l & CONFIG_FRESH_READ) updateIfNecessary(e);
-    const n = e.Fe;
+    const n = e.he;
     // parent check is shallow, might need to be recursive
-        if (n >= t.Fe && e._parent !== t) t.Fe = n + 1;
+        if (n >= t.he && e._parent !== t) t.he = n + 1;
 }
 
 function read(e) {
@@ -1137,7 +1157,7 @@ function read(e) {
     // The verdict windows (`latest`, `isPending`; verdict.ts): one cold path,
     // off this one, present only while a window is open.
         if (verdict !== null) return verdict(e, t);
-    if (!n.X && e.T?.Pe === undefined && !snapshotCaptureActive && (!unflushedStaged || e.se === NOT_PENDING) && // A28, see readNodeFast
+    if (!n.X && e.T?.De === undefined && !snapshotCaptureActive && (!unflushedStaged || e.ie === NOT_PENDING) && // A28, see readNodeFast
     !(e.l & CONFIG_OVERRIDE) && // lanes: the slow path's one arm
     true) {
         if (t) {
@@ -1153,18 +1173,18 @@ function read(e) {
             // future (REACTIVE_JOINED): a first pass that did is born held (A29),
             // wherever it was created. Lane work sees the screen (`frameRead`).
                         if (e.l & CONFIG_HELD && !(t.l & CONFIG_CHILDREN_FORBIDDEN)) {
-                if (frameRead(t, e)) return e.Ie;
+                if (frameRead(t, e)) return e.le;
                 joinPass(t, e);
             }
         }
         // Committed visibility for untracked and children-forbidden readers.
-                if (!t || e.se === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.Ie;
+                if (!t || e.ie === NOT_PENDING || t.l & CONFIG_CHILDREN_FORBIDDEN) return e.le;
         // (A plain signal is never uninitialized — the carve-out is `serve`'s.)
         // Lane work over a folded lane (D-34), once the frame has a
         // transaction, reads the screen too.
-                if ((observeFlightHook && t.l & CONFIG_VERDICT || laneStageHook && passLane?.folded) && stagedScreen(t)) return e.Ie;
+                if ((observeFlightHook && t.l & CONFIG_VERDICT || laneStageHook && passLane?.folded) && stagedScreen(t)) return e.le;
         stagedRead(t);
-        return e.se;
+        return e.ie;
     }
     // Rule 3: this read serves the committed value to a render effect outside a
     // parking flush (decided after the pull below — a pull can join).
@@ -1197,6 +1217,19 @@ function read(e) {
         const n = laneReadHook(t, e);
         if (n !== NOT_PENDING) return n;
     }
+    // A reader in a snapshot scope (a hydration claim) is served the value the
+    // server rendered with: a client write's recompute still in flight does
+    // not pull the claim off the markup it adopts — the reader replays at the
+    // scope's release. An errored node throws below as for any reader.
+        if (snapshotCaptureActive && t && t.l & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.T?.De;
+        if (n !== undefined && !(o.m & STATUS_ERROR)) {
+            const o = n === NO_SNAPSHOT ? undefined : n;
+            const E = e.ie !== NOT_PENDING ? e.ie : e.le;
+            if (E !== o) t.R |= REACTIVE_SNAPSHOT_STALE;
+            return o;
+        }
+    }
     // A stale reader of a held flight (rule 3, A15's reveal corollary) is served
     // the committed value — coherent with the frame, whose inputs are the
     // committed ones too — and does not go pending on it. So is lane work
@@ -1229,10 +1262,10 @@ function read(e) {
                 // the node settles — unless nobody is reading (`spectating`, #3528)
                 // or the reader is the node itself.
                 if (!tracking && !spectating && e !== t) link(e, t);
-                throw o.T?.F;
+                throw o.T?.U;
             }
         } else if (o.m & STATUS_UNINITIALIZED) {
-            throw o.T?.F;
+            throw o.T?.U;
         }
     }
     // An errored derive throws for every late reader instead of silently
@@ -1241,24 +1274,15 @@ function read(e) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - owner._time < clock: only on a later cycle than the one the error was found
-        if (tracking && o.ie < clock) {
+        if (tracking && o.Se < clock) {
             recompute(o);
             return read(e);
-        } else throw o.T?.F;
-    }
-    if (snapshotCaptureActive && t && t.l & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.T?.Pe;
-        if (n !== undefined) {
-            const o = n === NO_SNAPSHOT ? undefined : n;
-            const E = e.se !== NOT_PENDING ? e.se : e.Ie;
-            if (E !== o) t.R |= REACTIVE_SNAPSHOT_STALE;
-            return o;
-        }
+        } else throw o.T?.U;
     }
-    if (E) return e.Ie;
+    if (E) return e.le;
     // D-41: an untracked read reads the screen, and a shown error is on it
     // until the answer that replaces it commits.
-        if (!t && e.T?.de) throw e.T.de;
+        if (!t && e.T?.Ie) throw e.T.Ie;
     const s = serve(e, t);
     if (!t && typeof n.X === "function" && e.l & CONFIG_AUTO_DISPOSE && !(o.m & STATUS_PENDING) && !e.o) {
         // Deferred, not inline (#3078): an inline unobserved() here made untracked
@@ -1287,18 +1311,18 @@ function read(e) {
     // an untracked reader has nothing to serve and holds (A19 exception 1) — a
     // bookkeeping read (`spectate`) likewise, and a children-forbidden reader
     // (A32: the frame, which has nothing here).
-    if (e.se !== NOT_PENDING && e.m & STATUS_UNINITIALIZED && (!t || spectating || t.l & CONFIG_CHILDREN_FORBIDDEN)) throw new NotReadyError(null);
+    if (e.ie !== NOT_PENDING && e.m & STATUS_UNINITIALIZED && (!t || spectating || t.l & CONFIG_CHILDREN_FORBIDDEN)) throw new NotReadyError(null);
     const n = t && unflushedStaged ? unflushedValue(e) : NOT_PENDING;
     if (n !== NOT_PENDING) {
         markLateLinker(t);
         return n;
     }
-    if (readerSeesCommitted(e, t)) return e.Ie;
-    if (observeFlightHook && t.l & CONFIG_VERDICT && !(e.m & STATUS_UNINITIALIZED) && stagedScreen(t)) return e.Ie;
+    if (readerSeesCommitted(e, t)) return e.le;
+    if (observeFlightHook && t.l & CONFIG_VERDICT && !(e.m & STATUS_UNINITIALIZED) && stagedScreen(t)) return e.le;
     stagedRead(t, e);
     // D-41: the staged answer is an error (`stageError`).
-        if (e.l & CONFIG_STAGED_ERROR) throw e.se;
-    return e.se;
+        if (e.l & CONFIG_STAGED_ERROR) throw e.ie;
+    return e.ie;
 }
 
 /** A pass read a staging of this flush: it derives from what the flush may
@@ -1352,8 +1376,12 @@ function read(e) {
  * REVEALS — the creation-time arm skips pending computeds for the same
  * reason. Firewall leaves belong to a projection whose compute is the tree's
  * own work, captured (or deliberately not) at creation. */ function captureWriteSnapshot(e, t) {
-    if (e.l & CONFIG_NO_SNAPSHOT || e.X !== undefined || e.T?.Pe !== undefined) return;
-    ext(e).Pe = t === undefined ? NO_SNAPSHOT : t;
+    if (e.l & CONFIG_NO_SNAPSHOT || e.X !== undefined || e.T?.De !== undefined) return;
+    takeSnapshot(e, t);
+}
+
+function takeSnapshot(e, t) {
+    ext(e).De = t === undefined ? NO_SNAPSHOT : t;
     e.l |= CONFIG_HAS_SNAPSHOT;
     snapshotSources.add(e);
 }
@@ -1393,7 +1421,7 @@ function read(e) {
 
 function setSignal(e, t) {
     if (writeHook !== null) writeHook(e);
-    const n = e.se === NOT_PENDING ? e.Ie : e.se;
+    const n = e.ie === NOT_PENDING ? e.le : e.ie;
     if (typeof t === "function") t = t(n);
     // Lanes: a write landing on a guess is its truth (A18 — an async guess's
     // own landing), judged against the guess; one landing on a lane's
@@ -1408,7 +1436,7 @@ function setSignal(e, t) {
     // user comparator must not run against `undefined` (matches recompute).
     // D-41: a write over a shown error is a change whatever the last good
     // value was — the error leaves at its commit (`commitPendingNode`).
-        const o = !!(e.m & STATUS_UNINITIALIZED) || !!e.T?.de || !isSame(e, n, t);
+        const o = !!(e.m & STATUS_UNINITIALIZED) || !!e.T?.Ie || !isSame(e, n, t);
     if (!o) return t;
     // A write during hydration's snapshot capture to a source that has no
     // snapshot — created BEFORE capture began (module-level state: an identity
@@ -1420,16 +1448,16 @@ function setSignal(e, t) {
     // pass reads a value the server never had. Store leaves written here are
     // plain signals and qualify the same way.
         if (snapshotCaptureActive) captureWriteSnapshot(e, n);
-    const E = e.se !== NOT_PENDING;
+    const E = e.ie !== NOT_PENDING;
     if (!E) queuePendingNode(e);
     // A28: a held node rewritten outside a flush keeps its flushed staging
     // for every reader until the flush that carries the rewrite.
      else if (e.l & CONFIG_HELD && !globalQueue.q) stashFlushed(e);
-    e.se = t;
+    e.ie = t;
     if (context !== null) notePromotedWrite(e);
     // _time is a computed-only slot (§12e): writing it on a signal would fork
     // the lean shape. Every read site is computed-typed.
-        if (e.X !== undefined) e.ie = clock;
+        if (e.X !== undefined) e.Se = clock;
     // Staged-rewrite fast path (§12d): a re-write to a node whose subscribers
     // were already walked — and where nothing has recomputed or linked since
     // (epoch) — re-stages the value and stops. The walk is idempotent (subs
@@ -1462,7 +1490,7 @@ function setSignal(e, t) {
     const n = e.l & CONFIG_HELD && !(e.R & REACTIVE_MANUAL_WRITE) && txOf(e) !== flushTransaction;
     // The writer read the committed frame; its updater composes on it.
         if (n && typeof t === "function") {
-        const n = t(e.Ie);
+        const n = t(e.le);
         t = () => n;
     }
     // #4110: the write replaces a failed derivation's outcome. It lands without
@@ -1470,7 +1498,7 @@ function setSignal(e, t) {
     // every later read keeps throwing the error the derivation left behind.
     // The error stays the display until the write commits (D-41).
         if (e.m & STATUS_ERROR) {
-        e.T.de = e.T.F;
+        e.T.Ie = e.T.U;
         notifyStatus(e, STATUS_NONE, undefined);
     }
     t = setSignal(e, t);
@@ -1482,7 +1510,7 @@ function setSignal(e, t) {
         e.R = e.R & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(e, dirtyQueue);
         schedule();
-    } else if (e.se !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
+    } else if (e.ie !== NOT_PENDING) e.R |= REACTIVE_MANUAL_WRITE;
     return t;
 }