@solidjs/signals 2.0.0-beta.8 → 2.0.0-beta.9

package/dist/dev.js

@@ -35,6 +35,12 @@ const REACTIVE_DISPOSED = 1 << 6;
 const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
 const REACTIVE_SNAPSHOT_STALE = 1 << 8;
 const REACTIVE_LAZY = 1 << 9;
+const CONFIG_OWNED_WRITE = 1 << 0;
+const CONFIG_NO_SNAPSHOT = 1 << 1;
+const CONFIG_TRANSPARENT = 1 << 2;
+const CONFIG_IN_SNAPSHOT_SCOPE = 1 << 3;
+const CONFIG_CHILDREN_FORBIDDEN = 1 << 4;
+const CONFIG_AUTO_DISPOSE = 1 << 5;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -309,6 +315,7 @@ function mergeTransitionState(target, outgoing) {
     if (!targetReporters) target._asyncReporters.set(source, (targetReporters = new Set()));
     for (const reporter of reporters) targetReporters.add(reporter);
   }
+  for (const sub of outgoing._gatedSubs) target._gatedSubs.add(sub);
 }
 function resolveOptimisticNodes(nodes) {
   for (let i = 0; i < nodes.length; i++) {
@@ -439,11 +446,15 @@ class GlobalQueue extends Queue {
           scheduled = dirtyQueue._max >= dirtyQueue._min;
           reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
-          if (!stashedTransition._actions.length && stashedTransition._optimisticNodes.length) {
+          if (
+            !stashedTransition._actions.length &&
+            !stashedTransition._asyncReporters.size &&
+            stashedTransition._optimisticNodes.length
+          ) {
             stashedOptimisticReads = new Set();
             for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
               const node = stashedTransition._optimisticNodes[i];
-              if (node._fn || node._ownedWrite) continue;
+              if (node._fn || node._config & CONFIG_OWNED_WRITE) continue;
               stashedOptimisticReads.add(node);
               queueStashedOptimisticEffects(node);
             }
@@ -509,7 +520,8 @@ class GlobalQueue extends Queue {
         _optimisticStores: new Set(),
         _actions: [],
         _queueStash: { _queues: [[], []], _children: [] },
-        _done: false
+        _done: false,
+        _gatedSubs: new Set()
       };
     } else if (transition) {
       const outgoing = activeTransition;
@@ -548,7 +560,7 @@ function insertSubs(node, optimistic = false) {
   const sourceLane = node._optimisticLane || currentOptimisticLane;
   const hasSnapshot = node._snapshotValue !== undefined;
   for (let s = node._subs; s !== null; s = s._nextSub) {
-    if (hasSnapshot && s._sub._inSnapshotScope) {
+    if (hasSnapshot && s._sub._config & CONFIG_IN_SNAPSHOT_SCOPE) {
       s._sub._flags |= REACTIVE_SNAPSHOT_STALE;
       continue;
     }
@@ -596,6 +608,22 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
     resolveOptimisticNodes(
       completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes
     );
+    if (completingTransition && completingTransition._gatedSubs.size) {
+      for (const sub of completingTransition._gatedSubs) {
+        if (sub._flags & REACTIVE_DISPOSED) continue;
+        if (sub._type === EFFECT_TRACKED) {
+          if (!sub._modified) {
+            sub._modified = true;
+            sub._queue.enqueue(EFFECT_USER, sub._run);
+          }
+          continue;
+        }
+        const queue = sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+        if (queue._min > sub._height) queue._min = sub._height;
+        insertIntoHeap(sub, queue);
+      }
+      completingTransition._gatedSubs.clear();
+    }
     const optimisticStores = completingTransition
       ? completingTransition._optimisticStores
       : globalQueue._optimisticStores;
@@ -796,7 +824,8 @@ function unlinkSubs(link) {
     dep._subs = nextSub;
     if (nextSub === null) {
       dep._unobserved?.();
-      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
+      const c = dep;
+      c._fn && c._config & CONFIG_AUTO_DISPOSE && !(c._flags & REACTIVE_ZOMBIE) && unobserved(c);
     }
   }
   return nextDep;
@@ -913,7 +942,7 @@ function runDisposal(node, zombie) {
 }
 function childId(owner, consume) {
   let counter = owner;
-  while (counter._transparent && counter._parent) counter = counter._parent;
+  while (counter._config & CONFIG_TRANSPARENT && counter._parent) counter = counter._parent;
   if (counter.id != null)
     return formatId(counter.id, consume ? counter._childCount++ : counter._childCount);
   throw new Error("Cannot get child id from owner without an id");
@@ -953,7 +982,7 @@ function createOwner(options) {
     id:
       options?.id ??
       (transparent ? parent?.id : parent?.id != null ? getNextChildId(parent) : undefined),
-    _transparent: transparent || undefined,
+    _config: transparent ? CONFIG_TRANSPARENT : 0,
     _root: true,
     _parentComputed: parent?._root ? parent._parentComputed : parent,
     _firstChild: null,
@@ -969,10 +998,16 @@ function createOwner(options) {
       disposeChildren(owner, self);
     }
   };
-  if (parent?._childrenForbidden) {
-    throw new Error(
-      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
-    );
+  if (parent && parent._config & CONFIG_CHILDREN_FORBIDDEN) {
+    emitDiagnostic({
+      code: "PRIMITIVE_IN_FORBIDDEN_SCOPE",
+      kind: "lifecycle",
+      severity: "error",
+      message: PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE,
+      ownerId: parent.id,
+      ownerName: parent._name
+    });
+    throw new Error(PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE);
   }
   if (parent) {
     const lastChild = parent._firstChild;
@@ -1299,6 +1334,8 @@ function enableExternalSource(config) {
 }
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
+const PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE =
+  "[PRIMITIVE_IN_FORBIDDEN_SCOPE] Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled";
 let tracking = false;
 let stale = false;
 let refreshing = false;
@@ -1337,7 +1374,7 @@ function releaseSubtree(owner) {
     }
     if (child._fn) {
       const comp = child;
-      comp._inSnapshotScope = false;
+      comp._config &= ~CONFIG_IN_SNAPSHOT_SCOPE;
       if (comp._flags & REACTIVE_SNAPSHOT_STALE) {
         comp._flags &= ~REACTIVE_SNAPSHOT_STALE;
         comp._flags |= REACTIVE_DIRTY;
@@ -1377,7 +1414,7 @@ function recompute(el, create = false) {
       clearSignals(el);
     }
   }
-  const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
+  let isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
   const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
   const wasPending = !!(el._statusFlags & STATUS_PENDING);
   const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
@@ -1399,6 +1436,20 @@ function recompute(el, create = false) {
   if (isOptimisticDirty) {
     const lane = resolveLane(el);
     if (lane) currentOptimisticLane = lane;
+  } else if (activeTransition && !create && activeTransition._optimisticNodes.length) {
+    for (let d = el._deps; d; d = d._nextDep) {
+      const dep = d._dep;
+      if (dep._flags & REACTIVE_OPTIMISTIC_DIRTY) {
+        const depLane = resolveLane(dep);
+        if (depLane) {
+          isOptimisticDirty = true;
+          currentOptimisticLane = depLane;
+          el._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+          assignOrMergeLane(el, depLane);
+          break;
+        }
+      }
+    }
   }
   try {
     const prevInFlight = el._inFlight;
@@ -1508,9 +1559,12 @@ function computed(fn, options) {
     id:
       options?.id ??
       (transparent ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
-    _transparent: transparent || undefined,
+    _config:
+      (transparent ? CONFIG_TRANSPARENT : 0) |
+      (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (!context || options?.lazy ? CONFIG_AUTO_DISPOSE : 0) |
+      (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
     _equals: options?.equals != null ? options.equals : isEqual,
-    _ownedWrite: !!options?.ownedWrite,
     _unobserved: options?.unobserved,
     _disposal: null,
     _queue: context?._queue ?? globalQueue,
@@ -1541,10 +1595,16 @@ function computed(fn, options) {
   self._name = options?.name ?? "computed";
   self._prevHeap = self;
   const parent = context?._root ? context._parentComputed : context;
-  if (context?._childrenForbidden) {
-    throw new Error(
-      "Cannot create reactive primitives inside createTrackedEffect or owner-backed onSettled"
-    );
+  if (context && context._config & CONFIG_CHILDREN_FORBIDDEN) {
+    emitDiagnostic({
+      code: "PRIMITIVE_IN_FORBIDDEN_SCOPE",
+      kind: "lifecycle",
+      severity: "error",
+      message: PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE,
+      ownerId: context.id,
+      ownerName: context._name
+    });
+    throw new Error(PRIMITIVE_IN_FORBIDDEN_SCOPE_MESSAGE);
   }
   if (context) {
     const lastChild = context._firstChild;
@@ -1557,7 +1617,6 @@ function computed(fn, options) {
   }
   DEV$1.hooks.onOwner?.(self);
   if (parent) self._height = parent._height + 1;
-  if (snapshotCaptureActive && ownerInSnapshotScope(context)) self._inSnapshotScope = true;
   if (externalSourceConfig) {
     const bridgeSignal = signal(undefined, { equals: false, ownedWrite: true });
     const source = externalSourceConfig.factory(self._fn, () => {
@@ -1581,8 +1640,9 @@ function computed(fn, options) {
 function signal(v, options, firewall = null) {
   const s = {
     _equals: options?.equals != null ? options.equals : isEqual,
-    _ownedWrite: !!options?.ownedWrite,
-    _noSnapshot: !!options?._noSnapshot,
+    _config:
+      (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (options?._noSnapshot ? CONFIG_NO_SNAPSHOT : 0),
     _unobserved: options?.unobserved,
     _value: v,
     _subs: null,
@@ -1599,7 +1659,7 @@ function signal(v, options, firewall = null) {
   firewall && (firewall._child = s);
   if (
     snapshotCaptureActive &&
-    !s._noSnapshot &&
+    !(s._config & CONFIG_NO_SNAPSHOT) &&
     !((firewall?._statusFlags ?? 0) & STATUS_PENDING)
   ) {
     s._snapshotValue = v === undefined ? NO_SNAPSHOT : v;
@@ -1707,7 +1767,7 @@ function read(el) {
   const owner = el._firewall || el;
   if (strictRead && owner._statusFlags & STATUS_PENDING) {
     const message =
-      `Reading a pending async value directly in ${strictRead}. ` +
+      `[PENDING_ASYNC_UNTRACKED_READ] Reading a pending async value directly in ${strictRead}. ` +
       `Async values must be read within a tracking scope (JSX, a memo, or an effect's compute function).`;
     emitDiagnostic({
       code: "PENDING_ASYNC_UNTRACKED_READ",
@@ -1738,9 +1798,9 @@ function read(el) {
   }
   if (owner._statusFlags & STATUS_PENDING) {
     if (c && !(stale && owner._transition && activeTransition !== owner._transition)) {
-      if (c?._childrenForbidden) {
+      if (c && c._config & CONFIG_CHILDREN_FORBIDDEN) {
         const message =
-          "Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
+          "[PENDING_ASYNC_FORBIDDEN_SCOPE] Reading a pending async value inside createTrackedEffect or onSettled will throw. " +
           "Use createEffect instead which supports async-aware reactivity.";
         emitDiagnostic({
           code: "PENDING_ASYNC_FORBIDDEN_SCOPE",
@@ -1777,7 +1837,7 @@ function read(el) {
       return read(el);
     } else throw el._error;
   }
-  if (snapshotCaptureActive && c && c._inSnapshotScope) {
+  if (snapshotCaptureActive && c && c._config & CONFIG_IN_SNAPSHOT_SCOPE) {
     const sv = el._snapshotValue;
     if (sv !== undefined) {
       const snapshot = sv === NO_SNAPSHOT ? undefined : sv;
@@ -1788,7 +1848,7 @@ function read(el) {
   }
   if (strictRead) {
     const message =
-      `Reactive value read directly in ${strictRead} will not update. ` +
+      `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictRead} will not update. ` +
       `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
     emitDiagnostic({
       code: "STRICT_READ_UNTRACKED",
@@ -1806,6 +1866,18 @@ function read(el) {
     if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
   }
+  if (
+    activeTransition !== null &&
+    currentOptimisticLane !== null &&
+    !latestReadActive &&
+    el._pendingValue !== NOT_PENDING &&
+    owner === el &&
+    !el._fn &&
+    c
+  ) {
+    activeTransition._gatedSubs.add(c);
+    return el._value;
+  }
   const value =
     !c ||
     (currentOptimisticLane !== null &&
@@ -1821,9 +1893,8 @@ function read(el) {
     !c &&
     owner === el &&
     typeof computed._fn === "function" &&
-    !computed._preventAutoDisposal &&
+    el._config & CONFIG_AUTO_DISPOSE &&
     !(owner._statusFlags & STATUS_PENDING) &&
-    !computed._parent &&
     !el._subs
   ) {
     unobserved(el);
@@ -1831,9 +1902,14 @@ function read(el) {
   return value;
 }
 function setSignal(el, v) {
-  if (!el._ownedWrite && !context?._childrenForbidden && context && el._firewall !== context) {
+  if (
+    !(el._config & CONFIG_OWNED_WRITE) &&
+    !(context && context._config & CONFIG_CHILDREN_FORBIDDEN) &&
+    context &&
+    el._firewall !== context
+  ) {
     const message =
-      "Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
+      "[SIGNAL_WRITE_IN_OWNED_SCOPE] Writing to a Signal inside an owned scope (component, computation) is not allowed. " +
       "Move the write outside or set the `ownedWrite` option if this is intentional.";
     emitDiagnostic({
       code: "SIGNAL_WRITE_IN_OWNED_SCOPE",
@@ -1894,7 +1970,7 @@ function setSignal(el, v) {
 function runWithOwner(owner, fn) {
   if (owner && owner._flags & REACTIVE_DISPOSED) {
     const message =
-      "runWithOwner called with a disposed owner. Children created inside will never be disposed.";
+      "[RUN_WITH_DISPOSED_OWNER] runWithOwner called with a disposed owner. Children created inside will never be disposed.";
     emitDiagnostic({
       code: "RUN_WITH_DISPOSED_OWNER",
       kind: "owner",
@@ -2073,6 +2149,7 @@ function effect(compute, effect, error, options) {
     },
     lazy: true
   });
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   node._prevValue = undefined;
   node._effectFn = effect;
   node._errorFn = error;
@@ -2103,7 +2180,7 @@ function effect(compute, effect, error, options) {
         resetUnhandledAsync();
         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.";
+            "[ASYNC_OUTSIDE_LOADING_BOUNDARY] 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",
@@ -2125,7 +2202,8 @@ function effect(compute, effect, error, options) {
   initialized = true;
   cleanup(() => node._cleanup?.());
   if (!node._parent) {
-    const message = "Effects created outside a reactive context will never be disposed";
+    const message =
+      "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
     emitDiagnostic({
       code: "NO_OWNER_EFFECT",
       kind: "lifecycle",
@@ -2190,7 +2268,7 @@ function trackedEffect(fn, options) {
     { ...options, lazy: true }
   );
   node._cleanup = undefined;
-  node._childrenForbidden = true;
+  node._config = (node._config & ~CONFIG_AUTO_DISPOSE) | CONFIG_CHILDREN_FORBIDDEN;
   node._modified = true;
   node._type = EFFECT_TRACKED;
   node._notifyStatus = (status, error) => {
@@ -2205,7 +2283,8 @@ function trackedEffect(fn, options) {
   node._queue.enqueue(EFFECT_USER, run);
   cleanup(() => node._cleanup?.());
   if (!node._parent) {
-    const message = "Effects created outside a reactive context will never be disposed";
+    const message =
+      "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
     emitDiagnostic({
       code: "NO_OWNER_EFFECT",
       kind: "lifecycle",
@@ -2266,7 +2345,8 @@ function onCleanup(fn) {
   {
     const owner = getOwner();
     if (!owner) {
-      const message = "onCleanup called outside a reactive context will never be run";
+      const message =
+        "[NO_OWNER_CLEANUP] onCleanup called outside a reactive context will never be run";
       emitDiagnostic({
         code: "NO_OWNER_CLEANUP",
         kind: "lifecycle",
@@ -2274,9 +2354,9 @@ function onCleanup(fn) {
         message: message
       });
       console.warn(message);
-    } else if (owner._childrenForbidden) {
+    } else if (owner._config & CONFIG_CHILDREN_FORBIDDEN) {
       const message =
-        "Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead";
+        "[CLEANUP_IN_FORBIDDEN_SCOPE] Cannot use onCleanup inside createTrackedEffect or onSettled; return a cleanup function instead";
       emitDiagnostic({
         code: "CLEANUP_IN_FORBIDDEN_SCOPE",
         kind: "lifecycle",
@@ -2291,14 +2371,12 @@ function onCleanup(fn) {
   return cleanup(fn);
 }
 function accessor(node) {
-  const fn = read.bind(null, node);
-  fn.$r = true;
-  return fn;
+  return read.bind(null, node);
 }
 function createSignal(first, second) {
   if (typeof first === "function") {
     const node = computed(first, second);
-    node._preventAutoDisposal = true;
+    node._config &= ~CONFIG_AUTO_DISPOSE;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = signal(first, second);
@@ -2306,10 +2384,23 @@ function createSignal(first, second) {
   return [accessor(node), setSignal.bind(null, node)];
 }
 function createMemo(compute, options) {
-  let node = computed(compute, options);
-  return accessor(node);
+  return accessor(computed(compute, options));
 }
 function createEffect(compute, effectFn, options) {
+  if (effectFn === undefined) {
+    const message =
+      "[MISSING_EFFECT_FN] createEffect requires both a compute function and an effect function. " +
+      "Use `createEffect(() => signal(), value => doWork(value))`. " +
+      "If you want a derived value, use `createMemo`. " +
+      "If you want a one-shot side effect, just call the function directly.";
+    emitDiagnostic({
+      code: "MISSING_EFFECT_FN",
+      kind: "lifecycle",
+      severity: "error",
+      message: message
+    });
+    throw new Error(message);
+  }
   effect(compute, effectFn.effect || effectFn, effectFn.error, {
     user: true,
     ...{ ...options, name: options?.name ?? "effect" }
@@ -2373,7 +2464,7 @@ function resolve(fn) {
 function createOptimistic(first, second) {
   if (typeof first === "function") {
     const node = optimisticComputed(first, second);
-    node._preventAutoDisposal = true;
+    node._config &= ~CONFIG_AUTO_DISPOSE;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = optimisticSignal(first, second);
@@ -2382,7 +2473,7 @@ function createOptimistic(first, second) {
 }
 function onSettled(callback) {
   const owner = getOwner();
-  owner && !owner._childrenForbidden
+  owner && !(owner._config & CONFIG_CHILDREN_FORBIDDEN)
     ? createTrackedEffect(() => untrack(callback), { name: "onSettled" })
     : globalQueue.enqueue(EFFECT_USER, () => {
         const cleanup = callback();
@@ -2567,7 +2658,7 @@ function createProjectionInternal(fn, seed, options) {
     },
     options?.name ? { name: options.name } : undefined
   );
-  node._preventAutoDisposal = true;
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   return { store: wrappedStore, node: node };
 }
 function createProjection(fn, seed, options) {
@@ -2895,7 +2986,7 @@ const storeTraps = {
     }
     if (strictRead && typeof property === "string") {
       const message =
-        `Reactive value read directly in ${strictRead} will not update. ` +
+        `[STRICT_READ_UNTRACKED] Reactive value read directly in ${strictRead} will not update. ` +
         `Move it into a tracking scope (JSX, a memo, or an effect's compute function).`;
       emitDiagnostic({
         code: "STRICT_READ_UNTRACKED",
@@ -3188,7 +3279,7 @@ function createOptimisticProjectionInternal(fn, initialValue, options) {
       },
       options?.name ? { name: options.name } : undefined
     );
-    node._preventAutoDisposal = true;
+    node._config &= ~CONFIG_AUTO_DISPOSE;
   }
   return { store: wrappedStore, node: node };
 }
@@ -3465,22 +3556,22 @@ function mapArray(list, map, options) {
         }
       }
     : map;
-  const node = computed(
-    updateKeyedMap.bind({
-      _owner: createOwner(),
-      _len: 0,
-      _list: list,
-      _items: [],
-      _map: wrappedMap,
-      _mappings: [],
-      _nodes: [],
-      _key: keyFn,
-      _rows: keyFn || options?.keyed === false ? [] : undefined,
-      _indexes: indexes ? [] : undefined,
-      _fallback: options?.fallback
-    })
-  );
-  node._preventAutoDisposal = true;
+  const data = {
+    _owner: createOwner(),
+    _len: 0,
+    _list: list,
+    _items: [],
+    _map: wrappedMap,
+    _mappings: [],
+    _nodes: [],
+    _key: keyFn,
+    _rows: keyFn || options?.keyed === false ? [] : undefined,
+    _indexes: indexes ? [] : undefined,
+    _fallback: options?.fallback
+  };
+  const node = computed(updateKeyedMap.bind(data));
+  data._owner._parentComputed = node;
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   return accessor(node);
 }
 const pureOptions = { ownedWrite: true };
@@ -3633,7 +3724,7 @@ function repeat(count, map, options) {
       _fallback: options?.fallback
     })
   );
-  node._preventAutoDisposal = true;
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   return accessor(node);
 }
 function updateRepeat() {
@@ -3699,7 +3790,7 @@ function boundaryComputed(fn, propagationMask) {
     node._queue.notify(node, node._propagationMask, flags, actualError);
   };
   node._propagationMask = propagationMask;
-  node._preventAutoDisposal = true;
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   recompute(node, true);
   return node;
 }
@@ -3938,7 +4029,8 @@ class CollectionQueue extends Queue {
 }
 function createCollectionBoundary(type, fn, fallback, onFn) {
   if (!getOwner()) {
-    const message = "Boundaries created outside a reactive context will never be disposed.";
+    const message =
+      "[NO_OWNER_BOUNDARY] Boundaries created outside a reactive context will never be disposed.";
     emitDiagnostic({
       code: "NO_OWNER_BOUNDARY",
       kind: "lifecycle",
@@ -3971,15 +4063,16 @@ function createCollectionBoundary(type, fn, fallback, onFn) {
     controller.register(queue);
     cleanup(() => controller.unregister(queue));
   }
-  const decision = computed(() => {
-    if (!read(queue._disabled)) {
-      const resolved = read(tree);
-      if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
-    }
-    if (_revealUsed && read(queue._collapsed)) return undefined;
-    return fallback(queue);
-  });
-  return accessor(decision);
+  return accessor(
+    computed(() => {
+      if (!read(queue._disabled)) {
+        const resolved = read(tree);
+        if (!untrack(() => read(queue._disabled))) return ((queue._initialized = true), resolved);
+      }
+      if (_revealUsed && read(queue._collapsed)) return undefined;
+      return fallback(queue);
+    })
+  );
 }
 function createLoadingBoundary(fn, fallback, options) {
   return createCollectionBoundary(STATUS_PENDING, fn, () => fallback(), options?.on);