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

package/dist/observe/core/verdict.js

@@ -1,6 +1,6 @@
 import { CONFIG_VERDICT, REACTIVE_PROBED, CONFIG_INPUTS_PUBLISHED, CONFIG_HELD, REACTIVE_JOINED, REACTIVE_STAGED_READ, REACTIVE_LANE_READ, CONFIG_CHILDREN_FORBIDDEN, CONFIG_OVERRIDE, STATUS_PENDING, CONFIG_GUESS, NOT_PENDING, STATUS_UNINITIALIZED, EFFECT_RENDER, STATUS_ERROR, REACTIVE_PROBE_UNANSWERED } from "./constants.js";
 
-import { context, setVerdict, verdict, tracking, pullComputed, markLateLinker, spectating, unflushedValue } from "./core.js";
+import { context, tracking, setVerdict, bornInto, verdict, pullComputed, joinPass, markLateLinker, spectating, unflushedValue } from "./core.js";
 
 import "./dev.js";
 
@@ -10,7 +10,7 @@ import { link } from "./graph.js";
 
 import { verdictLane, laneValueOf, display } from "./lanes.js";
 
-import { GlobalQueue, globalQueue, joinFuture, queuePendingNode, staleReader, passLane, setPassLane, flushTransaction, txOf, stagedReaders } from "./scheduler.js";
+import { GlobalQueue, txOf, globalQueue, joinFuture, queuePendingNode, staleReader, passLane, setPassLane, flushTransaction, stagedReaders } from "./scheduler.js";
 
 // Verdicts (plan sec. 28 replay, 2026-10-02; maintainer, 2026-10-01: verdicts are
 // optimistic state the system supplies). `isPending(fn)` asks whether what
