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

package/dist/prod/from.js

@@ -0,0 +1,248 @@
+import { isThenable, onSupersede } from "./core/async.js";
+
+import { CONFIG_CHILDREN_FORBIDDEN } from "./core/constants.js";
+
+import { cleanup, getOwner } from "./core/owner.js";
+
+// `from` — a push source (callback subscription, Observable, AsyncIterable)
+// as an AsyncIterable a computation can return or `for await` over:
+//   const value = createMemo(() => from(source));
+// A subscription keeps the latest value: values that arrive between pulls
+// coalesce. An AsyncIterable streams through unchanged. Either way the source
+// opens when the result is iterated and closes on return(), on supersede (the
+// owning computation re-runs) and on owner disposal, whichever comes first.
+function toSubscribe(e) {
+    if (typeof e === "function") return e;
+    // TC39 / RxJS interop: `Symbol.observable` (or "@@observable") returns the observable.
+    // Read per call, not at module scope, so the module stays side-effect free.
+        const n = Symbol.observable;
+    const r = (n && e?.[n]) ?? e?.["@@observable"];
+    const t = typeof r === "function" ? r.call(e) : e;
+    if (t && typeof t.subscribe === "function") return (e, n, r) => t.subscribe({
+        next: e,
+        error: n,
+        complete: r
+    });
+    return null;
+}
+
+const DONE = {
+    value: undefined,
+    done: true
+};
+
+/**
+ * Ties an iterator's `finish` to the computation iterating it. Solid reaches
+ * an iterator's return() only when the compute returns the iterable directly.
+ * Inside an async generator the generator's own return() is queued behind its
+ * pending `await`, and owner cleanups wait for the replacing pass to commit,
+ * so close on supersede, with owner disposal as the backstop. No owner (an
+ * async compute iterating it after its first `await`, or plain iteration):
+ * no registration and no diagnostic, so only return() closes it. Scopes that
+ * forbid cleanups rely on supersede and return().
+ */ function bindToOwner(e) {
+    const n = getOwner();
+    if (!n) return;
+    onSupersede(e);
+    if (!(n.l & CONFIG_CHILDREN_FORBIDDEN)) cleanup(e);
+}
+
+/**
+ * An AsyncIterable as a stream bound to the iterating computation: every
+ * value passes through (no coalescing). `finish` calls the inner return()
+ * once and settles pending pulls as done, so a `for await` over it exits as
+ * soon as the computation re-runs — even when the inner iterator is an async
+ * generator whose own return() the language queues behind its pending
+ * `await`.
+ */ function wrapIterable(e) {
+    return {
+        [Symbol.asyncIterator]() {
+            const n = e[Symbol.asyncIterator]();
+            let r = false;
+            const t = new Set;
+            const finish = () => {
+                if (r) return DONE;
+                r = true;
+                for (const e of t) e(DONE);
+                t.clear();
+                try {
+                    const e = n.return?.();
+                    if (isThenable(e)) e.then(undefined, () => {});
+                } catch {}
+                return DONE;
+            };
+            bindToOwner(finish);
+            return {
+                next(...e) {
+                    if (r) return Promise.resolve(DONE);
+                    const o = n.next(...e);
+                    // A bare result (the producer's buffered fast path) passes through.
+                                        if (!isThenable(o)) return o;
+                    return new Promise((e, n) => {
+                        t.add(e);
+                        o.then(n => t.delete(e) && e(n), r => t.delete(e) && n(r));
+                    });
+                },
+                return() {
+                    return Promise.resolve(finish());
+                }
+            };
+        }
+    };
+}
+
+const toCleanup = e => typeof e === "function" ? e : e && typeof e.unsubscribe === "function" ? () => e.unsubscribe() : () => {};
+
+/**
+ * Converts a callback subscription, an Observable or an AsyncIterable into an
+ * AsyncIterable for a Solid computation. A subscription keeps only the latest
+ * value, and a value the source emits during `subscribe` is served without a
+ * loading frame; an AsyncIterable streams every value through.
+ *
+ * The source closes on supersede — the owning computation re-running — and
+ * on owner disposal. Inside an async generator memo that holds for a
+ * `for await` that starts before the first `await`; one that starts after it
+ * has no owner to bind to, so its source closes only when the loop ends.
+ * Prefer returning `from(...)` from its own memo, with awaited inputs read
+ * from upstream memos and transforms done in a downstream memo.
+ *
+ * Iterate the result with `for await` or return it from a computation: its
+ * `next()` returns an already-buffered value as a bare result, not a promise.
+ *
+ * @example
+ * ```ts
+ * const position = createMemo(() =>
+ *   from<Position>((next, error) => {
+ *     const id = navigator.geolocation.watchPosition(next, error);
+ *     return () => navigator.geolocation.clearWatch(id);
+ *   })
+ * );
+ * const ticks = createMemo(() => from(interval$(rate())));
+ * ```
+ */ function from(e) {
+    const n = toSubscribe(e);
+    if (!n) {
+        if (e && typeof e[Symbol.asyncIterator] === "function") return wrapIterable(e);
+        throw new TypeError("from(): expected a subscribe function, an Observable or an AsyncIterable");
+    }
+    return {
+        [Symbol.asyncIterator]() {
+            let e;
+            let r = false;
+            let t = false;
+            let o = false;
+            let u;
+            let f = null;
+            let l = null;
+            let s = false;
+            const close = () => {
+                if (s) return;
+                s = true;
+                t = true;
+                const e = l;
+                l = null;
+                // A throwing unsubscribe must not escape: at supersede this runs
+                // inside flush(), ahead of the replacing pass (the returned-iterator
+                // path swallows it the same way).
+                                try {
+                    e?.();
+                } catch {}
+            };
+            const settle = () => {
+                if (!f) return;
+                const n = f;
+                if (r) {
+                    f = null;
+                    r = false;
+                    n.resolve({
+                        value: e,
+                        done: false
+                    });
+                } else if (o) {
+                    f = null;
+                    o = false;
+                    n.reject(u);
+                } else if (t) {
+                    f = null;
+                    n.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                }
+            };
+            const i = n(n => {
+                if (t) return;
+                e = n;
+                r = true;
+                settle();
+            }, e => {
+                if (t) return;
+                o = true;
+                u = e;
+                t = true;
+                settle();
+                close();
+            }, () => {
+                if (t) return;
+                t = true;
+                settle();
+                close();
+            });
+            l = toCleanup(i);
+            // Completed or errored during subscribe: release what it just returned.
+                        if (s) {
+                const e = l;
+                l = null;
+                try {
+                    e();
+                } catch {}
+            }
+            // Idempotent: return(), supersede and disposal may all reach it.
+                        const finish = () => {
+                close();
+                r = false;
+                if (f) {
+                    const e = f;
+                    f = null;
+                    e.resolve(DONE);
+                }
+                return DONE;
+            };
+            bindToOwner(finish);
+            return {
+                next() {
+                    // A buffered value is returned as a bare result, not a promise: the
+                    // iterator consumer lands it in the same pass, so a source that
+                    // emits during subscribe (BehaviorSubject-style) shows its value
+                    // with no loading frame. `for await` accepts either form.
+                    if (r) {
+                        r = false;
+                        return {
+                            value: e,
+                            done: false
+                        };
+                    }
+                    if (o) {
+                        o = false;
+                        return Promise.reject(u);
+                    }
+                    if (t) return Promise.resolve({
+                        value: undefined,
+                        done: true
+                    });
+                    return new Promise((e, n) => {
+                        f = {
+                            resolve: e,
+                            reject: n
+                        };
+                    });
+                },
+                return() {
+                    return Promise.resolve(finish());
+                }
+            };
+        }
+    };
+}
+
+export { from };

