@solidjs/signals 0.13.13 → 2.0.0-beta.8

package/dist/dev.js

@@ -240,6 +240,23 @@ let inTrackedQueueCallback = false;
 let _enforceLoadingBoundary = false;
 let _hitUnhandledAsync = false;
 let stashedOptimisticReads = null;
+const transientStoreNodes = new Set();
+function registerTransientStoreNode(node) {
+  transientStoreNodes.add(node);
+}
+function sweepTransientStoreNodes() {
+  if (transientStoreNodes.size === 0) return;
+  for (const node of transientStoreNodes) {
+    if (node._subs !== null) {
+      transientStoreNodes.delete(node);
+      continue;
+    }
+    if (node._pendingValue !== NOT_PENDING) continue;
+    if (node._overrideValue !== undefined && node._overrideValue !== NOT_PENDING) continue;
+    transientStoreNodes.delete(node);
+    node._unobserved?.();
+  }
+}
 function resetUnhandledAsync() {
   _hitUnhandledAsync = false;
 }
@@ -426,7 +443,7 @@ class GlobalQueue extends Queue {
             stashedOptimisticReads = new Set();
             for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
               const node = stashedTransition._optimisticNodes[i];
-              if (node._fn || node._pureWrite) continue;
+              if (node._fn || node._ownedWrite) continue;
               stashedOptimisticReads.add(node);
               queueStashedOptimisticEffects(node);
             }
@@ -589,6 +606,7 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
       optimisticStores.clear();
       schedule();
     }
+    sweepTransientStoreNodes();
     cleanupCompletedLanes(completingTransition);
   }
 }
@@ -790,6 +808,7 @@ function unobserved(el) {
     dep = unlinkSubs(dep);
   }
   el._deps = null;