@@ -61,11 +61,13 @@ function watchVerdict(e, t = false) {
  * every flush (fuzzer F12). True when the reader is served the committed
  * value — not over a flight committed beneath inputs already on screen (A15
  * reveal corollary, #3305): that value would tear against them, and the
- * reveal observes the flight. */ function observeFlight(e, t) {
-    if (t.u & CONFIG_INPUTS_PUBLISHED) return false;
-    if (globalQueue.ee) {
+ * reveal observes the flight. Nor for a reader born into the flight's
+ * transaction (`bornInto`, #4010): it has no screen — it waits on the flight
+ * with the rest of its frame. */ function observeFlight(e, t) {
+    if (t.i & CONFIG_INPUTS_PUBLISHED || t.i & CONFIG_HELD && bornInto(e, txOf(t))) return false;
+    if (globalQueue.X) {
         joinFuture(null);
-        if (!(t.u & CONFIG_HELD)) queuePendingNode(t);
+        if (!(t.i & CONFIG_HELD)) queuePendingNode(t);
         verdictRead(e, flushTransaction, true);
     }
     return true;
@@ -88,9 +90,9 @@ let probeFound = false;
  * value notifying anyone (a held write's commit; a held landing's): its
  * reader re-derives there. `latest` shows the proposal that lands — a
  * rewrite or a landing reaches its reader through the link it holds — so a
- * re-run would only repeat the frame. */ function verdictRead(e, t, n = probing) {
+ * re-run would only repeat the frame. */ function verdictRead(e, t, n) {
     route(e, t);
-    if (n) staleReader(e, t);
+    if (n) staleReader(e, t); else if (probing && t.an[t.an.length - 1] !== e) t.an.push(e);
 }
 
 /** A verdict read of a node staged or in flight but not held yet: whether it
@@ -154,29 +156,32 @@ let probeFound = false;
  * frame with neither is final. A24: pending iff a value change is in
  * flight — a staging equal to what is displayed changes nothing when it
  * lands: final now (maintainer, 2026-10-02). */ function heldNotFinal(e) {
-    if ((e.G & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
-    return e.Ae !== NOT_PENDING && !latestActive && !e.m.It && !(e.G & STATUS_UNINITIALIZED) && (!e.tn || !e.tn(e.pe, e.Ae));
+    if ((e.S & STATUS_PENDING) !== 0 && !quietPending(e)) return true;
+    return e.Oe !== NOT_PENDING && !latestActive && !e.m.It && !(e.S & STATUS_UNINITIALIZED) && (!e.en || !e.en(e.Ae, e.Oe));
 }
 
 /** `isPending`'s answer for an unheld node whose flight is up (cause ii). */ function pendingVerdict(e, t) {
-    if (t.G & STATUS_UNINITIALIZED) return;
+    if (t.S & STATUS_UNINITIALIZED) return;
     if (probing && !quietPending(t)) probeFound = true;
     if (e !== null && tracking) {
-        if (t.u & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.ee) provisionalVerdict(e, false);
+        if (t.i & CONFIG_HELD) verdictRead(e, txOf(t)); else if (globalQueue.X) provisionalVerdict(e, false);
  // decided above
         }
 }
 
 /** The pass entering a verdict window is a verdict reader (CONFIG_VERDICT):
- * a dependency going pending re-derives it, the verdict having changed. */ function markVerdictReader(e) {
+ * a dependency going pending re-derives it, the verdict having changed. Not
+ * an untracked window: that is a snapshot, like any untracked read (#3946 —
+ * a router's link claim probing inside the computation that creates the
+ * anchor). A throw still reaches the pass through `untrack`. */ function markVerdictReader(e) {
     let t = context;
     if (t?.Ht) t = t.gt;
-    if (t !== null) {
-        t.u |= CONFIG_VERDICT;
+    if (t !== null && tracking) {
+        t.i |= CONFIG_VERDICT;
         t.R |= REACTIVE_PROBED;
         // Observe tier: which windows this pass entered (1 `isPending`, 2
         // `latest`) — the hold census names the affordance (attribution.ts).
-                t.en = (t.en ?? 0) | e;
+                t.Ze = (t.Ze ?? 0) | e;
     }
 }
 
@@ -226,7 +231,7 @@ function isPending(e) {
  * a tracked reader of a rewrite not yet flushed, the late-linker re-run in
  * the flush that carries it. */ function heldLatest(e, t) {
     const n = unflushedValue(e);
-    if (n === NOT_PENDING) return e.Ae;
+    if (n === NOT_PENDING) return e.Oe;
     if (t !== null) markLateLinker(t);
     return n;
 }
@@ -253,10 +258,11 @@ function isPending(e) {
  *   uninitialized one throws NotReady: loading, not pending (A19 exc. 1);
  * - an errored derivation throws for every reader (#2897). */ function verdictValue(e, t) {
     const n = e;
-    const r = t !== null && tracking && !(t.u & CONFIG_CHILDREN_FORBIDDEN);
+    const r = t !== null && !(t.i & CONFIG_CHILDREN_FORBIDDEN);
+    const i = r && tracking;
     if (t !== null && tracking) {
         link(e, t);
-        if (n.re !== undefined) {
+        if (n.ee !== undefined) {
             // A31: the pulled memo's pass is its own, not the probe's — it reads
             // outside the window, and the probe's read below answers for what
             // the pass produced.
@@ -269,77 +275,83 @@ function isPending(e) {
     // final by declaration — the value itself is read as below. The verdict is
     // display-ahead like any: in a transaction's flush (the declaring action's
     // body) the reader is its verdict lane's, not a staging the frame parks.
-        if (probing && GlobalQueue.C !== undefined && GlobalQueue.C(n)) {
+        if (probing && GlobalQueue.N !== undefined && GlobalQueue.N(n)) {
         probeFound = true;
-        if (r && flushTransaction !== null) verdictRead(t, flushTransaction);
+        if (i && flushTransaction !== null) verdictRead(t, flushTransaction);
     }
-    if (e.u & CONFIG_OVERRIDE) {
-        const i = txOf(e);
-        if (r) verdictRead(t, i._parent ?? i);
-        const u = (n.G & STATUS_PENDING) !== 0 && !quietPending(n);
-        if (e.u & CONFIG_GUESS) {
-            if (probing && (u || e.Ae !== NOT_PENDING && (!e.tn || !e.tn(e.m.Z, e.Ae)))) probeFound = true;
-            return e.m.Z;
+    if (e.i & CONFIG_OVERRIDE) {
+        const r = txOf(e);
+        if (i) verdictRead(t, r._parent ?? r);
+        const u = (n.S & STATUS_PENDING) !== 0 && !quietPending(n);
+        if (e.i & CONFIG_GUESS) {
+            if (probing && (u || e.Oe !== NOT_PENDING && (!e.en || !e.en(e.m.B, e.Oe)))) probeFound = true;
+            return e.m.B;
         }
         if (probing && u) probeFound = true;
         return latestActive && !u ? laneValueOf(e) : display(e);
     }
-    const i = (n.G & STATUS_UNINITIALIZED) !== 0;
-    if (e.u & CONFIG_HELD) {
-        if (!i) {
-            const i = txOf(e);
+    const u = (n.S & STATUS_UNINITIALIZED) !== 0;
+    if (e.i & CONFIG_HELD) {
+        if (!u) {
+            const r = txOf(e);
             // A render effect re-run (or mounted) outside the verdict lane's flush
             // while the lane is blocked — its display held on its own derivation
             // in flight — is a stale reader of the lane (#3460, as `laneRead`): the
             // committed value now, re-derived at the reveal. Not inside a probe:
             // `isPending` is answered below either way.
-                        if (r && !probing && t.i === EFFECT_RENDER && passLane === null && i.rt !== null && i.rt.fn && flushTransaction !== i) {
-                staleReader(t, i.rt);
-                return e.pe;
+                        if (i && !probing && t.u === EFFECT_RENDER && passLane === null && r.rt !== null && r.rt.fn && flushTransaction !== r) {
+                staleReader(t, r.rt);
+                return e.Ae;
             }
-            if (r) verdictRead(t, i);
+            if (i) verdictRead(t, r);
             if (probing && heldNotFinal(n)) probeFound = true;
-            if (latestActive && e.Ae !== NOT_PENDING) {
+            if (latestActive && e.Oe !== NOT_PENDING) {
                 // An action body reading another transaction's proposal derives
                 // from it: the two settle as one (A15; posture C, 2026-09-15). An
                 // untracked read elsewhere has no transaction to entangle.
-                if (!r && flushTransaction !== null && !globalQueue.ee) joinFuture(txOf(e));
-                return heldLatest(e, r ? t : null);
+                if (!i && flushTransaction !== null && !globalQueue.X) joinFuture(txOf(e));
+                return heldLatest(e, i ? t : null);
             }
-            return e.pe;
+            return e.Ae;
+        }
+        // Born into the future: its staging is its only value. It has no
+        // committed value, so no verdict: `isPending` reads it as its read does —
+        // the owner joins the hold (held with it, or caught by a boundary that
+        // has not shown content) and answers for the commit, where it is final.
+                if (e.Oe !== NOT_PENDING && !(n.S & STATUS_PENDING)) {
+            if (probing && r) joinPass(t, e);
+            return e.Oe;
         }
-        // Born into the future: its staging is its only value.
-                if (e.Ae !== NOT_PENDING && !(n.G & STATUS_PENDING)) return e.Ae;
-    } else if (e.Ae !== NOT_PENDING) {
-        if (n.G & STATUS_PENDING && !i) pendingVerdict(r ? t : null, n); else if (r && globalQueue.ee) provisionalVerdict(t, !latestActive && !i);
+    } else if (e.Oe !== NOT_PENDING) {
+        if (n.S & STATUS_PENDING && !u) pendingVerdict(i ? t : null, n); else if (i && globalQueue.X) provisionalVerdict(t, !latestActive && !u);
         // Outside a flush, the staging is an unflushed write (A28): the probe
         // answers for the flushed world, and watches the seam of the flush that
         // carries the write — a memo of `isPending(x)` created after the write
         // flips if that flush parks (#3078). (The write's own fan-out ran before
         // the reader existed; nothing else would re-derive it.)
-         else if (r && probing) watchVerdict(t);
+         else if (i && probing) watchVerdict(t);
         if (latestActive) {
             // A28: an unflushed write is not what `latest` serves; a tracked
             // reader derived from the flushed world runs again in the carrying
             // flush.
-            if (globalQueue.ee) return e.Ae;
+            if (globalQueue.X) return e.Oe;
             if (t !== null) markLateLinker(t);
         }
-        return e.pe;
+        return e.Ae;
     }
-    if (n.G & STATUS_PENDING) {
-        if (!i) {
-            pendingVerdict(r ? t : null, n);
-            return e.pe;
+    if (n.S & STATUS_PENDING) {
+        if (!u) {
+            pendingVerdict(i ? t : null, n);
+            return e.Ae;
         }
         // As `read()`: an untracked read of a pending node still re-runs its
         // reader when the node settles (a projection's pull reads its firewall
         // untracked, store/store.ts).
                 if (t !== null && !tracking && !spectating && e !== t) link(e, t);
-        throw n.m?.v;
+        throw n.m?.F;
     }
-    if (n.re !== undefined && n.G & STATUS_ERROR) throw n.m.v;
-    return e.pe;
+    if (n.ee !== undefined && n.S & STATUS_ERROR) throw n.m.F;
+    return e.Ae;
 }
 
 // Installed at module evaluation — present exactly when something imports

package/dist/observe/map.js

@@ -23,23 +23,23 @@ function mapArray(t, e, s) {
     const r = e.length > 1;
     const n = e;
     const o = {
-        H: createOwner(),
+        L: createOwner(),
         wt: 0,
         Mt: t,
         $t: [],
         qt: n,
         zt: [],
-        nn: [],
+        Je: [],
         bt: i,
         Jt: i || s?.keyed === false ? [] : undefined,
         Xt: r && s?.keyed !== false ? [] : undefined,
         Yt: s?.keyed === false,
-        P: s?.fallback
+        H: s?.fallback
     };
     const h = computed(updateKeyedMap.bind(o), s?.name ? {
         name: s.name
     } : undefined);
-    h.u &= ~CONFIG_AUTO_DISPOSE;
+    h.i &= ~CONFIG_AUTO_DISPOSE;
     return accessor(h);
 }
 
@@ -157,7 +157,7 @@ function trySmallMove(t, e, s, i) {
         }
     }
     const a = t.zt;
-    const u = t.nn;
+    const u = t.Je;
     const l = a.slice(0, s);
     const d = u.slice(0, s);
     for (let t = 0; t < n.length; t += 3) {
@@ -177,7 +177,7 @@ function trySmallMove(t, e, s, i) {
         d[t] = u[e];
     }
     t.zt = l;
-    t.nn = d;
+    t.Je = d;
     t.wt = s;
     t.$t = e.slice(0);
     // Dispose unmatched sources LAST (general-path ordering).
@@ -194,11 +194,11 @@ function updateKeyedMap() {
     // the flight's reader (pending tracking + post-settle retry) instead of
     // vanishing. Set per pass: the first pass runs inside `computed()`, before
     // the node exists to the caller.
-    this.H.gt = getOwner();
+    this.L.gt = getOwner();
     const t = this.Mt() || [], e = t.length;
     t[$TRACK];
  // top level tracking (a store array's container node)
-        runWithOwner(this.H, () => {
+        runWithOwner(this.L, () => {
         let s, i, r, n, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
@@ -220,19 +220,19 @@ function updateKeyedMap() {
         // fast path for empty arrays
                 if (e === 0) {
             if (this.wt !== 0) {
-                this.H.dispose(false);
-                this.nn = [];
+                this.L.dispose(false);
+                this.Je = [];
                 this.$t = [];
                 this.zt = [];
                 this.wt = 0;
                 this.Jt && (this.Jt = []);
                 this.Xt && (this.Xt = []);
             }
-            if (this.P && !this.zt[0]) {
+            if (this.H && !this.zt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.nn[0]?.dispose();
-                this.zt[0] = runWithOwner(this.nn[0] = createOwner(), this.P);
+                this.Je[0]?.dispose();
+                this.zt[0] = runWithOwner(this.Je[0] = createOwner(), this.H);
             }
         }
         // fast path for new create
@@ -248,10 +248,10 @@ function updateKeyedMap() {
                 throw t;
             }
             // commit
-                        if (this.nn[0]) this.nn[0].dispose();
+                        if (this.Je[0]) this.Je[0].dispose();
  // previous fallback
                         this.zt = h;
-            this.nn = f;
+            this.Je = f;
             r && (this.Jt = r);
             n && (this.Xt = n);
             this.$t = t.slice(0);
@@ -343,13 +343,13 @@ function updateKeyedMap() {
                 i = l.get(u);
                 if (i !== undefined && i !== -1) {
                     A[i] = this.zt[s];
-                    M[i] = this.nn[s];
+                    M[i] = this.Je[s];
                     r && (r[i] = this.Jt[s]);
                     n && (n[i] = this.Xt[s]);
                     i = d[i];
                     l.set(u, i);
                 } else {
-                    (p ??= []).push(this.nn[s]);
+                    (p ??= []).push(this.Je[s]);
                     if (true && attrHooks !== null) (m ??= []).push(a);
                 }
             }
@@ -370,7 +370,7 @@ function updateKeyedMap() {
             // change propagation), then dispose exited rows
                         for (s = 0; s < h; s++) {
                 A[s] = this.zt[s];
-                M[s] = this.nn[s];
+                M[s] = this.Je[s];
                 r && (r[s] = this.Jt[s]);
                 n && (n[s] = this.Xt[s]);
             }
@@ -380,7 +380,7 @@ function updateKeyedMap() {
             }
             for (i = c + 1; i < e; i++) {
                 A[i] = this.zt[i - y];
-                M[i] = this.nn[i - y];
+                M[i] = this.Je[i - y];
                 if (r) {
                     r[i] = this.Jt[i - y];
                     _(r[i], t[i]);
@@ -391,14 +391,14 @@ function updateKeyedMap() {
                 }
             }
             this.zt = A;
-            this.nn = M;
+            this.Je = M;
             r && (this.Jt = r);
             n && (this.Xt = n);
             this.wt = e;
             // save a copy of the mapped items for the next update
                         this.$t = t.slice(0);
             if (p) for (s = 0; s < p.length; s++) p[s].dispose();
-            if (true && attrHooks !== null && m !== undefined && O !== undefined) attrHooks.listChurn(this.H.gt, m, O, e, this.bt !== undefined);
+            if (true && attrHooks !== null && m !== undefined && O !== undefined) attrHooks.listChurn(this.L.gt, m, O, e, this.bt !== undefined);
         }
     });
     return this.zt;
@@ -421,18 +421,18 @@ function updateKeyedMap() {
  */ function repeat(t, e, s) {
     const i = e;
     const r = {
-        H: createOwner(),
+        L: createOwner(),
         wt: 0,
         ts: 0,
         es: t,
         qt: i,
-        nn: [],
+        Je: [],
         zt: [],
         ss: s?.from,
-        P: s?.fallback
+        H: s?.fallback
     };
     const n = computed(updateRepeat.bind(r));
-    n.u &= ~CONFIG_AUTO_DISPOSE;
+    n.i &= ~CONFIG_AUTO_DISPOSE;
     return accessor(n);
 }
 
@@ -445,24 +445,24 @@ function updateKeyedMap() {
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
     // As in updateKeyedMap: the node is the row callbacks' reader, per pass.
-    this.H.gt = getOwner();
+    this.L.gt = getOwner();
     const t = this.es();
     const e = this.ss?.() || 0;
-    runWithOwner(this.H, () => {
+    runWithOwner(this.L, () => {
         if (t === 0) {
             if (this.wt !== 0) {
-                this.H.dispose(false);
-                this.nn = [];
+                this.L.dispose(false);
+                this.Je = [];
                 this.zt = [];
                 this.wt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
                                 this.ts = 0;
             }
-            if (this.P && !this.zt[0]) {
+            if (this.H && !this.zt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.nn[0]?.dispose();
-                this.zt[0] = runWithOwner(this.nn[0] = createOwner(), this.P);
+                this.Je[0]?.dispose();
+                this.zt[0] = runWithOwner(this.Je[0] = createOwner(), this.H);
             }
             return;
         }
@@ -475,7 +475,7 @@ function updateRepeat() {
         const o = new Array(t);
         const h = new Array(t);
         for (let t = r; t < n; t++) {
-            h[t - e] = this.nn[t - this.ts];
+            h[t - e] = this.Je[t - this.ts];
             o[t - e] = this.zt[t - this.ts];
         }
         try {
@@ -488,9 +488,9 @@ function updateRepeat() {
             throw t;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.wt === 0) this.nn[0]?.dispose(); else for (let t = this.ts; t < i; t++) if (t < e || t >= s) this.nn[t - this.ts].dispose();
+                if (this.wt === 0) this.Je[0]?.dispose(); else for (let t = this.ts; t < i; t++) if (t < e || t >= s) this.Je[t - this.ts].dispose();
         this.zt = o;
-        this.nn = h;
+        this.Je = h;
         this.ts = e;
         this.wt = t;
     });

package/dist/observe/reveal.js

@@ -41,8 +41,8 @@ const slotMinReady = t => isController(t) ? t.ns() : ready(t);
  * (`!gated`), a nested controller leaves its parent's ownership and runs its
  * own order; a boundary leaves when it has shown content (boundaries.ts). */ function setSlotState(t, e, s, r) {
     if (isController(t)) {
-        t.te = s;
-        t.oe = r;
+        t.ne = s;
+        t.re = r;
         t.ls();
         // Released and ready — every slot of its own has shown — it graduates,
         // as a boundary does when it shows content. Released at the frontier
@@ -50,9 +50,9 @@ const slotMinReady = t => isController(t) ? t.ns() : ready(t);
                 if (!s && t.us && t._parent === e) t._parent = null;
         return;
     }
-    if (t.te !== s || t.oe !== r) {
-        t.te = s;
-        t.oe = r;
+    if (t.ne !== s || t.re !== r) {
+        t.ne = s;
+        t.re = r;
         redraw(t);
     }
 }
@@ -64,8 +64,8 @@ class RevealController {
     /** The controller gating this one, until it releases this one. */
     _parent=null;
     /** The state a parent forces on this whole group. */
-    te=false;
-    oe=false;
+    ne=false;
+    re=false;
     us=true;
     ds=true;
     Ss=false;
@@ -76,7 +76,7 @@ class RevealController {
     /** A slot that has left this controller's ownership: a boundary that has
      * shown content, a nested group that is ready. Shown is shown — it counts
      * as ready whatever happens to it later (a re-arm gates nobody else). */    Rs(t) {
-        return (isController(t) ? t._parent : t.B) !== this;
+        return (isController(t) ? t._parent : t.V) !== this;
     }
     /** The slots this controller still owns, in registration order — the
      * ones the order's state is forced on. */    _s(t) {
@@ -106,7 +106,7 @@ class RevealController {
         }
         return t !== "natural";
     }
-    ae(t) {
+    ue(t) {
         if (this.fs.includes(t)) return;
         this.fs.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
@@ -114,17 +114,17 @@ class RevealController {
                 const e = untrack(this.hs) === "sequential" && !!untrack(this.cs);
         if (isController(t)) {
             t._parent = this;
-            t.te = true;
-            t.oe = e;
+            t.ne = true;
+            t.re = e;
             t.ls();
         } else {
-            t.B = this;
-            t.te = true;
-            t.oe = e;
+            t.V = this;
+            t.ne = true;
+            t.re = e;
         }
         untrack(() => this.ls());
     }
-    ue(t) {
+    oe(t) {
         const e = this.fs.indexOf(t);
         if (e >= 0) this.fs.splice(e, 1);
         untrack(() => this.ls());
@@ -138,8 +138,8 @@ class RevealController {
         try {
             const t = untrack(this.hs);
             const e = t === "sequential" && !!untrack(this.cs);
-            if (this.te) {
-                this._s(t => setSlotState(t, this, true, this.oe));
+            if (this.ne) {
+                this._s(t => setSlotState(t, this, true, this.re));
             } else if (t === "natural") {
                 this._s(t => {
                     if (isController(t)) setSlotState(t, this, false, false); else setSlotState(t, this, !ready(t), false);
@@ -179,10 +179,10 @@ class RevealController {
  *   slots behind the frontier render nothing instead of their fallbacks
  */ function createRevealOrder(t, e) {
     const s = createOwner();
-    const r = s.U[REVEAL];
+    const r = s.D[REVEAL];
     const i = new RevealController(e?.order || SEQUENTIAL_ACCESSOR, e?.collapsed || FALSE_ACCESSOR);
-    s.U = {
-        ...s.U,
+    s.D = {
+        ...s.D,
         [REVEAL]: i
     };
     return runWithOwner(s, () => {
@@ -194,8 +194,8 @@ class RevealController {
         });
         if (true) s._name = "reveal order";
         if (r) {
-            r.ae(i);
-            cleanup(() => r.ue(i));
+            r.ue(i);
+            cleanup(() => r.oe(i));
         }
         return e;
     });
@@ -204,9 +204,9 @@ class RevealController {
 // Installed at module evaluation — present exactly when something imports
 // `createRevealOrder`; a Loading boundary without one pays a null check.
 setRevealHooks({
-    ae: (t, e) => t.ae(e),
     ue: (t, e) => t.ue(e),
-    j: t => t.ls()
+    oe: (t, e) => t.oe(e),
+    P: t => t.ls()
 });
 
 export { createRevealOrder };