@solidjs/signals 0.13.12 → 2.0.0-beta.7

package/README.md

@@ -1,6 +1,6 @@
 # @solidjs/signals
 
-The reactive core that powers [SolidJS 2.0](https://github.com/solidjs/solid). This is a standalone signals library designed for rendering — it includes first-class support for async, transitions, optimistic updates, and deeply reactive stores that go beyond what general-purpose signals libraries offer.
+The reactive core that powers [SolidJS 2.0](https://github.com/solidjs/solid). It is developed in the Solid monorepo and includes first-class support for async, transitions, optimistic updates, and deeply reactive stores that go beyond what general-purpose signals libraries offer.
 
 > **Status:** Beta — this package is the reactive foundation of SolidJS 2.0 Beta. The API is stabilizing but may still have breaking changes before a final release.
 
@@ -240,14 +240,15 @@ createRoot(dispose => {
 
 ## Development
 
+From the monorepo root:
+
 ```bash
 pnpm install
-pnpm build          # Rollup build (dev/prod/node outputs)
-pnpm test           # Run tests
-pnpm test:watch     # Watch mode
-pnpm test:gc        # Tests with GC exposed
-pnpm bench          # Benchmarks
-pnpm format         # Prettier + import sorting
+pnpm --filter @solidjs/signals build
+pnpm --filter @solidjs/signals test
+pnpm --filter @solidjs/signals test:watch
+pnpm --filter @solidjs/signals test:gc
+pnpm --filter @solidjs/signals bench
 ```
 
 ## License

package/dist/dev.js

@@ -426,7 +426,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);
             }
@@ -790,6 +790,7 @@ function unobserved(el) {
     dep = unlinkSubs(dep);
   }
   el._deps = null;
+  el._depsTail = null;
   disposeChildren(el, true);
 }
 function link(dep, sub) {
@@ -1081,6 +1082,7 @@ function handleAsync(el, result, setter) {
     if (el._inFlight !== result) return;
     if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
     globalQueue.initTransition(resolveTransition(el));
+    const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
@@ -1094,9 +1096,10 @@ function handleAsync(el, result, setter) {
       }
       el._time = clock;
     } else if (lane) {
+      const isEffect = el._type;
       const prevValue = el._value;
       const equals = el._equals;
-      if (!equals || !equals(value, prevValue)) {
+      if ((!isEffect && wasUninitialized) || !equals || !equals(value, prevValue)) {
         el._value = value;
         el._time = clock;
         if (el._latestValueComputed) {
@@ -1359,6 +1362,7 @@ function recompute(el, create = false) {
   const 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);
   const oldcontext = context;
   context = el;
   el._depsTail = null;
@@ -1424,7 +1428,8 @@ function recompute(el, create = false) {
       : el._pendingValue === NOT_PENDING
         ? el._value
         : el._pendingValue;
-    const valueChanged = !el._equals || !el._equals(compareValue, value);
+    const valueChanged =
+      (!isEffect && wasUninitialized) || !el._equals || !el._equals(compareValue, value);
     if (valueChanged) {
       const prevVisible = hasOverride ? el._overrideValue : undefined;
       if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty) {
@@ -1485,7 +1490,7 @@ 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,
@@ -1534,7 +1539,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);
     });
@@ -1556,7 +1561,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,
@@ -1668,10 +1673,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) {
@@ -1691,7 +1702,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;
@@ -1776,7 +1786,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 ||
@@ -1784,14 +1795,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",
@@ -1875,7 +1898,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;
     }
@@ -2061,16 +2084,18 @@ 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 must be rendered inside a Loading boundary.";
+          emitDiagnostic({
+            code: "ASYNC_OUTSIDE_LOADING_BOUNDARY",
+            kind: "async",
+            severity: "error",
+            message: message,
+            ownerId: node.id,
+            ownerName: node._name
+          });
+          throw new Error(message);
+        }
       }
     }
   };
@@ -2253,27 +2278,28 @@ 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, undefined, 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, undefined, options);
   return accessor(node);
 }
-function createEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
+function createEffect(compute, effectFn, options) {
+  effect(compute, effectFn.effect || effectFn, effectFn.error, undefined, {
     ...options,
     name: options?.name ?? "effect"
   });
 }