+  el._depsTail = null;
   disposeChildren(el, true);
 }
 function link(dep, sub) {
@@ -1382,7 +1401,9 @@ function recompute(el, create = false) {
     if (lane) currentOptimisticLane = lane;
   }
   try {
-    value = handleAsync(el, el._fn(value));
+    const prevInFlight = el._inFlight;
+    const fnResult = el._fn(value);
+    value = el._inFlight !== prevInFlight ? fnResult : handleAsync(el, fnResult);
     clearStatus(el, create);
     const resolvedLane = resolveLane(el);
     if (resolvedLane) {
@@ -1481,7 +1502,7 @@ function updateIfNecessary(el) {
   }
   el._flags = el._flags & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
-function computed(fn, initialValue, options) {
+function computed(fn, options) {
   const transparent = options?.transparent ?? false;
   const self = {
     id:
@@ -1489,14 +1510,14 @@ function computed(fn, initialValue, options) {
       (transparent ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
     _transparent: transparent || undefined,
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
+    _ownedWrite: !!options?.ownedWrite,
     _unobserved: options?.unobserved,
     _disposal: null,
     _queue: context?._queue ?? globalQueue,
     _context: context?._context ?? defaultContext,
     _childCount: 0,
     _fn: fn,
-    _value: initialValue,
+    _value: undefined,
     _height: 0,
     _child: null,
     _nextHeap: undefined,
@@ -1538,7 +1559,7 @@ function computed(fn, initialValue, options) {
   if (parent) self._height = parent._height + 1;
   if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   if (externalSourceConfig) {
-    const bridgeSignal = signal(undefined, { equals: false, pureWrite: true });
+    const bridgeSignal = signal(undefined, { equals: false, ownedWrite: true });
     const source = externalSourceConfig.factory(self._fn, () => {
       setSignal(bridgeSignal, undefined);
     });
@@ -1560,7 +1581,7 @@ function computed(fn, initialValue, options) {
 function signal(v, options, firewall = null) {
   const s = {
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
+    _ownedWrite: !!options?.ownedWrite,
     _noSnapshot: !!options?._noSnapshot,
     _unobserved: options?.unobserved,
     _value: v,
@@ -1591,8 +1612,8 @@ function optimisticSignal(v, options) {
   s._overrideValue = NOT_PENDING;
   return s;
 }
-function optimisticComputed(fn, initialValue, options) {
-  const c = computed(fn, initialValue, options);
+function optimisticComputed(fn, options) {
+  const c = computed(fn, options);
   c._overrideValue = NOT_PENDING;
   return c;
 }
@@ -1672,10 +1693,16 @@ function read(el) {
   }
   let c = context;
   if (c?._root) c = c._parentComputed;
-  if (refreshing && el._fn) recompute(el);
-  if (el._flags & REACTIVE_LAZY) {
-    el._flags &= ~REACTIVE_LAZY;
-    recompute(el, true);
+  const computed = el;
+  if (typeof computed._fn === "function") {
+    const comp = el;
+    if (refreshing && !(comp._flags & REACTIVE_DISPOSED)) recompute(comp);
+    if (comp._flags & REACTIVE_LAZY) {
+      comp._flags &= ~REACTIVE_LAZY;
+      recompute(comp, true);
+    } else if (comp._flags & REACTIVE_DISPOSED) {
+      recompute(comp, true);
+    }
   }
   const owner = el._firewall || el;
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
@@ -1695,7 +1722,6 @@ function read(el) {
     throw new Error(message);
   }
   if (c && tracking) {
-    if (el._fn && el._flags & REACTIVE_DISPOSED) recompute(el);
     link(el, c);
     if (owner._fn) {
       const isZombie = el._flags & REACTIVE_ZOMBIE;
@@ -1780,7 +1806,8 @@ function read(el) {
     if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
   }
-  return !c ||
+  const value =
+    !c ||
     (currentOptimisticLane !== null &&
       (el._overrideValue !== undefined ||
         el._optimisticLane ||
@@ -1788,14 +1815,26 @@ function read(el) {
         !!(owner._statusFlags & STATUS_PENDING))) ||
     el._pendingValue === NOT_PENDING ||
     (stale && el._transition && activeTransition !== el._transition)
-    ? el._value
-    : el._pendingValue;
+      ? el._value
+      : el._pendingValue;
+  if (
+    !c &&
+    owner === el &&
+    typeof computed._fn === "function" &&
+    !computed._preventAutoDisposal &&
+    !(owner._statusFlags & STATUS_PENDING) &&
+    !computed._parent &&
+    !el._subs
+  ) {
+    unobserved(el);
+  }
+  return value;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context) {
+  if (!el._ownedWrite && !context?._childrenForbidden && context && el._firewall !== context) {
     const message =
       "Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
-      "Move the write outside or set the `pureWrite` option if this is intentional.";
+      "Move the write outside or set the `ownedWrite` option if this is intentional.";
     emitDiagnostic({
       code: "SIGNAL_WRITE_IN_OWNED_SCOPE",
       kind: "write",
@@ -1879,7 +1918,7 @@ function runWithOwner(owner, fn) {
 }
 function getPendingSignal(el) {
   if (!el._pendingSignal) {
-    el._pendingSignal = optimisticSignal(false, { pureWrite: true });
+    el._pendingSignal = optimisticSignal(false, { ownedWrite: true });
     if (el._parentSource) {
       el._pendingSignal._parentSource = el;
     }
@@ -2022,26 +2061,23 @@ function hasContext(context, owner) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-function effect(compute, effect, error, initialValue, options) {
+function effect(compute, effect, error, options) {
   let initialized = false;
-  const node = computed(
-    options?.render ? p => staleValues(() => compute(p)) : compute,
-    initialValue,
-    {
-      ...options,
-      equals: () => {
-        node._modified = !node._error;
-        if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
-        return false;
-      },
-      lazy: true
-    }
-  );
-  node._prevValue = initialValue;
+  const isUser = !!options?.user;
+  const node = computed(isUser ? compute : p => staleValues(() => compute(p)), {
+    ...options,
+    equals: () => {
+      node._modified = !node._error;
+      if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
+      return false;
+    },
+    lazy: true
+  });
+  node._prevValue = undefined;
   node._effectFn = effect;
   node._errorFn = error;
   node._cleanup = undefined;
-  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
+  node._type = isUser ? EFFECT_USER : EFFECT_RENDER;
   node._notifyStatus = (status, error) => {
     const actualStatus = status !== undefined ? status : node._statusFlags;
     const actualError = error !== undefined ? error : node._error;
@@ -2065,22 +2101,25 @@ function effect(compute, effect, error, initialValue, options) {
       node._queue.notify(node, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
       if (_hitUnhandledAsync) {
         resetUnhandledAsync();
-        const err = new Error("An async value must be rendered inside a Loading boundary.");
-        emitDiagnostic({
-          code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
-          kind: "async",
-          severity: "error",
-          message: err.message,
-          ownerId: node.id,
-          ownerName: node._name
-        });
-        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
+        if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) {
+          const message =
+            "An async value was read outside a Loading boundary. The root mount will be deferred until all pending async settles.";
+          emitDiagnostic({
+            code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
+            kind: "async",
+            severity: "warn",
+            message: message,
+            ownerId: node.id,
+            ownerName: node._name
+          });
+          console.warn(message);
+        }
       }
     }
   };
   recompute(node, true);
   !options?.defer &&
-    (node._type === EFFECT_USER
+    (node._type === EFFECT_USER || options?.schedule
       ? node._queue.enqueue(node._type, runEffect.bind(node))
       : runEffect.call(node));
   initialized = true;
@@ -2148,7 +2187,6 @@ function trackedEffect(fn, options) {
       }
       node._cleanup = cleanup;
     },
-    undefined,
     { ...options, lazy: true }
   );
   node._cleanup = undefined;
@@ -2257,31 +2295,29 @@ function accessor(node) {
   fn.$r = true;
   return fn;
 }
-function createSignal(first, second, third) {
+function createSignal(first, second) {
   if (typeof first === "function") {
-    const node = computed(first, second, third);
+    const node = computed(first, second);
+    node._preventAutoDisposal = true;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = signal(first, second);
   registerGraph(node, getOwner());
   return [accessor(node), setSignal.bind(null, node)];
 }
-function createMemo(compute, value, options) {
-  let node = computed(compute, value, options);
+function createMemo(compute, options) {
+  let node = computed(compute, options);
   return accessor(node);
 }
-function createEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
-    ...options,
-    name: options?.name ?? "effect"
-  });
-}
-function createRenderEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn, undefined, value, {
-    render: true,
+function createEffect(compute, effectFn, options) {
+  effect(compute, effectFn.effect || effectFn, effectFn.error, {
+    user: true,
     ...{ ...options, name: options?.name ?? "effect" }
   });
 }
+function createRenderEffect(compute, effectFn, options) {
+  effect(compute, effectFn, undefined, { ...options, name: options?.name ?? "effect" });
+}
 function createTrackedEffect(compute, options) {
   trackedEffect(compute, { ...options, name: options?.name ?? "trackedEffect" });
 }
@@ -2305,8 +2341,11 @@ function createReaction(effectFn, options) {
           dispose(node);
         },
         effectFn.error,
-        undefined,
-        { defer: true, ...(true ? { ...options, name: options?.name ?? "effect" } : options) }
+        {
+          ...(true ? { ...options, name: options?.name ?? "effect" } : options),
+          user: true,
+          defer: true
+        }
       );
     });
   };
@@ -2331,9 +2370,10 @@ function resolve(fn) {
     });
   });
 }
-function createOptimistic(first, second, third) {
+function createOptimistic(first, second) {
   if (typeof first === "function") {
-    const node = optimisticComputed(first, second, third);
+    const node = optimisticComputed(first, second);
+    node._preventAutoDisposal = true;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = optimisticSignal(first, second);
@@ -2499,7 +2539,7 @@ function reconcile(value, key) {
     applyState(value, state, keyFn);
   };
 }
-function createProjectionInternal(fn, initialValue = {}, options) {
+function createProjectionInternal(fn, seed, options) {
   let node;
   const wrappedMap = new WeakMap();
   const wrapper = s => {
@@ -2519,31 +2559,39 @@ function createProjectionInternal(fn, initialValue = {}, options) {
     wrappedMap.set(source, wrapped);
     return wrapped;
   };
-  const wrappedStore = wrapProjection(initialValue);
-  node = computed(() => {
-    const owner = getOwner();
-    let settled = false;
-    let result;
-    const draft = new Proxy(
-      wrappedStore,
-      createWriteTraps(() => !settled || owner._inFlight === result)
-    );
-    storeSetter(draft, s => {
-      result = fn(s);
-      settled = true;
-      const value = handleAsync(owner, result, value => {
-        value !== s &&
-          value !== undefined &&
-          storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
-      });
-      value !== s && value !== undefined && reconcile(value, options?.key || "id")(wrappedStore);
-    });
-  });
+  const wrappedStore = wrapProjection(seed);
+  node = computed(
+    () => {
+      if (!node) node = getOwner();
+      runProjectionComputed(wrappedStore, fn, options?.key || "id");
+    },
+    options?.name ? { name: options.name } : undefined
+  );
   node._preventAutoDisposal = true;
   return { store: wrappedStore, node: node };
 }
-function createProjection(fn, initialValue = {}, options) {
-  return createProjectionInternal(fn, initialValue, options).store;
+function createProjection(fn, seed, options) {
+  return createProjectionInternal(fn, seed, options).store;
+}
+function runProjectionComputed(wrappedStore, fn, key, wrapCommit) {
+  const owner = getOwner();
+  let settled = false;
+  let result;
+  const draft = new Proxy(
+    wrappedStore,
+    createWriteTraps(() => !settled || owner._inFlight === result)
+  );
+  storeSetter(draft, s => {
+    result = fn(s);
+    settled = true;
+    const commit = v => {
+      if (v === s || v === undefined) return;
+      const write = () => storeSetter(wrappedStore, reconcile(v, key));
+      wrapCommit ? wrapCommit(write) : write();
+    };
+    commit(handleAsync(owner, result, commit));
+  });
+  return owner;
 }
 function createWriteTraps(isActive) {
   const traps = {
@@ -2654,7 +2702,7 @@ function getNode(nodes, property, value, firewall, equals = isEqual, optimistic,
     {
       equals: equals,
       unobserved() {
-        delete nodes[property];
+        if (nodes[property] === s) delete nodes[property];
       }
     },
     firewall
@@ -2728,19 +2776,51 @@ function prepareStoreWrite(target, store, property) {
   if (useOptimistic) trackOptimisticStore(store);
   return { base: base, overrideKey: overrideKey, state: state };
 }
-function notifyStoreProperty(target, property, mode, value) {
-  if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], mode !== "delete");
+function upsertStoreNode(target, nodes, property, prev, snapshotProps) {
+  if (nodes[property]) return nodes[property];
+  const initial = isWrappable(prev) ? wrap(prev, target) : prev;
+  const node = getNode(
+    nodes,
+    property,
+    initial,
+    target[STORE_FIREWALL],
+    isEqual,
+    target[STORE_OPTIMISTIC],
+    snapshotProps
+  );
+  registerTransientStoreNode(node);
+  return node;
+}
+function notifyStoreProperty(target, property, mode, value, prev, prevHas) {
+  const skipUpsert = projectionWriteActive || target[STORE_OPTIMISTIC];
+  const newHas = mode !== "delete";
+  const existingHas = target[STORE_HAS]?.[property];
+  if (existingHas) {
+    setSignal(existingHas, newHas);
+  } else if (!skipUpsert && mode !== "invalidate" && prevHas !== newHas) {
+    const hasNode = upsertStoreNode(target, getNodes(target, STORE_HAS), property, prevHas);
+    setSignal(hasNode, newHas);
+  }
   const nodes = getNodes(target, STORE_NODE);
   if (mode === "set") {
-    nodes[property] &&
+    if (nodes[property]) {
       setSignal(nodes[property], () => (isWrappable(value) ? wrap(value, target) : value));
+    } else if (!skipUpsert) {
+      const node = upsertStoreNode(target, nodes, property, prev, target[STORE_SNAPSHOT_PROPS]);
+      setSignal(node, () => (isWrappable(value) ? wrap(value, target) : value));
+    }
   } else if (mode === "invalidate") {
     if (nodes[property]) {
       setSignal(nodes[property], {});
       delete nodes[property];
     }
   } else {
-    nodes[property] && setSignal(nodes[property], undefined);
+    if (nodes[property]) {
+      setSignal(nodes[property], undefined);
+    } else if (!skipUpsert) {
+      const node = upsertStoreNode(target, nodes, property, prev, target[STORE_SNAPSHOT_PROPS]);
+      setSignal(node, undefined);
+    }
   }
   nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
 }
@@ -2837,18 +2917,13 @@ const storeTraps = {
         : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
           ? target[STORE_OVERRIDE][property] !== $DELETED
           : property in target[STORE_VALUE];
-    if (!writeOnly(target[$PROXY])) {
-      getObserver() &&
-        read(
-          getNode(
-            getNodes(target, STORE_HAS),
-            property,
-            has,
-            target[STORE_FIREWALL],
-            isEqual,
-            target[STORE_OPTIMISTIC]
-          )
-        );
+    if (writeOnly(target[$PROXY])) return has;
+    const nodes = getNodes(target, STORE_HAS);
+    if (nodes[property]) return read(nodes[property]);
+    if (getObserver()) {
+      return read(
+        getNode(nodes, property, has, target[STORE_FIREWALL], isEqual, target[STORE_OPTIMISTIC])
+      );
     }
     return has;
   },
@@ -2867,6 +2942,12 @@ const storeTraps = {
             : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
               ? target[STORE_OVERRIDE][property]
               : base;
+        const prevHas =
+          target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
+            ? target[STORE_OPTIMISTIC_OVERRIDE][property] !== $DELETED
+            : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
+              ? target[STORE_OVERRIDE][property] !== $DELETED
+              : property in target[STORE_VALUE];
         const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
         const isArrayIndexWrite = Array.isArray(state) && property !== "length";
         const nextIndex = isArrayIndexWrite ? parseInt(property) + 1 : 0;
@@ -2886,11 +2967,21 @@ const storeTraps = {
           override[property] = value;
           if (nextLength !== undefined) override.length = nextLength;
         }
-        notifyStoreProperty(target, property, "set", value);
-        if (Array.isArray(state)) {
+        notifyStoreProperty(target, property, "set", value, prev, prevHas);
+        if (Array.isArray(state) && property !== "length" && nextLength !== undefined) {
           const nodes = getNodes(target, STORE_NODE);
-          const lengthValue = property === "length" ? value : nextLength;
-          lengthValue !== undefined && nodes.length && setSignal(nodes.length, lengthValue);
+          if (nodes.length) {
+            setSignal(nodes.length, nextLength);
+          } else if (!projectionWriteActive && !target[STORE_OPTIMISTIC]) {
+            const node = upsertStoreNode(
+              target,
+              nodes,
+              "length",
+              len,
+              target[STORE_SNAPSHOT_PROPS]
+            );
+            setSignal(node, nextLength);
+          }
         }
         if (true) DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
       });
@@ -2948,7 +3039,7 @@ const storeTraps = {
         } else if (target[overrideKey] && property in target[overrideKey]) {
           delete target[overrideKey][property];
         } else return true;
-        notifyStoreProperty(target, property, "delete");
+        notifyStoreProperty(target, property, "delete", undefined, prev, true);
       });
     }
     return true;
@@ -3021,7 +3112,7 @@ function createStore(first, second, options) {
 function createOptimisticStore(first, second, options) {
   GlobalQueue._clearOptimisticStore ||= clearOptimisticStore;
   const derived = typeof first === "function";
-  const initialValue = (derived ? second : first) ?? {};
+  const initialValue = derived ? second : first;
   const fn = derived ? first : undefined;
   const { store: wrappedStore } = createOptimisticProjectionInternal(fn, initialValue, options);
   return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
@@ -3055,7 +3146,7 @@ function clearOptimisticStore(store) {
   }
   delete target[STORE_OPTIMISTIC_OVERRIDE];
 }
-function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
+function createOptimisticProjectionInternal(fn, initialValue, options) {
   let node;
   const wrappedMap = new WeakMap();
   const wrapper = s => {
@@ -3078,37 +3169,25 @@ function createOptimisticProjectionInternal(fn, initialValue = {}, options) {
   };
   const wrappedStore = wrapProjection(initialValue);
   if (fn) {
-    node = computed(() => {
-      const owner = getOwner();
-      let settled = false;
-      let result;
-      const draft = new Proxy(
-        wrappedStore,
-        createWriteTraps(() => !settled || owner._inFlight === result)
-      );
+    const wrapCommit = write => {
       setProjectionWriteActive(true);
       try {
-        storeSetter(draft, s => {
-          result = fn(s);
-          settled = true;
-          const value = handleAsync(owner, result, value => {
-            setProjectionWriteActive(true);
-            try {
-              value !== s &&
-                value !== undefined &&
-                storeSetter(wrappedStore, reconcile(value, options?.key || "id"));
-            } finally {
-              setProjectionWriteActive(false);
-            }
-          });
-          value !== s &&
-            value !== undefined &&
-            reconcile(value, options?.key || "id")(wrappedStore);
-        });
+        write();
       } finally {
         setProjectionWriteActive(false);
       }
-    });
+    };
+    node = computed(
+      () => {
+        setProjectionWriteActive(true);
+        try {
+          runProjectionComputed(wrappedStore, fn, options?.key || "id", wrapCommit);
+        } finally {
+          setProjectionWriteActive(false);
+        }
+      },
+      options?.name ? { name: options.name } : undefined
+    );
     node._preventAutoDisposal = true;
   }
   return { store: wrappedStore, node: node };
@@ -3386,7 +3465,7 @@ function mapArray(list, map, options) {
         }
       }
     : map;
-  return createMemo(
+  const node = computed(
     updateKeyedMap.bind({
       _owner: createOwner(),
       _len: 0,
@@ -3401,8 +3480,10 @@ function mapArray(list, map, options) {
       _fallback: options?.fallback
     })
   );
+  node._preventAutoDisposal = true;
+  return accessor(node);
 }
-const pureOptions = { pureWrite: true };
+const pureOptions = { ownedWrite: true };
 function updateKeyedMap() {
   const newItems = this._list() || [],
     newLen = newItems.length;
@@ -3539,17 +3620,21 @@ function repeat(count, map, options) {
         }
       }
     : map;
-  return updateRepeat.bind({
-    _owner: createOwner(),
-    _len: 0,
-    _offset: 0,
-    _count: count,
-    _map: wrappedMap,
-    _nodes: [],
-    _mappings: [],
-    _from: options?.from,
-    _fallback: options?.fallback
-  });
+  const node = computed(
+    updateRepeat.bind({
+      _owner: createOwner(),
+      _len: 0,
+      _offset: 0,
+      _count: count,
+      _map: wrappedMap,
+      _nodes: [],
+      _mappings: [],
+      _from: options?.from,
+      _fallback: options?.fallback
+    })
+  );
+  node._preventAutoDisposal = true;
+  return accessor(node);
 }
 function updateRepeat() {
   const newLen = this._count();
@@ -3606,7 +3691,7 @@ function compare(key, a, b) {
   return key ? key(a) === key(b) : true;
 }
 function boundaryComputed(fn, propagationMask) {
-  const node = computed(fn, undefined, { lazy: true });
+  const node = computed(fn, { lazy: true });
   node._notifyStatus = (status, error) => {
     const flags = status !== undefined ? status : node._statusFlags;
     const actualError = error !== undefined ? error : node._error;
@@ -3631,12 +3716,16 @@ const ON_INIT = Symbol();
 const RevealControllerContext = createContext(null);
 let _revealUsed = false;
 const FALSE_ACCESSOR = () => false;
+const SEQUENTIAL_ACCESSOR = () => "sequential";
 function isRevealController(slot) {
   return slot instanceof RevealController;
 }
 function isSlotReady(slot) {
   return isRevealController(slot) ? slot.isReady() : slot._sources.size === 0 && !slot._pending;
 }
+function isSlotMinimallyReady(slot) {
+  return isRevealController(slot) ? slot.isMinimallyReady() : isSlotReady(slot);
+}
 function setSlotState(slot, controller, disabled, collapsed) {
   setSignal(slot._disabled, disabled);
   setSignal(slot._collapsed, collapsed);
@@ -3648,16 +3737,17 @@ function setSlotState(slot, controller, disabled, collapsed) {
     slot._revealController = undefined;
 }
 class RevealController {
-  _togetherAccessor;
+  _orderAccessor;
   _collapsedAccessor;
   _slots = [];
   _parentController;
-  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
-  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _ready = true;
+  _minimallyReady = true;
   _evaluating = false;
-  constructor(together, collapsed) {
-    this._togetherAccessor = together;
+  constructor(order, collapsed) {
+    this._orderAccessor = order;
     this._collapsedAccessor = collapsed;
   }
   _forEachOwnedSlot(fn) {
@@ -3672,12 +3762,37 @@ class RevealController {
   isReady() {
     return this._forEachOwnedSlot(isSlotReady);
   }
+  isMinimallyReady() {
+    const order = untrack(this._orderAccessor);
+    if (order === "together") return this.isReady();
+    if (order === "natural") {
+      let hasSlot = false;
+      let anyReady = false;
+      this._forEachOwnedSlot(slot => {
+        hasSlot = true;
+        if (isSlotMinimallyReady(slot)) {
+          anyReady = true;
+          return false;
+        }
+      });
+      return !hasSlot || anyReady;
+    }
+    let firstReady = true;
+    this._forEachOwnedSlot(slot => {
+      firstReady = isSlotMinimallyReady(slot);
+      return false;
+    });
+    return firstReady;
+  }
   register(slot) {
     if (this._slots.includes(slot)) return;
     this._slots.push(slot);
-    const together = !!untrack(this._togetherAccessor);
-    setSignal(slot._disabled, true),
-      setSignal(slot._collapsed, together ? false : !!untrack(this._collapsedAccessor));
+    const order = untrack(this._orderAccessor);
+    (setSignal(slot._disabled, true),
+      setSignal(
+        slot._collapsed,
+        order === "sequential" ? !!untrack(this._collapsedAccessor) : false
+      ));
     untrack(() => this.evaluate());
   }
   unregister(slot) {
@@ -3689,29 +3804,52 @@ class RevealController {
     if (this._evaluating) return;
     this._evaluating = true;
     const wasReady = this._ready;
+    const wasMinReady = this._minimallyReady;
     try {
       const disabled = disabledOverride ?? read(this._disabled),
-        collapseTail = !!untrack(this._collapsedAccessor),
+        order = untrack(this._orderAccessor),
+        collapseTail = order === "sequential" && !!untrack(this._collapsedAccessor),
         collapsed = collapsedOverride ?? collapseTail;
-      if (disabled && collapsed)
-        this._forEachOwnedSlot(slot => setSlotState(slot, this, true, true));
-      else if (!!untrack(this._togetherAccessor)) {
-        const ready = this.isReady();
-        this._forEachOwnedSlot(slot => setSlotState(slot, this, !ready, false));
+      if (disabled) {
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, true, collapsed));
+      } else if (order === "natural") {
+        this._forEachOwnedSlot(slot => {
+          if (isRevealController(slot)) {
+            setSignal(slot._collapsed, false);
+            setSignal(slot._disabled, false);
+            slot.evaluate(false, false);
+          } else {
+            setSlotState(slot, this, !isSlotReady(slot), false);
+          }
+        });
+      } else if (order === "together") {
+        const minReady = this._forEachOwnedSlot(isSlotMinimallyReady);
+        this._forEachOwnedSlot(slot => setSlotState(slot, this, !minReady, false));
       } else {
         let pendingSeen = false;
         this._forEachOwnedSlot(slot => {
           if (pendingSeen) return setSlotState(slot, this, true, collapseTail);
           if (isSlotReady(slot)) return setSlotState(slot, this, false, false);
           pendingSeen = true;
-          setSlotState(slot, this, true, false);
+          if (isRevealController(slot)) {
+            setSignal(slot._collapsed, false);
+            setSignal(slot._disabled, false);
+            slot.evaluate(false, false);
+          } else {
+            setSlotState(slot, this, true, false);
+          }
         });
       }
     } finally {
       this._ready = this.isReady();
+      this._minimallyReady = this.isMinimallyReady();
       this._evaluating = false;
     }
-    if (this._parentController && wasReady !== this._ready) this._parentController.evaluate();
+    if (
+      this._parentController &&
+      (wasReady !== this._ready || wasMinReady !== this._minimallyReady)
+    )
+      this._parentController.evaluate();
   }
 }
 class CollectionQueue extends Queue {
@@ -3719,8 +3857,8 @@ class CollectionQueue extends Queue {
   _sources = new Set();
   _tree;
   _pending = true;
-  _disabled = signal(false, { pureWrite: true, _noSnapshot: true });
-  _collapsed = signal(false, { pureWrite: true, _noSnapshot: true });
+  _disabled = signal(false, { ownedWrite: true, _noSnapshot: true });
+  _collapsed = signal(false, { ownedWrite: true, _noSnapshot: true });
   _revealController;
   _initialized = false;
   _onFn;
@@ -3836,7 +3974,7 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
   const decision = computed(() => {
     if (!read(queue._disabled)) {
       const resolved = read(tree);
-      if (!untrack(() => read(queue._disabled))) return (queue._initialized = true), resolved;
+      if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
     }
     if (_revealUsed && read(queue._collapsed)) return undefined;
     return fallback(queue);
@@ -3860,14 +3998,14 @@ function createRevealOrder(fn, options) {
   _revealUsed = true;
   const owner = createOwner();
   const parentController = getContext(RevealControllerContext);
-  const together = options?.together || FALSE_ACCESSOR,
+  const order = options?.order || SEQUENTIAL_ACCESSOR,
     collapsed = options?.collapsed || FALSE_ACCESSOR;
-  const controller = new RevealController(together, collapsed);
+  const controller = new RevealController(order, collapsed);
   setContext(RevealControllerContext, controller, owner);
   return runWithOwner(owner, () => {
     const value = fn();
     computed(() => {
-      together();
+      order();
       collapsed();
       controller.evaluate();
     });