package/dist/prod/index.js

@@ -18,7 +18,7 @@ export { $REFRESH, SUPPORTS_PROXY } from "./core/constants.js";
 
 export { setConsoleFooter } from "./core/dev.js";
 
-export { ROOT_ERROR_HOOK, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
+export { ROOT_ERROR_HOOK, clock, enforceLoadingBoundary, flush, resetErrorHalt } from "./core/scheduler.js";
 
 import "./core/effect.js";
 
@@ -26,7 +26,7 @@ export { configureClientErrors } from "./core/error-hooks.js";
 
 export { storeName } from "./store/edges.js";
 
-export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until } from "./signals.js";
+export { createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until } from "./signals.js";
 
 export { mapArray, repeat } from "./map.js";
 
@@ -36,6 +36,8 @@ export { affects } from "./affects.js";
 
 export { createDeferred } from "./deferred.js";
 
+export { from } from "./from.js";
+
 export { flatten } from "./flatten.js";
 
 export { createErrorBoundary, createLoadingBoundary } from "./boundaries.js";

package/dist/prod/map.js

@@ -21,7 +21,7 @@ function mapArray(t, e, i) {
     const n = e.length > 1;
     const r = e;
     const o = {
-        L: createOwner(),
+        H: createOwner(),
         it: 0,
         st: t,
         ot: [],
@@ -32,7 +32,7 @@ function mapArray(t, e, i) {
         ct: s || i?.keyed === false ? [] : undefined,
         lt: n && i?.keyed !== false ? [] : undefined,
         ut: i?.keyed === false,
-        H: i?.fallback
+        L: i?.fallback
     };
     const f = computed(updateKeyedMap.bind(o), undefined);
     f.l &= ~CONFIG_AUTO_DISPOSE;
@@ -263,11 +263,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.L.Ye = getOwner();
+    this.H.Ye = getOwner();
     const t = this.st() || [], e = t.length;
     t[$TRACK];
  // top level tracking (a store array's container node)
-        runWithOwner(this.L, () => {
+        runWithOwner(this.H, () => {
         let i, s, 
         // The stage slot a mapper writes its row/index signal into: `j` on the
         // create-all path, `j - start` on the general path, whose stage arrays
@@ -293,7 +293,7 @@ function updateKeyedMap() {
         // fast path for empty arrays
                 if (e === 0) {
             if (this.it !== 0) {
-                this.L.dispose(false);
+                this.H.dispose(false);
                 this.tn = [];
                 this.ot = [];
                 this.ht = [];
@@ -301,11 +301,11 @@ function updateKeyedMap() {
                 this.ct && (this.ct = []);
                 this.lt && (this.lt = []);
             }
-            if (this.H && !this.ht.length) {
+            if (this.L && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.tn[0]?.dispose();
-                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.H);
+                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.L);
             }
         }
         // fast path for new create
@@ -502,7 +502,7 @@ function updateKeyedMap() {
  */ function repeat(t, e, i) {
     const s = e;
     const n = {
-        L: createOwner(),
+        H: createOwner(),
         it: 0,
         dt: 0,
         wt: t,
@@ -510,7 +510,7 @@ function updateKeyedMap() {
         tn: [],
         ht: [],
         Ot: i?.from,
-        H: i?.fallback
+        L: i?.fallback
     };
     const r = computed(updateRepeat.bind(n));
     r.l &= ~CONFIG_AUTO_DISPOSE;
@@ -526,24 +526,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.L.Ye = getOwner();
+    this.H.Ye = getOwner();
     const t = this.wt();
     const e = this.Ot?.() || 0;
-    runWithOwner(this.L, () => {
+    runWithOwner(this.H, () => {
         if (t === 0) {
             if (this.it !== 0) {
-                this.L.dispose(false);
+                this.H.dispose(false);
                 this.tn = [];
                 this.ht = [];
                 this.it = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
                                 this.dt = 0;
             }
-            if (this.H && !this.ht.length) {
+            if (this.L && !this.ht.length) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.tn[0]?.dispose();
-                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.H);
+                this.ht[0] = runWithOwner(this.tn[0] = createOwner(), this.L);
             }
             return;
         }

package/dist/prod/reveal.js

@@ -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). */    gt(t) {
-        return (isController(t) ? t._parent : t.V) !== 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. */    Lt(t) {
@@ -106,7 +106,7 @@ class RevealController {
         }
         return t !== "natural";
     }
-    oe(t) {
+    te(t) {
         if (this.At.includes(t)) return;
         this.At.push(t);
         // Gated from the start (collapsed in a collapsed sequential tail); the
@@ -118,13 +118,13 @@ class RevealController {
             t.ee = e;
             t._t();
         } else {
-            t.V = this;
+            t.v = this;
             t.$ = true;
             t.ee = e;
         }
         untrack(() => this._t());
     }
-    te(t) {
+    oe(t) {
         const e = this.At.indexOf(t);
         if (e >= 0) this.At.splice(e, 1);
         untrack(() => this._t());
@@ -194,8 +194,8 @@ class RevealController {
         });
         if (false) ;
         if (r) {
-            r.oe(i);
-            cleanup(() => r.te(i));
+            r.te(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({
-    oe: (t, e) => t.oe(e),
     te: (t, e) => t.te(e),
-    P: t => t._t()
+    oe: (t, e) => t.oe(e),
+    V: t => t._t()
 });
 
 export { createRevealOrder };

package/dist/prod/signals.js

@@ -6,7 +6,7 @@ import { CONFIG_CHILDREN_FORBIDDEN, EFFECT_USER, $REFRESH, CONFIG_AUTO_DISPOSE,
 
 import { computed, signal, runWithOwner, setMemo, setSignal, markRefresh, read, untrack } from "./core/core.js";
 
-import { globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
+import { schedule, globalQueue, flushTransaction, dirtyQueue, GlobalQueue, resolveTx, passTx, staleReader, joinFuture } from "./core/scheduler.js";
 
 import { cleanup, createRoot, getOwner, dispose } from "./core/owner.js";
 
@@ -463,7 +463,7 @@ function createMemo(e, t) {
                 // guessed node's own re-ask is not answered by it (#3895): park
                 // on that flight, or reject with its error.
                                 const e = read(t);
-                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.F;
+                if (t.l & CONFIG_GUESS && t.m & (STATUS_PENDING | STATUS_ERROR)) throw t.T?.U;
                 return e;
             }, t => {
                 n(typeof e === "function" ? t : e);
@@ -657,7 +657,7 @@ function createMemo(e, t) {
         // still holding the optimistic value — reads do not pull (#3411). Fall
         // to the next pass while the heap has work; `run` swapped the queue,
         // so this lands there, and `enqueue` keeps the drain alive.
-        if (dirtyQueue.et >= dirtyQueue.Ge) return globalQueue.enqueue(EFFECT_USER, fire);
+        if (dirtyQueue.et >= dirtyQueue.Fe) return globalQueue.enqueue(EFFECT_USER, fire);
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
         // attach to. Reject it in dev; in production the return is simply
@@ -666,4 +666,46 @@ function createMemo(e, t) {
     });
 }
 
-export { accessor, createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onSettled, refresh, resolve, until };
+/**
+ * Schedules `callback` to run **once**, right after the pending flush
+ * finishes, in the same microtask checkpoint (before the browser paints).
+ * Unlike `onSettled`, it never waits on async work: if that flush is held by
+ * a pending transition, the callback still runs.
+ *
+ * Its main use is keeping a write out of another update's hold. Writes made
+ * in the same synchronous frame are applied together, so when one of them
+ * starts async work (a route change, a fetch), the others are held with it
+ * until it resolves. A write made in `onFlush` happens after that flush, so
+ * it is its own update: it commits on its own unless something it changes
+ * also derives from the held work (a memo or `createEffect` reading both),
+ * in which case it joins that hold as any later write would.
+ *
+ * Call it from event handlers and effect callbacks (including
+ * `createTrackedEffect` and `onSettled` bodies). In an owned scope such as a
+ * component body or a computation it warns in dev: use `onSettled` there.
+ *
+ * - A write in the callback lands after any write made inline in the same
+ *   frame. Don't write the same signal both inside and outside it; use a
+ *   functional setter if the order matters.
+ * - Several `onFlush` callbacks run in call order and batch into one flush.
+ * - `queueMicrotask` is not a substitute: called before the frame's first
+ *   write, it runs before that flush and its write joins it.
+ *
+ * @example
+ * ```tsx
+ * // A menu closes now even when the consumer's onSelect starts async work.
+ * const select = (id: string) => {
+ *   onFlush(() => setOpen(false));
+ *   props.onSelect?.(id);
+ * };
+ * ```
+ *
+ * @param callback Function to run once after the pending flush
+ */ function onFlush(e) {
+    // The frame's flush is queued (or already draining) ahead of this
+    // microtask, so the callback's writes start a flush of their own.
+    schedule();
+    queueMicrotask(e);
+}
+
+export { accessor, createEffect, createMemo, createOptimistic, createReaction, createRenderEffect, createSignal, createTrackedEffect, onCleanup, onFlush, onSettled, refresh, resolve, until };

package/dist/prod/store/affects.js

@@ -72,7 +72,7 @@ function scopeOf(e, o) {
     if (f !== undefined) {
         if (f.pb !== null) o.eo.add(f.v);
         // The writer's view: the tick's own unflushed guesses are in motion too.
-                if (f.fam?.opt === true) r = optHooks.view(f, r, true);
+                if (optHooks && f.fam?.opt === true) r = optHooks.view(f, r, true);
         const e = f.n;
         if (e !== null) for (const o of Reflect.ownKeys(e)) 
         // Another mark's carrier is its own channel: counting it here would

package/dist/prod/store/hooks.js

@@ -1,3 +1,6 @@
+// Set before any family is optimistic (`fam.opt`): a call site checks the
+// hooks first, so a build that does not import optimistic.ts folds the arm
+// away.
 let optHooks = null;
 
 function installOptHooks(o) {

package/dist/prod/store/optimistic.js

@@ -83,7 +83,7 @@ function notifyOptimisticWrites(e, n) {
     // inner store's truth for its key before guessing over it.
         const o = e.ch ? e.v : null;
     const guess = (e, n, i, r) => {
-        if (o !== null) e.Ie = i ? n in t : unwrapValue(t[n]);
+        if (o !== null) e.le = i ? n in t : unwrapValue(t[n]);
         // By value: a function leaf is a value, not an updater (#3017).
                 optimisticWrite(e, () => r);
     };
@@ -274,7 +274,7 @@ function arrangementEqual(e, n, t) {
     if (!t) return fold(e, n);
     const i = e.O;
     if (i === undefined || e.ze !== $TRACK) return;
-    const r = e.T.v;
+    const r = e.T.P;
     if (!(r instanceof LaneView)) return;
     if (!Array.isArray(n) || !Array.isArray(r.rows)) {
         r.base = n;
@@ -318,7 +318,7 @@ function arrangementEqual(e, n, t) {
         // key's new object is the same row, its target adopted it).
                 if (n === undefined) {
             if (!sameRow(d[e], f[e], o)) laneSet(getNode(i, e), f[e], c);
-        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.v : d[e], f[e], o)) laneSet(n, f[e], c);
+        } else if (!sameRow(n.l & CONFIG_OVERRIDE ? n.T.P : d[e], f[e], o)) laneSet(n, f[e], c);
     }
     if (p !== null) {
         for (let e = f.length; ;e++) {
@@ -342,8 +342,8 @@ function arrangementEqual(e, n, t) {
     const i = txOf(e);
     // A guess the screen never showed is void at the correction (D-34); a
     // keyed arrangement guess's view carries its removed-keys set.
-        if (!i.ke || !(t?.l & CONFIG_OVERRIDE) || !t.T.v?.removed) return false;
-    const r = e.T.v;
+        if (!i.ge || !(t?.l & CONFIG_OVERRIDE) || !t.T.P?.removed) return false;
+    const r = e.T.P;
     if ((!e.xe || !e.xe(r, n)) && !GlobalQueue.nn(r, n)) {
         i.folded = foldedRead;
         insertSubs(e);
@@ -365,8 +365,8 @@ function arrangementEqual(e, n, t) {
         const t = txOf(n);
         joinPassAt(e, resolveTx(t._parent ?? t));
     }
-    if (n.se !== NOT_PENDING) return n.se;
-    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.Ie;
+    if (n.ie !== NOT_PENDING) return n.ie;
+    return n.l & CONFIG_SLOT_NODE ? GlobalQueue.fn(n) : n.le;
 }
 
 function sameRow(e, n, t) {
@@ -383,8 +383,8 @@ function sameRow(e, n, t) {
     if (!(e.l & CONFIG_OVERRIDE)) {
         e.l |= CONFIG_OVERRIDE;
         list(e, t);
-    } else if (i.v === n) return;
-    i.v = n;
+    } else if (i.P === n) return;
+    i.P = n;
     if (e.o !== null) {
         insertSubs(e);
         laneDirty(e, t);
@@ -430,7 +430,7 @@ function sweepOverlaid() {
             // The container shows its backing again (a shown arrangement guess
             // that ended without a landing left its `LaneView` as the value).
                         const t = e.k;
-            if (t !== null && t.Ie instanceof LaneView) t.Ie = t.Ie.base;
+            if (t !== null && t.le instanceof LaneView) t.le = t.le.base;
         }
         if (n.size === 0) overlaidFamilies.delete(e);
     }
@@ -447,8 +447,8 @@ function sweepOverlaid() {
     if (i !== null) for (const e of Reflect.ownKeys(i)) {
         const r = i[e];
         const o = untrack(() => unwrapValue(n[e]));
-        if (r.xe && r.xe(r.Ie, o)) continue;
-        r.Ie = o;
+        if (r.xe && r.xe(r.le, o)) continue;
+        r.le = o;
         // (The lane's end notified it this epoch when the shown value and the
         // covered one differed — its readers re-derive already.)
                 if (r.o !== null && r.Me !== notifyEpoch) {
@@ -460,8 +460,8 @@ function sweepOverlaid() {
     if (r !== null) for (const e of Reflect.ownKeys(r)) {
         const i = r[e];
         const o = untrack(() => e in n);
-        if (i.Ie === o) continue;
-        i.Ie = o;
+        if (i.le === o) continue;
+        i.le = o;
         if (i.o !== null && i.Me !== notifyEpoch) {
             insertSubs(i);
             t = true;
@@ -470,9 +470,9 @@ function sweepOverlaid() {
     // The arrangement the readers saw (the shown guess) against the inner's
     // now: a structural reader re-derives when they differ.
         const o = e.k;
-    if (o !== null && o.o !== null && o.Ie instanceof LaneView && o.Me !== notifyEpoch) {
+    if (o !== null && o.o !== null && o.le instanceof LaneView && o.Me !== notifyEpoch) {
         const i = Array.isArray(n) ? untrack(() => n.map(unwrapValue)) : n;
-        if (!arrangementEqual(o.Ie.rows, i, e.fam?.key ?? null)) {
+        if (!arrangementEqual(o.le.rows, i, e.fam?.key ?? null)) {
             insertSubs(o);
             t = true;
         }