-function createRenderEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn, undefined, value, {
+function createRenderEffect(compute, effectFn, options) {
+  effect(compute, effectFn, undefined, undefined, {
     render: true,
     ...{ ...options, name: options?.name ?? "effect" }
   });
@@ -2327,9 +2353,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, undefined, second);
+    node._preventAutoDisposal = true;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = optimisticSignal(first, second);
@@ -2495,7 +2522,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 => {
@@ -2515,7 +2542,7 @@ function createProjectionInternal(fn, initialValue = {}, options) {
     wrappedMap.set(source, wrapped);
     return wrapped;
   };
-  const wrappedStore = wrapProjection(initialValue);
+  const wrappedStore = wrapProjection(seed);
   node = computed(() => {
     const owner = getOwner();
     let settled = false;
@@ -2538,8 +2565,8 @@ function createProjectionInternal(fn, initialValue = {}, options) {
   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 createWriteTraps(isActive) {
   const traps = {
@@ -2690,12 +2717,55 @@ function getKeys(source, override, enumerable = true) {
   return Array.from(keys);
 }
 function getPropertyDescriptor(source, override, property) {
-  let value = source;
   if (override && property in override) {
-    if (value[property] === $DELETED) return void 0;
-    if (!(property in value)) value = override;
+    if (override[property] === $DELETED) return void 0;
+    const overrideDesc = Reflect.getOwnPropertyDescriptor(override, property);
+    if (overrideDesc?.get || overrideDesc?.set || !(property in source)) return overrideDesc;
   }
-  return Reflect.getOwnPropertyDescriptor(value, property);
+  return Reflect.getOwnPropertyDescriptor(source, property);
+}
+function prepareStoreWrite(target, store, property) {
+  if (target[STORE_OPTIMISTIC]) {
+    const firewall = target[STORE_FIREWALL];
+    if (firewall?._transition) {
+      globalQueue.initTransition(firewall._transition);
+    }
+  }
+  const state = target[STORE_VALUE];
+  const base = state[property];
+  if (
+    snapshotCaptureActive &&
+    typeof property !== "symbol" &&
+    !((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
+  ) {
+    if (!target[STORE_SNAPSHOT_PROPS]) {
+      target[STORE_SNAPSHOT_PROPS] = Object.create(null);
+      snapshotSources?.add(target);
+    }
+    if (!(property in target[STORE_SNAPSHOT_PROPS])) {
+      target[STORE_SNAPSHOT_PROPS][property] = base;
+    }
+  }
+  const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
+  const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+  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");
+  const nodes = getNodes(target, STORE_NODE);
+  if (mode === "set") {
+    nodes[property] &&
+      setSignal(nodes[property], () => (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);
+  }
+  nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
 }
 let Writing = null;
 const storeTraps = {
@@ -2808,31 +2878,12 @@ const storeTraps = {
   set(target, property, rawValue) {
     const store = target[$PROXY];
     if (writeOnly(store)) {
-      if (target[STORE_OPTIMISTIC]) {
-        const firewall = target[STORE_FIREWALL];
-        if (firewall?._transition) {
-          globalQueue.initTransition(firewall._transition);
-        }
-      }
       untrack(() => {
-        const state = target[STORE_VALUE];
-        const base = state[property];
-        if (
-          snapshotCaptureActive &&
-          typeof property !== "symbol" &&
-          !((target[STORE_FIREWALL]?._statusFlags ?? 0) & STATUS_PENDING)
-        ) {
-          if (!target[STORE_SNAPSHOT_PROPS]) {
-            target[STORE_SNAPSHOT_PROPS] = Object.create(null);
-            snapshotSources?.add(target);
-          }
-          if (!(property in target[STORE_SNAPSHOT_PROPS])) {
-            target[STORE_SNAPSHOT_PROPS][property] = base;
-          }
-        }
-        const useOptimistic = target[STORE_OPTIMISTIC] && !projectionWriteActive;
-        const overrideKey = useOptimistic ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-        if (useOptimistic) trackOptimisticStore(store);
+        const {
+          base: base,
+          overrideKey: overrideKey,
+          state: state
+        } = prepareStoreWrite(target, store, property);
         const prev =
           target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]
             ? target[STORE_OPTIMISTIC_OVERRIDE][property]
@@ -2858,21 +2909,46 @@ const storeTraps = {
           override[property] = value;
           if (nextLength !== undefined) override.length = nextLength;
         }
-        const wrappable = isWrappable(value);
-        target[STORE_HAS]?.[property] && setSignal(target[STORE_HAS][property], true);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] &&
-          setSignal(nodes[property], () => (wrappable ? wrap(value, target) : value));
+        notifyStoreProperty(target, property, "set", value);
         if (Array.isArray(state)) {
+          const nodes = getNodes(target, STORE_NODE);
           const lengthValue = property === "length" ? value : nextLength;
           lengthValue !== undefined && nodes.length && setSignal(nodes.length, lengthValue);
         }
-        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
         if (true) DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, value, prev);
       });
     }
     return true;
   },
+  defineProperty(target, property, descriptor) {
+    const store = target[$PROXY];
+    if (writeOnly(store)) {
+      untrack(() => {
+        const { base: base, overrideKey: overrideKey } = prepareStoreWrite(target, store, property);
+        const normalizedDescriptor =
+          "value" in descriptor
+            ? {
+                ...descriptor,
+                value: descriptor.value?.[$TARGET]?.[STORE_VALUE] ?? descriptor.value
+              }
+            : descriptor;
+        Object.defineProperty(
+          target[overrideKey] || (target[overrideKey] = Object.create(null)),
+          property,
+          normalizedDescriptor
+        );
+        notifyStoreProperty(target, property, "invalidate");
+        if (true) {
+          const next =
+            "value" in normalizedDescriptor
+              ? normalizedDescriptor.value
+              : normalizedDescriptor.get?.call(store);
+          DEV$1.hooks.onStoreNodeUpdate?.(target[$PROXY], property, next, base);
+        }
+      });
+    }
+    return true;
+  },
   deleteProperty(target, property) {
     const optDeleted = target[STORE_OPTIMISTIC_OVERRIDE]?.[property] === $DELETED;
     const regDeleted = target[STORE_OVERRIDE]?.[property] === $DELETED;
@@ -2895,10 +2971,7 @@ const storeTraps = {
         } else if (target[overrideKey] && property in target[overrideKey]) {
           delete target[overrideKey][property];
         } else return true;
-        if (target[STORE_HAS]?.[property]) setSignal(target[STORE_HAS][property], false);
-        const nodes = getNodes(target, STORE_NODE);
-        nodes[property] && setSignal(nodes[property], undefined);
-        nodes[$TRACK] && setSignal(nodes[$TRACK], undefined);
+        notifyStoreProperty(target, property, "delete");
       });
     }
     return true;
@@ -2920,6 +2993,8 @@ const storeTraps = {
     if (property === $PROXY) return { value: target[$PROXY], writable: true, configurable: true };
     if (target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE]) {
       if (target[STORE_OPTIMISTIC_OVERRIDE][property] === $DELETED) return undefined;
+      const optDesc = Reflect.getOwnPropertyDescriptor(target[STORE_OPTIMISTIC_OVERRIDE], property);
+      if (optDesc?.get || optDesc?.set || !(property in target[STORE_VALUE])) return optDesc;
       const baseDesc = getPropertyDescriptor(target[STORE_VALUE], target[STORE_OVERRIDE], property);
       if (baseDesc) {
         return { ...baseDesc, value: target[STORE_OPTIMISTIC_OVERRIDE][property] };
@@ -2969,7 +3044,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)];
@@ -3003,7 +3078,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 => {
@@ -3113,7 +3188,12 @@ function updatePath(current, args, i = 0) {
   ) {
     const target = part !== undefined ? current[part] : current;
     const keys = Object.keys(value);
-    for (let i = 0; i < keys.length; i++) target[keys[i]] = value[keys[i]];
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const desc = Object.getOwnPropertyDescriptor(value, key);
+      if (desc.get || desc.set) Object.defineProperty(target, key, desc);
+      else target[key] = desc.value;
+    }
   } else {
     current[part] = value;
   }
@@ -3329,7 +3409,7 @@ function mapArray(list, map, options) {
         }
       }
     : map;
-  return createMemo(
+  const node = computed(
     updateKeyedMap.bind({
       _owner: createOwner(),
       _len: 0,
@@ -3344,8 +3424,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;
@@ -3482,17 +3564,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();
@@ -3595,8 +3681,8 @@ class RevealController {
   _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;
   _evaluating = false;
   constructor(together, collapsed) {
@@ -3619,8 +3705,8 @@ class RevealController {
     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));
+    (setSignal(slot._disabled, true),
+      setSignal(slot._collapsed, together ? false : !!untrack(this._collapsedAccessor)));
     untrack(() => this.evaluate());
   }
   unregister(slot) {
@@ -3662,8 +3748,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;
@@ -3779,7 +3865,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);