@solidjs/signals 0.13.13 → 2.0.0-beta.11

package/dist/dev.js

@@ -35,6 +35,14 @@ const REACTIVE_DISPOSED = 1 << 6;
 const REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
 const REACTIVE_SNAPSHOT_STALE = 1 << 8;
 const REACTIVE_LAZY = 1 << 9;
+const REACTIVE_MANUAL_WRITE = 1 << 10;
+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 CONFIG_SYNC = 1 << 6;
 const STATUS_PENDING = 1 << 0;
 const STATUS_ERROR = 1 << 1;
 const STATUS_UNINITIALIZED = 1 << 2;
@@ -47,6 +55,91 @@ const STORE_SNAPSHOT_PROPS = "sp";
 const SUPPORTS_PROXY = typeof Proxy === "function";
 const defaultContext = {};
 const $REFRESH = Symbol("refresh");
+const hooks = {};
+const diagnosticListeners = new Set();
+const diagnosticCaptures = new Set();
+let diagnosticSequence = 0;
+const diagnostics = {
+  subscribe(listener) {
+    diagnosticListeners.add(listener);
+    return () => diagnosticListeners.delete(listener);
+  },
+  capture() {
+    const events = [];
+    diagnosticCaptures.add(events);
+    return {
+      get events() {
+        return events;
+      },
+      clear() {
+        events.length = 0;
+      },
+      stop() {
+        diagnosticCaptures.delete(events);
+        return [...events];
+      }
+    };
+  }
+};
+const DEV$1 = {
+  hooks: hooks,
+  diagnostics: diagnostics,
+  getChildren: getChildren,
+  getSignals: getSignals,
+  getParent: getParent,
+  getSources: getSources,
+  getObservers: getObservers
+};
+function emitDiagnostic(event) {
+  const entry = { sequence: ++diagnosticSequence, ...event };
+  for (const listener of diagnosticListeners) listener(entry);
+  for (const capture of diagnosticCaptures) capture.push(entry);
+  return entry;
+}
+function registerGraph(value, owner) {
+  value._owner = owner;
+  if (owner) {
+    if (!owner._signals) owner._signals = [];
+    owner._signals.push(value);
+  }
+  DEV$1.hooks.onGraph?.(value, owner);
+}
+function clearSignals(node) {
+  node._signals = undefined;
+}
+function getChildren(owner) {
+  const children = [];
+  let child = owner._firstChild;
+  while (child) {
+    children.push(child);
+    child = child._nextSibling;
+  }
+  return children;
+}
+function getSignals(owner) {
+  return owner._signals ? [...owner._signals] : [];
+}
+function getParent(owner) {
+  return owner._parent;
+}
+function getSources(computation) {
+  const sources = [];
+  let link = computation._deps;
+  while (link) {
+    sources.push(link._dep);
+    link = link._nextDep;
+  }
+  return sources;
+}
+function getObservers(node) {
+  const observers = [];
+  let link = node._subs;
+  while (link) {
+    observers.push(link._sub);
+    link = link._nextSub;
+  }
+  return observers;
+}
 function actualInsertIntoHeap(n, heap) {
   const parentHeight =
     (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
@@ -64,7 +157,7 @@ function actualInsertIntoHeap(n, heap) {
 }
 function insertIntoHeap(n, heap) {
   let flags = n._flags;
-  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
   if (flags & REACTIVE_CHECK) {
     n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
   } else n._flags = flags | REACTIVE_IN_HEAP;
@@ -72,7 +165,11 @@ function insertIntoHeap(n, heap) {
 }
 function insertIntoHeapHeight(n, heap) {
   let flags = n._flags;
-  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  if (
+    flags &
+    (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)
+  )
+    return;
   n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
   actualInsertIntoHeap(n, heap);
 }
@@ -144,90 +241,76 @@ function adjustHeight(el, heap) {
     }
   }
 }
-const hooks = {};
-const diagnosticListeners = new Set();
-const diagnosticCaptures = new Set();
-let diagnosticSequence = 0;
-const diagnostics = {
-  subscribe(listener) {
-    diagnosticListeners.add(listener);
-    return () => diagnosticListeners.delete(listener);
-  },
-  capture() {
-    const events = [];
-    diagnosticCaptures.add(events);
-    return {
-      get events() {
-        return events;
-      },
-      clear() {
-        events.length = 0;
-      },
-      stop() {
-        diagnosticCaptures.delete(events);
-        return [...events];
-      }
-    };
-  }
-};
-const DEV$1 = {
-  hooks: hooks,
-  diagnostics: diagnostics,
-  getChildren: getChildren,
-  getSignals: getSignals,
-  getParent: getParent,
-  getSources: getSources,
-  getObservers: getObservers
-};
-function emitDiagnostic(event) {
-  const entry = { sequence: ++diagnosticSequence, ...event };
-  for (const listener of diagnosticListeners) listener(entry);
-  for (const capture of diagnosticCaptures) capture.push(entry);
-  return entry;
-}
-function registerGraph(value, owner) {
-  value._owner = owner;
-  if (owner) {
-    if (!owner._signals) owner._signals = [];
-    owner._signals.push(value);
+const signalLanes = new WeakMap();
+const activeLanes = new Set();
+function getOrCreateLane(signal) {
+  let lane = signalLanes.get(signal);
+  if (lane) {
+    return findLane(lane);
   }
-  DEV$1.hooks.onGraph?.(value, owner);
+  const parentSource = signal._parentSource;
+  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
+  lane = {
+    _source: signal,
+    _pendingAsync: new Set(),
+    _effectQueues: [[], []],
+    _mergedInto: null,
+    _transition: activeTransition,
+    _parentLane: parentLane
+  };
+  signalLanes.set(signal, lane);
+  activeLanes.add(lane);
+  signal._overrideSinceLane = false;
+  return lane;
 }
-function clearSignals(node) {
-  node._signals = undefined;
+function findLane(lane) {
+  while (lane._mergedInto) lane = lane._mergedInto;
+  return lane;
 }
-function getChildren(owner) {
-  const children = [];
-  let child = owner._firstChild;
-  while (child) {
-    children.push(child);
-    child = child._nextSibling;
-  }
-  return children;
+function mergeLanes(lane1, lane2) {
+  lane1 = findLane(lane1);
+  lane2 = findLane(lane2);
+  if (lane1 === lane2) return lane1;
+  lane2._mergedInto = lane1;
+  for (const node of lane2._pendingAsync) lane1._pendingAsync.add(node);
+  lane1._effectQueues[0].push(...lane2._effectQueues[0]);
+  lane1._effectQueues[1].push(...lane2._effectQueues[1]);
+  return lane1;
 }
-function getSignals(owner) {
-  return owner._signals ? [...owner._signals] : [];
+function resolveLane(el) {
+  const lane = el._optimisticLane;
+  if (!lane) return undefined;
+  const root = findLane(lane);
+  if (activeLanes.has(root)) return root;
+  el._optimisticLane = undefined;
+  return undefined;
 }
-function getParent(owner) {
-  return owner._parent;
+function resolveTransition(el) {
+  return resolveLane(el)?._transition ?? el._transition;
 }
-function getSources(computation) {
-  const sources = [];
-  let link = computation._deps;
-  while (link) {
-    sources.push(link._dep);
-    link = link._nextDep;
-  }
-  return sources;
+function hasActiveOverride(el) {
+  return !!(el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING);
 }
-function getObservers(node) {
-  const observers = [];
-  let link = node._subs;
-  while (link) {
-    observers.push(link._sub);
-    link = link._nextSub;
+function assignOrMergeLane(el, sourceLane) {
+  const sourceRoot = findLane(sourceLane);
+  const existing = el._optimisticLane;
+  if (existing) {
+    if (existing._mergedInto) {
+      el._optimisticLane = sourceLane;
+      return;
+    }
+    const existingRoot = findLane(existing);
+    if (activeLanes.has(existingRoot)) {
+      if (existingRoot !== sourceRoot && !hasActiveOverride(el)) {
+        if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
+          el._optimisticLane = sourceLane;
+        } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot);
+        else mergeLanes(sourceRoot, existingRoot);
+      }
+      return;
+    }
   }
-  return observers;
+  el._optimisticLane = sourceLane;
 }
 const transitions = new Set();
 const dirtyQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _min: 0, _max: 0 };
@@ -235,11 +318,39 @@ const zombieQueue = { _heap: new Array(2e3).fill(undefined), _marked: false, _mi
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
+let syncDepth = 0;
 let projectionWriteActive = false;
 let inTrackedQueueCallback = false;
 let _enforceLoadingBoundary = false;
 let _hitUnhandledAsync = false;
 let stashedOptimisticReads = null;
+const transientStoreNodes = new Set();
+function registerTransientStoreNode(node) {
+  transientStoreNodes.add(node);
+}
+function canUseSimpleSyncFlush(queue) {
+  return (
+    transitions.size === 0 &&
+    activeLanes.size === 0 &&
+    queue._children.length === 0 &&
+    queue._optimisticNodes.length === 0 &&
+    queue._optimisticStores.size === 0 &&
+    transientStoreNodes.size === 0
+  );
+}
+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;
 }
@@ -292,6 +403,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++) {
@@ -329,7 +441,7 @@ function cleanupCompletedLanes(completingTransition) {
 function schedule() {
   if (scheduled) return;
   scheduled = true;
-  if (!globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
+  if (!syncDepth && !globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
 }
 class Queue {
   _parent = null;
@@ -396,11 +508,13 @@ class Queue {
 }
 class GlobalQueue extends Queue {
   _running = false;
+  _pendingNode = null;
   _pendingNodes = [];
   _optimisticNodes = [];
   _optimisticStores = new Set();
   static _update;
   static _dispose;
+  static _runEffect;
   static _clearOptimisticStore = null;
   flush() {
     if (this._running) return;
@@ -412,6 +526,7 @@ class GlobalQueue extends Queue {
         if (!isComplete) {
           const stashedTransition = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
+          this._pendingNode = null;
           this._pendingNodes = [];
           this._optimisticNodes = [];
           this._optimisticStores = new Set();
@@ -422,11 +537,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._pureWrite) continue;
+              if (node._fn || node._config & CONFIG_OWNED_WRITE) continue;
               stashedOptimisticReads.add(node);
               queueStashedOptimisticEffects(node);
             }
@@ -447,14 +566,22 @@ class GlobalQueue extends Queue {
         reassignPendingTransition(this._pendingNodes);
         finalizePureQueue(completingTransition);
       } else {
-        if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
-        finalizePureQueue();
+        if (canUseSimpleSyncFlush(this)) {
+          commitPendingNodes();
+          if (dirtyQueue._max >= dirtyQueue._min) {
+            runHeap(dirtyQueue, GlobalQueue._update);
+            commitPendingNodes();
+          }
+        } else {
+          if (transitions.size) runHeap(zombieQueue, GlobalQueue._update);
+          finalizePureQueue();
+        }
       }
       clock++;
       scheduled = dirtyQueue._max >= dirtyQueue._min;
-      runLaneEffects(EFFECT_RENDER);
+      activeLanes.size && runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
-      runLaneEffects(EFFECT_USER);
+      activeLanes.size && runLaneEffects(EFFECT_USER);
       this.run(EFFECT_USER);
       if (true) DEV$1.hooks.onUpdate?.();
     } finally {
@@ -492,7 +619,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;
@@ -502,6 +630,11 @@ class GlobalQueue extends Queue {
     }
     transitions.add(activeTransition);
     activeTransition._time = clock;
+    if (this._pendingNode !== null) {
+      this._pendingNode._transition = activeTransition;
+      activeTransition._pendingNodes.push(this._pendingNode);
+      this._pendingNode = null;
+    }
     if (this._pendingNodes !== activeTransition._pendingNodes) {
       for (let i = 0; i < this._pendingNodes.length; i++) {
         const node = this._pendingNodes[i];
@@ -527,11 +660,26 @@ class GlobalQueue extends Queue {
     }
   }
 }
+function queuePendingNode(node) {
+  if (activeTransition) {
+    globalQueue._pendingNodes.push(node);
+    return;
+  }
+  if (globalQueue._pendingNode === null && globalQueue._pendingNodes.length === 0) {
+    globalQueue._pendingNode = node;
+    return;
+  }
+  if (globalQueue._pendingNode !== null) {
+    globalQueue._pendingNodes.push(globalQueue._pendingNode);
+    globalQueue._pendingNode = null;
+  }
+  globalQueue._pendingNodes.push(node);
+}
 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;
     }
@@ -555,30 +703,63 @@ function insertSubs(node, optimistic = false) {
     insertIntoHeap(s._sub, queue);
   }
 }
-function commitPendingNodes() {
-  const pendingNodes = globalQueue._pendingNodes;
-  for (let i = 0; i < pendingNodes.length; i++) {
-    const n = pendingNodes[i];
+function commitPendingNode(n) {
+  const c = n;
+  if (!c._fn) {
     if (n._pendingValue !== NOT_PENDING) {
       n._value = n._pendingValue;
       n._pendingValue = NOT_PENDING;
-      if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
     }
-    if (!(n._statusFlags & STATUS_PENDING)) n._statusFlags &= ~STATUS_UNINITIALIZED;
-    if (n._fn) GlobalQueue._dispose(n, false, true);
+    return;
+  }
+  if (n._pendingValue !== NOT_PENDING) {
+    n._value = n._pendingValue;
+    n._pendingValue = NOT_PENDING;
+    if (n._type && n._type !== EFFECT_TRACKED) n._modified = true;
+  }
+  c._flags &= ~REACTIVE_MANUAL_WRITE;
+  if (!(c._statusFlags & STATUS_PENDING)) c._statusFlags &= ~STATUS_UNINITIALIZED;
+  if (c._pendingFirstChild !== null || c._pendingDisposal !== null)
+    GlobalQueue._dispose(c, false, true);
+}
+function commitPendingNodes() {
+  if (globalQueue._pendingNode !== null) {
+    commitPendingNode(globalQueue._pendingNode);
+    globalQueue._pendingNode = null;
+  }
+  const pendingNodes = globalQueue._pendingNodes;
+  for (let i = 0; i < pendingNodes.length; i++) {
+    commitPendingNode(pendingNodes[i]);
   }
   pendingNodes.length = 0;
 }
 function finalizePureQueue(completingTransition = null, incomplete = false) {
   const resolvePending = !incomplete;
   if (resolvePending) commitPendingNodes();
-  if (!incomplete) checkBoundaryChildren(globalQueue);
-  if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
+  if (!incomplete && globalQueue._children.length) checkBoundaryChildren(globalQueue);
+  const ranHeap = dirtyQueue._max >= dirtyQueue._min;
+  if (ranHeap) runHeap(dirtyQueue, GlobalQueue._update);
   if (resolvePending) {
-    commitPendingNodes();
+    if (ranHeap) commitPendingNodes();
     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;
@@ -589,6 +770,7 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
       optimisticStores.clear();
       schedule();
     }
+    sweepTransientStoreNodes();
     cleanupCompletedLanes(completingTransition);
   }
 }
@@ -608,7 +790,16 @@ function reassignPendingTransition(pendingNodes) {
   }
 }
 const globalQueue = new GlobalQueue();
-function flush() {
+function flush(fn) {
+  if (fn) {
+    syncDepth++;
+    try {
+      return fn();
+    } finally {
+      flush();
+      syncDepth--;
+    }
+  }
   if (globalQueue._running) {
     if (inTrackedQueueCallback) {
       throw new Error(
@@ -673,160 +864,27 @@ function transitionComplete(transition) {
       ) {
         done = false;
         break;
-      }
-    }
-  }
-  done && (transition._done = true);
-  return done;
-}
-function currentTransition(transition) {
-  while (transition._done && typeof transition._done === "object") transition = transition._done;
-  return transition;
-}
-function setActiveTransition(transition) {
-  activeTransition = transition;
-}
-function runInTransition(transition, fn) {
-  const prevTransition = activeTransition;
-  try {
-    activeTransition = currentTransition(transition);
-    return fn();
-  } finally {
-    activeTransition = prevTransition;
-  }
-}
-const signalLanes = new WeakMap();
-const activeLanes = new Set();
-function getOrCreateLane(signal) {
-  let lane = signalLanes.get(signal);
-  if (lane) {
-    return findLane(lane);
-  }
-  const parentSource = signal._parentSource;
-  const parentLane = parentSource?._optimisticLane ? findLane(parentSource._optimisticLane) : null;
-  lane = {
-    _source: signal,
-    _pendingAsync: new Set(),
-    _effectQueues: [[], []],
-    _mergedInto: null,
-    _transition: activeTransition,
-    _parentLane: parentLane
-  };
-  signalLanes.set(signal, lane);
-  activeLanes.add(lane);
-  signal._overrideSinceLane = false;
-  return lane;
-}
-function findLane(lane) {
-  while (lane._mergedInto) lane = lane._mergedInto;
-  return lane;
-}
-function mergeLanes(lane1, lane2) {
-  lane1 = findLane(lane1);
-  lane2 = findLane(lane2);
-  if (lane1 === lane2) return lane1;
-  lane2._mergedInto = lane1;
-  for (const node of lane2._pendingAsync) lane1._pendingAsync.add(node);
-  lane1._effectQueues[0].push(...lane2._effectQueues[0]);
-  lane1._effectQueues[1].push(...lane2._effectQueues[1]);
-  return lane1;
-}
-function resolveLane(el) {
-  const lane = el._optimisticLane;
-  if (!lane) return undefined;
-  const root = findLane(lane);
-  if (activeLanes.has(root)) return root;
-  el._optimisticLane = undefined;
-  return undefined;
-}
-function resolveTransition(el) {
-  return resolveLane(el)?._transition ?? el._transition;
-}
-function hasActiveOverride(el) {
-  return !!(el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING);
-}
-function assignOrMergeLane(el, sourceLane) {
-  const sourceRoot = findLane(sourceLane);
-  const existing = el._optimisticLane;
-  if (existing) {
-    if (existing._mergedInto) {
-      el._optimisticLane = sourceLane;
-      return;
-    }
-    const existingRoot = findLane(existing);
-    if (activeLanes.has(existingRoot)) {
-      if (existingRoot !== sourceRoot && !hasActiveOverride(el)) {
-        if (sourceRoot._parentLane && findLane(sourceRoot._parentLane) === existingRoot) {
-          el._optimisticLane = sourceLane;
-        } else if (existingRoot._parentLane && findLane(existingRoot._parentLane) === sourceRoot);
-        else mergeLanes(sourceRoot, existingRoot);
-      }
-      return;
-    }
-  }
-  el._optimisticLane = sourceLane;
-}
-function unlinkSubs(link) {
-  const dep = link._dep;
-  const nextDep = link._nextDep;
-  const nextSub = link._nextSub;
-  const prevSub = link._prevSub;
-  if (nextSub !== null) nextSub._prevSub = prevSub;
-  else dep._subsTail = prevSub;
-  if (prevSub !== null) prevSub._nextSub = nextSub;
-  else {
-    dep._subs = nextSub;
-    if (nextSub === null) {
-      dep._unobserved?.();
-      dep._fn && !dep._preventAutoDisposal && !(dep._flags & REACTIVE_ZOMBIE) && unobserved(dep);
+      }
     }
   }
-  return nextDep;
+  done && (transition._done = true);
+  return done;
 }
-function unobserved(el) {
-  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
-  let dep = el._deps;
-  while (dep !== null) {
-    dep = unlinkSubs(dep);
-  }
-  el._deps = null;
-  disposeChildren(el, true);
+function currentTransition(transition) {
+  while (transition._done && typeof transition._done === "object") transition = transition._done;
+  return transition;
 }
-function link(dep, sub) {
-  const prevDep = sub._depsTail;
-  if (prevDep !== null && prevDep._dep === dep) return;
-  let nextDep = null;
-  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
-  if (isRecomputing) {
-    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
-    if (nextDep !== null && nextDep._dep === dep) {
-      sub._depsTail = nextDep;
-      return;
-    }
-  }
-  const prevSub = dep._subsTail;
-  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
-    return;
-  const newLink =
-    (sub._depsTail =
-    dep._subsTail =
-      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
-  if (prevDep !== null) prevDep._nextDep = newLink;
-  else sub._deps = newLink;
-  if (prevSub !== null) prevSub._nextSub = newLink;
-  else dep._subs = newLink;
+function setActiveTransition(transition) {
+  activeTransition = transition;
 }
-function isValidLink(checkLink, sub) {
-  const depsTail = sub._depsTail;
-  if (depsTail !== null) {
-    let link = sub._deps;
-    do {
-      if (link === checkLink) return true;
-      if (link === depsTail) break;
-      link = link._nextDep;
-    } while (link !== null);
+function runInTransition(transition, fn) {
+  const prevTransition = activeTransition;
+  try {
+    activeTransition = currentTransition(transition);
+    return fn();
+  } finally {
+    activeTransition = prevTransition;
   }
-  return false;
 }
 const PENDING_OWNER = {};
 function markDisposal(el) {
@@ -851,8 +909,9 @@ function dispose(node) {
   disposeChildren(node, true);
 }
 function disposeChildren(node, self = false, zombie) {
-  if (node._flags & REACTIVE_DISPOSED) return;
-  if (self) node._flags = REACTIVE_DISPOSED;
+  const flags = node._flags;
+  if (flags & REACTIVE_DISPOSED) return;
+  if (self) node._flags = flags | REACTIVE_DISPOSED;
   if (self && true) clearSignals(node);
   if (self && node._fn) node._inFlight = null;
   let child = zombie ? node._pendingFirstChild : node._firstChild;
@@ -877,6 +936,20 @@ function disposeChildren(node, self = false, zombie) {
     node._firstChild = null;
     node._childCount = 0;
   }
+  if (
+    self &&
+    !zombie &&
+    !(flags & REACTIVE_ZOMBIE) &&
+    node._parent !== null &&
+    !(node._parent._flags & REACTIVE_DISPOSED)
+  ) {
+    const prev = node._prevSibling;
+    const next = node._nextSibling;
+    if (prev !== null) prev._nextSibling = next;
+    else node._parent._firstChild = next;
+    if (next !== null) next._prevSibling = prev;
+    node._prevSibling = null;
+  }
   runDisposal(node, zombie);
 }
 function runDisposal(node, zombie) {
@@ -894,7 +967,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");
@@ -927,6 +1000,9 @@ function cleanup(fn) {
 function isDisposed(node) {
   return !!(node._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
+function disposeRootSelf(self = true) {
+  disposeChildren(this, self);
+}
 function createOwner(options) {
   const parent = context;
   const transparent = options?.transparent ?? false;
@@ -934,11 +1010,12 @@ 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,
     _nextSibling: null,
+    _prevSibling: null,
     _disposal: null,
     _queue: parent?._queue ?? globalQueue,
     _context: parent?._context || defaultContext,
@@ -946,14 +1023,18 @@ function createOwner(options) {
     _pendingDisposal: null,
     _pendingFirstChild: null,
     _parent: parent,
-    dispose(self = true) {
-      disposeChildren(owner, self);
-    }
+    dispose: disposeRootSelf
   };
-  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;
@@ -961,6 +1042,7 @@ function createOwner(options) {
       parent._firstChild = owner;
     } else {
       owner._nextSibling = lastChild;
+      lastChild._prevSibling = owner;
       parent._firstChild = owner;
     }
   }
@@ -969,7 +1051,82 @@ function createOwner(options) {
 }
 function createRoot(init, options) {
   const owner = createOwner(options);
-  return runWithOwner(owner, () => init(owner.dispose));
+  return runWithOwner(owner, () => init(() => owner.dispose()));
+}
+function unlinkSubs(link) {
+  const dep = link._dep;
+  const nextDep = link._nextDep;
+  const nextSub = link._nextSub;
+  const prevSub = link._prevSub;
+  if (nextSub !== null) nextSub._prevSub = prevSub;
+  else dep._subsTail = prevSub;
+  if (prevSub !== null) prevSub._nextSub = nextSub;
+  else {
+    dep._subs = nextSub;
+    if (nextSub === null) {
+      dep._unobserved?.();
+      const c = dep;
+      c._fn && c._config & CONFIG_AUTO_DISPOSE && !(c._flags & REACTIVE_ZOMBIE) && unobserved(c);
+    }
+  }
+  return nextDep;
+}
+function trimStaleDeps(el) {
+  const depsTail = el._depsTail;
+  let toRemove = depsTail !== null ? depsTail._nextDep : el._deps;
+  if (toRemove !== null) {
+    do {
+      toRemove = unlinkSubs(toRemove);
+    } while (toRemove !== null);
+    if (depsTail !== null) depsTail._nextDep = null;
+    else el._deps = null;
+  }
+}
+function unobserved(el) {
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let dep = el._deps;
+  while (dep !== null) {
+    dep = unlinkSubs(dep);
+  }
+  el._deps = null;
+  el._depsTail = null;
+  disposeChildren(el, true);
+}
+function link(dep, sub) {
+  const prevDep = sub._depsTail;
+  if (prevDep !== null && prevDep._dep === dep) return;
+  let nextDep = null;
+  const isRecomputing = sub._flags & REACTIVE_RECOMPUTING_DEPS;
+  if (isRecomputing) {
+    nextDep = prevDep !== null ? prevDep._nextDep : sub._deps;
+    if (nextDep !== null && nextDep._dep === dep) {
+      sub._depsTail = nextDep;
+      return;
+    }
+  }
+  const prevSub = dep._subsTail;
+  if (prevSub !== null && prevSub._sub === sub && (!isRecomputing || isValidLink(prevSub, sub)))
+    return;
+  const newLink =
+    (sub._depsTail =
+    dep._subsTail =
+      { _dep: dep, _sub: sub, _nextDep: nextDep, _prevSub: prevSub, _nextSub: null });
+  if (prevDep !== null) prevDep._nextDep = newLink;
+  else sub._deps = newLink;
+  if (prevSub !== null) prevSub._nextSub = newLink;
+  else dep._subs = newLink;
+}
+function isValidLink(checkLink, sub) {
+  const depsTail = sub._depsTail;
+  if (depsTail !== null) {
+    let link = sub._deps;
+    do {
+      if (link === checkLink) return true;
+      if (link === depsTail) break;
+      link = link._nextDep;
+    } while (link !== null);
+  }
+  return false;
 }
 function addPendingSource(el, source) {
   if (el._pendingSource === source || el._pendingSources?.has(source)) return false;
@@ -1062,13 +1219,34 @@ function settlePendingSource(el) {
   if (scheduled) schedule();
 }
 function handleAsync(el, result, setter) {
-  const isObject = typeof result === "object" && result !== null;
-  const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
-  const isThenable = !iterator && isObject && untrack(() => typeof result.then === "function");
+  let iterator = false;
+  let isThenable = false;
+  if (typeof result === "object" && result !== null) {
+    untrack(() => {
+      iterator = result[Symbol.asyncIterator];
+      isThenable = !iterator && typeof result.then === "function";
+    });
+  }
   if (!isThenable && !iterator) {
     el._inFlight = null;
     return result;
   }
+  if (el._config & CONFIG_SYNC) {
+    const message =
+      `[SYNC_NODE_RECEIVED_ASYNC] A computed/effect created with \`sync: true\` returned ` +
+      `${isThenable ? "a Promise" : "an AsyncIterable"}. The value would be stored as-is and ` +
+      `never awaited in production; remove \`sync: true\` to use async-aware behavior, or ` +
+      `unwrap the value before returning.`;
+    emitDiagnostic({
+      code: "SYNC_NODE_RECEIVED_ASYNC",
+      kind: "lifecycle",
+      severity: "error",
+      message: message,
+      ownerId: el.id,
+      ownerName: el._name
+    });
+    throw new Error(message);
+  }
   el._inFlight = result;
   let syncValue;
   const handleError = error => {
@@ -1082,6 +1260,7 @@ function handleAsync(el, result, setter) {
     if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
     globalQueue.initTransition(resolveTransition(el));
     const wasUninitialized = !!(el._statusFlags & STATUS_UNINITIALIZED);
+    trimStaleDeps(el);
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
@@ -1191,12 +1370,12 @@ function handleAsync(el, result, setter) {
   return syncValue;
 }
 function clearStatus(el, clearUninitialized = false) {
-  clearPendingSources(el);
-  el._blocked = false;
+  if (el._pendingSource || el._pendingSources) clearPendingSources(el);
+  if (el._blocked) el._blocked = false;
   el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
-  setPendingError(el);
-  updatePendingSignal(el);
-  el._notifyStatus?.();
+  if (el._error) setPendingError(el);
+  if (el._pendingSignal) updatePendingSignal(el);
+  if (el._notifyStatus) el._notifyStatus();
 }
 function notifyStatus(el, status, error, blockStatus, lane) {
   if (
@@ -1250,7 +1429,7 @@ function notifyStatus(el, status, error, blockStatus, lane) {
       (status !== STATUS_PENDING &&
         (sub._error !== error || sub._pendingSource || sub._pendingSources))
     ) {
-      if (!downstreamBlockStatus && !sub._transition) globalQueue._pendingNodes.push(sub);
+      if (!downstreamBlockStatus && !sub._transition) queuePendingNode(sub);
       notifyStatus(sub, status, error, downstreamBlockStatus, downstreamLane);
     }
   });
@@ -1280,6 +1459,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;
@@ -1318,7 +1499,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;
@@ -1348,7 +1529,7 @@ function recompute(el, create = false) {
     deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
     el._inFlight = null;
     if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
-    else {
+    else if (el._firstChild !== null || el._disposal !== null) {
       markDisposal(el);
       el._pendingDisposal = el._disposal;
       el._pendingFirstChild = el._firstChild;
@@ -1356,9 +1537,9 @@ function recompute(el, create = false) {
       el._firstChild = null;
       el._childCount = 0;
       clearSignals(el);
-    }
+    } else 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);
@@ -1380,14 +1561,41 @@ 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;
+        }
+      }
+    }
   }
+  const isStaleEffect = isEffect && isEffect !== EFFECT_USER;
+  const prevStale = stale;
+  if (isStaleEffect) stale = true;
   try {
-    value = handleAsync(el, el._fn(value));
+    if (!true && el._config & CONFIG_SYNC);
+    else {
+      const prevInFlight = el._inFlight;
+      const fnResult = el._fn(value);
+      const isAsyncResult = typeof fnResult === "object" && fnResult !== null;
+      const inFlightChanged = el._inFlight !== prevInFlight;
+      value = inFlightChanged || !isAsyncResult ? fnResult : handleAsync(el, fnResult);
+      if (!inFlightChanged && !isAsyncResult) el._inFlight = null;
+    }
     clearStatus(el, create);
-    const resolvedLane = resolveLane(el);
-    if (resolvedLane) {
-      resolvedLane._pendingAsync.delete(el);
-      updatePendingSignal(resolvedLane._source);
+    if (el._optimisticLane) {
+      const resolvedLane = resolveLane(el);
+      if (resolvedLane) {
+        resolvedLane._pendingAsync.delete(el);
+        updatePendingSignal(resolvedLane._source);
+      }
     }
   } catch (e) {
     if (e instanceof NotReadyError && currentOptimisticLane) {
@@ -1409,19 +1617,12 @@ function recompute(el, create = false) {
   } finally {
     tracking = prevTracking;
     strictRead = prevStrictRead;
+    if (isStaleEffect) stale = prevStale;
     el._flags = REACTIVE_NONE | (create ? el._flags & REACTIVE_SNAPSHOT_STALE : 0);
     context = oldcontext;
   }
   if (!el._error) {
-    const depsTail = el._depsTail;
-    let toRemove = depsTail !== null ? depsTail._nextDep : el._deps;
-    if (toRemove !== null) {
-      do {
-        toRemove = unlinkSubs(toRemove);
-      } while (toRemove !== null);
-      if (depsTail !== null) depsTail._nextDep = null;
-      else el._deps = null;
-    }
+    trimStaleDeps(el);
     const compareValue = hasOverride
       ? el._overrideValue
       : el._pendingValue === NOT_PENDING
@@ -1429,6 +1630,10 @@ function recompute(el, create = false) {
         : el._pendingValue;
     const valueChanged =
       (!isEffect && wasUninitialized) || !el._equals || !el._equals(compareValue, value);
+    if (isEffect && valueChanged) {
+      el._modified = !el._error;
+      if (!create) el._queue.enqueue(isEffect, GlobalQueue._runEffect.bind(null, el));
+    }
     if (valueChanged) {
       const prevVisible = hasOverride ? el._overrideValue : undefined;
       if (create || (isEffect && activeTransition !== el._transition) || isOptimisticDirty) {
@@ -1451,10 +1656,16 @@ function recompute(el, create = false) {
     }
   }
   currentOptimisticLane = prevLane;
-  (!create || el._statusFlags & STATUS_PENDING) &&
+  const needsPendingCommit =
+    el._pendingValue !== NOT_PENDING ||
+    el._pendingFirstChild !== null ||
+    el._pendingDisposal !== null ||
+    !!(el._statusFlags & (STATUS_PENDING | STATUS_UNINITIALIZED));
+  needsPendingCommit &&
+    (!create || el._statusFlags & STATUS_PENDING) &&
     !el._transition &&
     !(activeTransition && hasOverride) &&
-    globalQueue._pendingNodes.push(el);
+    queuePendingNode(el);
   el._transition &&
     isEffect &&
     activeTransition !== el._transition &&
@@ -1481,22 +1692,26 @@ 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:
       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) |
+      (options?.sync ? CONFIG_SYNC : 0) |
+      (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
     _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,
@@ -1507,6 +1722,7 @@ function computed(fn, initialValue, options) {
     _subsTail: null,
     _parent: context,
     _nextSibling: null,
+    _prevSibling: null,
     _firstChild: null,
     _flags: options?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
     _statusFlags: STATUS_UNINITIALIZED,
@@ -1518,12 +1734,75 @@ function computed(fn, initialValue, options) {
     _transition: null
   };
   self._name = options?.name ?? "computed";
+  setupComputedNode(self, options);
+  return self;
+}
+function createEffectNode(fn, effectFn, errorFn, type, notifyStatus, options) {
+  const transparent = options?.transparent ?? false;
+  const self = {
+    id:
+      options?.id ??
+      (transparent ? context?.id : context?.id != null ? getNextChildId(context) : undefined),
+    _config:
+      (transparent ? CONFIG_TRANSPARENT : 0) |
+      (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (options?.sync ? CONFIG_SYNC : 0) |
+      (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+    _equals: false,
+    _unobserved: options?.unobserved,
+    _disposal: null,
+    _queue: context?._queue ?? globalQueue,
+    _context: context?._context ?? defaultContext,
+    _childCount: 0,
+    _fn: fn,
+    _value: undefined,
+    _height: 0,
+    _child: null,
+    _nextHeap: undefined,
+    _prevHeap: null,
+    _deps: null,
+    _depsTail: null,
+    _subs: null,
+    _subsTail: null,
+    _parent: context,
+    _nextSibling: null,
+    _prevSibling: null,
+    _firstChild: null,
+    _flags: REACTIVE_LAZY,
+    _statusFlags: STATUS_UNINITIALIZED,
+    _time: clock,
+    _pendingValue: NOT_PENDING,
+    _pendingDisposal: null,
+    _pendingFirstChild: null,
+    _inFlight: null,
+    _transition: null,
+    _modified: false,
+    _prevValue: undefined,
+    _effectFn: effectFn,
+    _errorFn: errorFn,
+    _cleanup: undefined,
+    _cleanupRegistered: false,
+    _type: type,
+    _notifyStatus: notifyStatus
+  };
+  self._name = options?.name ?? "effect";
+  setupComputedNode(self, lazyOptions);
+  return self;
+}
+const lazyOptions = { lazy: true };
+function setupComputedNode(self, options) {
   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;
@@ -1531,14 +1810,14 @@ function computed(fn, initialValue, options) {
       context._firstChild = self;
     } else {
       self._nextSibling = lastChild;
+      lastChild._prevSibling = self;
       context._firstChild = self;
     }
   }
   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, pureWrite: true });
+    const bridgeSignal = signal(undefined, { equals: false, ownedWrite: true });
     const source = externalSourceConfig.factory(self._fn, () => {
       setSignal(bridgeSignal, undefined);
     });
@@ -1555,13 +1834,13 @@ function computed(fn, initialValue, options) {
       snapshotSources.add(self);
     }
   }
-  return self;
 }
 function signal(v, options, firewall = null) {
   const s = {
     _equals: options?.equals != null ? options.equals : isEqual,
-    _pureWrite: !!options?.pureWrite,
-    _noSnapshot: !!options?._noSnapshot,
+    _config:
+      (options?.ownedWrite ? CONFIG_OWNED_WRITE : 0) |
+      (options?._noSnapshot ? CONFIG_NO_SNAPSHOT : 0),
     _unobserved: options?.unobserved,
     _value: v,
     _subs: null,
@@ -1578,7 +1857,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;
@@ -1591,8 +1870,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,15 +1951,33 @@ 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 (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 (
+    !computed._fn &&
+    owner === el &&
+    el._overrideValue === undefined &&
+    el._snapshotValue === undefined &&
+    activeTransition === null &&
+    currentOptimisticLane === null &&
+    !snapshotCaptureActive &&
+    !strictRead
+  ) {
+    if (c && tracking) link(el, c);
+    return !c || el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  }
   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",
@@ -1695,7 +1992,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;
@@ -1712,9 +2008,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",
@@ -1751,7 +2047,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;
@@ -1762,7 +2058,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",
@@ -1780,7 +2076,20 @@ function read(el) {
     if (c && stale && shouldReadStashedOptimisticValue(el)) return el._value;
     return el._overrideValue;
   }
-  return !c ||
+  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 &&
       (el._overrideValue !== undefined ||
         el._optimisticLane ||
@@ -1788,14 +2097,30 @@ 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" &&
+    el._config & CONFIG_AUTO_DISPOSE &&
+    !(owner._statusFlags & STATUS_PENDING) &&
+    !el._subs
+  ) {
+    unobserved(el);
+  }
+  return value;
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !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. " +
-      "Move the write outside or set the `pureWrite` option if this is intentional.";
+      "[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",
       kind: "write",
@@ -1840,10 +2165,10 @@ function setSignal(el, v) {
     el._optimisticLane = lane;
     el._overrideValue = v;
   } else {
-    if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
+    if (el._pendingValue === NOT_PENDING) queuePendingNode(el);
     el._pendingValue = v;
   }
-  updatePendingSignal(el);
+  if (el._pendingSignal) updatePendingSignal(el);
   if (el._latestValueComputed) {
     setSignal(el._latestValueComputed, v);
   }
@@ -1852,10 +2177,21 @@ function setSignal(el, v) {
   schedule();
   return v;
 }
+function suppressComputedRecompute(el) {
+  deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  if (!(el._flags & REACTIVE_MANUAL_WRITE) && el._pendingValue === NOT_PENDING)
+    queuePendingNode(el);
+  el._flags = (el._flags & -4) | REACTIVE_MANUAL_WRITE;
+}
+function setMemo(el, v) {
+  const result = setSignal(el, v);
+  suppressComputedRecompute(el);
+  return result;
+}
 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",
@@ -1879,7 +2215,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;
     }
@@ -1975,15 +2311,26 @@ function isPending(fn) {
     foundPending = prevFoundPending;
   }
 }
-function refresh(fn) {
+function refresh(target) {
   let prevRefreshing = refreshing;
   refreshing = true;
   try {
-    if (typeof fn !== "function") {
-      recompute(fn[$REFRESH]);
-      return fn;
+    const node = target?.[$REFRESH];
+    if (true && !node) {
+      const message =
+        "[INVALID_REFRESH_TARGET] refresh() expects a Solid source accessor or refreshable store. " +
+        "Pass the original source target, not a wrapper function or derived property read.";
+      emitDiagnostic({
+        code: "INVALID_REFRESH_TARGET",
+        kind: "write",
+        severity: "error",
+        message: message
+      });
+      throw new Error(message);
+    }
+    if (node && typeof node._fn === "function" && !(node._flags & REACTIVE_DISPOSED)) {
+      recompute(node);
     }
-    return untrack(fn);
   } finally {
     refreshing = prevRefreshing;
     if (!prevRefreshing) {
@@ -2022,71 +2369,24 @@ function hasContext(context, owner) {
 function isUndefined(value) {
   return typeof value === "undefined";
 }
-function effect(compute, effect, error, initialValue, 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
-    }
+function effect(compute, effect, error, options) {
+  const isUser = !!options?.user;
+  const node = createEffectNode(
+    compute,
+    effect,
+    error,
+    isUser ? EFFECT_USER : EFFECT_RENDER,
+    notifyEffectStatus,
+    options
   );
-  node._prevValue = initialValue;
-  node._effectFn = effect;
-  node._errorFn = error;
-  node._cleanup = undefined;
-  node._type = options?.render ? EFFECT_RENDER : EFFECT_USER;
-  node._notifyStatus = (status, error) => {
-    const actualStatus = status !== undefined ? status : node._statusFlags;
-    const actualError = error !== undefined ? error : node._error;
-    if (actualStatus & STATUS_ERROR) {
-      let err = actualError;
-      node._queue.notify(node, STATUS_PENDING, 0);
-      if (node._type === EFFECT_USER) {
-        try {
-          return node._errorFn
-            ? node._errorFn(err, () => {
-                node._cleanup?.();
-                node._cleanup = undefined;
-              })
-            : console.error(err);
-        } catch (e) {
-          err = e;
-        }
-      }
-      if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw err;
-    } else if (node._type === EFFECT_RENDER) {
-      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;
-      }
-    }
-  };
   recompute(node, true);
   !options?.defer &&
-    (node._type === EFFECT_USER
-      ? node._queue.enqueue(node._type, runEffect.bind(node))
-      : runEffect.call(node));
-  initialized = true;
-  cleanup(() => node._cleanup?.());
+    (node._type === EFFECT_USER || options?.schedule
+      ? node._queue.enqueue(node._type, runEffect.bind(null, node))
+      : runEffect(node));
   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",
@@ -2099,32 +2399,76 @@ function effect(compute, effect, error, initialValue, options) {
     console.warn(message);
   }
 }
-function runEffect() {
-  if (!this._modified || this._flags & REACTIVE_DISPOSED) return;
+function notifyEffectStatus(status, error) {
+  const actualStatus = status !== undefined ? status : this._statusFlags;
+  const actualError = error !== undefined ? error : this._error;
+  if (actualStatus & STATUS_ERROR) {
+    let err = actualError;
+    this._queue.notify(this, STATUS_PENDING, 0);
+    if (this._type === EFFECT_USER) {
+      try {
+        return this._errorFn
+          ? this._errorFn(err, () => {
+              this._cleanup?.();
+              this._cleanup = undefined;
+            })
+          : console.error(err);
+      } catch (e) {
+        err = e;
+      }
+    }
+    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw err;
+  } else if (this._type === EFFECT_RENDER) {
+    this._queue.notify(this, STATUS_PENDING | STATUS_ERROR, actualStatus, actualError);
+    if (_hitUnhandledAsync) {
+      resetUnhandledAsync();
+      if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+        const message =
+          "[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",
+          severity: "warn",
+          message: message,
+          ownerId: this.id,
+          ownerName: this._name
+        });
+        console.warn(message);
+      }
+    }
+  }
+}
+function runEffect(node) {
+  if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
   let prevStrictRead = false;
   {
     prevStrictRead = setStrictRead("an effect callback");
   }
-  this._cleanup?.();
-  this._cleanup = undefined;
+  node._cleanup?.();
+  node._cleanup = undefined;
   try {
-    const cleanup = this._effectFn(this._value, this._prevValue);
-    if (true && cleanup !== undefined && typeof cleanup !== "function") {
+    const nextCleanup = node._effectFn(node._value, node._prevValue);
+    if (true && nextCleanup !== undefined && typeof nextCleanup !== "function") {
       throw new Error(
-        `${this._name || "effect"} callback returned an invalid cleanup value. Return a cleanup function or undefined.`
+        `${node._name || "effect"} callback returned an invalid cleanup value. Return a cleanup function or undefined.`
       );
     }
-    this._cleanup = cleanup;
+    node._cleanup = nextCleanup;
+    if (node._cleanup && !node._cleanupRegistered) {
+      node._cleanupRegistered = true;
+      runWithOwner(node._parent, () => cleanup(() => node._cleanup?.()));
+    }
   } catch (error) {
-    this._error = new StatusError(this, error);
-    this._statusFlags |= STATUS_ERROR;
-    if (!this._queue.notify(this, STATUS_ERROR, STATUS_ERROR)) throw error;
+    node._error = new StatusError(node, error);
+    node._statusFlags |= STATUS_ERROR;
+    if (!node._queue.notify(node, STATUS_ERROR, STATUS_ERROR)) throw error;
   } finally {
     setStrictRead(prevStrictRead);
-    this._prevValue = this._value;
-    this._modified = false;
+    node._prevValue = node._value;
+    node._modified = false;
   }
 }
+GlobalQueue._runEffect = runEffect;
 function trackedEffect(fn, options) {
   const run = () => {
     if (!node._modified || node._flags & REACTIVE_DISPOSED) return;
@@ -2148,11 +2492,10 @@ function trackedEffect(fn, options) {
       }
       node._cleanup = cleanup;
     },
-    undefined,
     { ...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) => {
@@ -2167,7 +2510,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",
@@ -2228,7 +2572,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",
@@ -2236,9 +2581,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",
@@ -2254,34 +2599,45 @@ function onCleanup(fn) {
 }
 function accessor(node) {
   const fn = read.bind(null, node);
-  fn.$r = true;
+  fn[$REFRESH] = node;
   return fn;
 }
-function createSignal(first, second, third) {
+function createSignal(first, second) {
   if (typeof first === "function") {
-    const node = computed(first, second, third);
-    return [accessor(node), setSignal.bind(null, node)];
+    const node = computed(first, second);
+    node._config &= ~CONFIG_AUTO_DISPOSE;
+    return [accessor(node), setMemo.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);
-  return accessor(node);
-}
-function createEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn.effect || effectFn, effectFn.error, value, {
-    ...options,
-    name: options?.name ?? "effect"
-  });
+function createMemo(compute, options) {
+  return accessor(computed(compute, options));
 }
-function createRenderEffect(compute, effectFn, value, options) {
-  effect(compute, effectFn, undefined, value, {
-    render: true,
+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" }
   });
 }
+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 +2661,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 +2690,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._config &= ~CONFIG_AUTO_DISPOSE;
     return [accessor(node), setSignal.bind(null, node)];
   }
   const node = optimisticSignal(first, second);
@@ -2342,7 +2702,7 @@ function createOptimistic(first, second, third) {
 }
 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();
@@ -2357,7 +2717,7 @@ function onSettled(callback) {
 function unwrap(value) {
   return value?.[$TARGET]?.[STORE_NODE] ?? value;
 }
-function getOverrideValue(value, override, nodes, key, optOverride) {
+function getOverrideValue(value, override, key, optOverride) {
   if (optOverride && key in optOverride) return optOverride[key];
   return override && key in override ? override[key] : value[key];
 }
@@ -2369,23 +2729,147 @@ function getAllKeys(value, override, next) {
 function applyState(next, state, keyFn) {
   const target = state?.[$TARGET];
   if (!target) return;
+  if (target[STORE_OVERRIDE] || target[STORE_OPTIMISTIC_OVERRIDE]) {
+    applyStateSlow(next, target, keyFn);
+  } else {
+    applyStateFast(next, target, keyFn);
+  }
+}
+function applyStateFast(next, target, keyFn) {
+  const previous = target[STORE_VALUE];
+  if (next === previous) return;
+  (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
+  target[STORE_VALUE] = next;
+  if (Array.isArray(previous)) {
+    let changed = false;
+    const prevLength = previous.length;
+    if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
+      let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
+      for (
+        start = 0, end = Math.min(prevLength, next.length);
+        start < end &&
+        ((item = previous[start]) === next[start] ||
+          (item && next[start] && keyFn(item) === keyFn(next[start])));
+        start++
+      ) {
+        applyState(next[start], wrap(item, target), keyFn);
+      }
+      const temp = new Array(next.length),
+        newIndices = new Map();
+      for (
+        end = prevLength - 1, newEnd = next.length - 1;
+        end >= start &&
+        newEnd >= start &&
+        ((item = previous[end]) === next[newEnd] ||
+          (item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])));
+        end--, newEnd--
+      ) {
+        temp[newEnd] = item;
+      }
+      if (start > newEnd || start > end) {
+        for (j = start; j <= newEnd; j++) {
+          changed = true;
+          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
+        }
+        for (; j < next.length; j++) {
+          changed = true;
+          const wrapped = wrap(temp[j], target);
+          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
+          applyState(next[j], wrapped, keyFn);
+        }
+        changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+        prevLength !== next.length &&
+          target[STORE_NODE].length &&
+          setSignal(target[STORE_NODE].length, next.length);
+        return;
+      }
+      newIndicesNext = new Array(newEnd + 1);
+      for (j = newEnd; j >= start; j--) {
+        item = next[j];
+        keyVal = item ? keyFn(item) : item;
+        i = newIndices.get(keyVal);
+        newIndicesNext[j] = i === undefined ? -1 : i;
+        newIndices.set(keyVal, j);
+      }
+      for (i = start; i <= end; i++) {
+        item = previous[i];
+        keyVal = item ? keyFn(item) : item;
+        j = newIndices.get(keyVal);
+        if (j !== undefined && j !== -1) {
+          temp[j] = item;
+          j = newIndicesNext[j];
+          newIndices.set(keyVal, j);
+        }
+      }
+      for (j = start; j < next.length; j++) {
+        if (j in temp) {
+          const wrapped = wrap(temp[j], target);
+          target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrapped);
+          applyState(next[j], wrapped, keyFn);
+        } else target[STORE_NODE][j] && setSignal(target[STORE_NODE][j], wrap(next[j], target));
+      }
+      if (start < next.length) changed = true;
+    } else if (next.length) {
+      for (let i = 0, len = next.length; i < len; i++) {
+        const item = previous[i];
+        isWrappable(item)
+          ? applyState(next[i], wrap(item, target), keyFn)
+          : target[STORE_NODE][i] && setSignal(target[STORE_NODE][i], next[i]);
+      }
+    }
+    if (prevLength !== next.length) {
+      changed = true;
+      target[STORE_NODE].length && setSignal(target[STORE_NODE].length, next.length);
+    }
+    changed && target[STORE_NODE][$TRACK] && setSignal(target[STORE_NODE][$TRACK], void 0);
+    return;
+  }
+  let nodes = target[STORE_NODE];
+  if (nodes) {
+    const tracked = nodes[$TRACK];
+    const keys = tracked ? getAllKeys(previous, undefined, next) : Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const key = keys[i];
+      const node = nodes[key];
+      const previousValue = unwrap(previous[key]);
+      let nextValue = unwrap(next[key]);
+      if (previousValue === nextValue) continue;
+      if (
+        !previousValue ||
+        !isWrappable(previousValue) ||
+        !isWrappable(nextValue) ||
+        (keyFn(previousValue) != null && keyFn(previousValue) !== keyFn(nextValue))
+      ) {
+        tracked && setSignal(tracked, void 0);
+        node && setSignal(node, isWrappable(nextValue) ? wrap(nextValue, target) : nextValue);
+      } else applyState(nextValue, wrap(previousValue, target), keyFn);
+    }
+  }
+  if ((nodes = target[STORE_HAS])) {
+    const keys = Object.keys(nodes);
+    for (let i = 0, len = keys.length; i < len; i++) {
+      const key = keys[i];
+      setSignal(nodes[key], key in next);
+    }
+  }
+}
+function applyStateSlow(next, target, keyFn) {
   const previous = target[STORE_VALUE];
   const override = target[STORE_OVERRIDE];
   const optOverride = target[STORE_OPTIMISTIC_OVERRIDE];
   let nodes = target[STORE_NODE];
-  if (next === previous && !override && !optOverride) return;
   (target[STORE_LOOKUP] || storeLookup).set(next, target[$PROXY]);
   target[STORE_VALUE] = next;
   target[STORE_OVERRIDE] = undefined;
   if (Array.isArray(previous)) {
     let changed = false;
-    const prevLength = getOverrideValue(previous, override, nodes, "length", optOverride);
+    const prevLength = getOverrideValue(previous, override, "length", optOverride);
     if (next.length && prevLength && next[0] && keyFn(next[0]) != null) {
       let i, j, start, end, newEnd, item, newIndicesNext, keyVal;
       for (
         start = 0, end = Math.min(prevLength, next.length);
         start < end &&
-        ((item = getOverrideValue(previous, override, nodes, start, optOverride)) === next[start] ||
+        ((item = getOverrideValue(previous, override, start, optOverride)) === next[start] ||
           (item && next[start] && keyFn(item) === keyFn(next[start])));
         start++
       ) {
@@ -2397,7 +2881,7 @@ function applyState(next, state, keyFn) {
         end = prevLength - 1, newEnd = next.length - 1;
         end >= start &&
         newEnd >= start &&
-        ((item = getOverrideValue(previous, override, nodes, end, optOverride)) === next[newEnd] ||
+        ((item = getOverrideValue(previous, override, end, optOverride)) === next[newEnd] ||
           (item && next[newEnd] && keyFn(item) === keyFn(next[newEnd])));
         end--, newEnd--
       ) {
@@ -2429,7 +2913,7 @@ function applyState(next, state, keyFn) {
         newIndices.set(keyVal, j);
       }
       for (i = start; i <= end; i++) {
-        item = getOverrideValue(previous, override, nodes, i, optOverride);
+        item = getOverrideValue(previous, override, i, optOverride);
         keyVal = item ? keyFn(item) : item;
         j = newIndices.get(keyVal);
         if (j !== undefined && j !== -1) {
@@ -2448,7 +2932,7 @@ function applyState(next, state, keyFn) {
       if (start < next.length) changed = true;
     } else if (next.length) {
       for (let i = 0, len = next.length; i < len; i++) {
-        const item = getOverrideValue(previous, override, nodes, i, optOverride);
+        const item = getOverrideValue(previous, override, i, optOverride);
         isWrappable(item)
           ? applyState(next[i], wrap(item, target), keyFn)
           : target[STORE_NODE][i] && setSignal(target[STORE_NODE][i], next[i]);
@@ -2467,7 +2951,7 @@ function applyState(next, state, keyFn) {
     for (let i = 0, len = keys.length; i < len; i++) {
       const key = keys[i];
       const node = nodes[key];
-      const previousValue = unwrap(getOverrideValue(previous, override, nodes, key, optOverride));
+      const previousValue = unwrap(getOverrideValue(previous, override, key, optOverride));
       let nextValue = unwrap(next[key]);
       if (previousValue === nextValue) continue;
       if (
@@ -2499,7 +2983,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 +3003,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);
-    });
-  });
-  node._preventAutoDisposal = true;
+  const wrappedStore = wrapProjection(seed);
+  node = computed(
+    () => {
+      if (!node) node = getOwner();
+      runProjectionComputed(wrappedStore, fn, options?.key || "id");
+    },
+    options?.name ? { name: options.name } : undefined
+  );
+  node._config &= ~CONFIG_AUTO_DISPOSE;
   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 = {
@@ -2607,6 +3099,7 @@ const STORE_VALUE = "v",
   STORE_OPTIMISTIC_OVERRIDE = "x",
   STORE_NODE = "n",
   STORE_HAS = "h",
+  STORE_CUSTOM_PROTO = "c",
   STORE_WRAP = "w",
   STORE_LOOKUP = "l",
   STORE_FIREWALL = "f",
@@ -2616,7 +3109,14 @@ function createStoreProxy(value, traps = storeTraps, extend) {
   if (Array.isArray(value)) {
     newTarget = [];
     newTarget.v = value;
-  } else newTarget = { v: value };
+  } else {
+    newTarget = { v: value };
+    const unwrapped = value?.[$TARGET]?.[STORE_VALUE] ?? value;
+    const proto = Object.getPrototypeOf(unwrapped);
+    if (proto !== null && proto !== Object.prototype) {
+      newTarget[STORE_CUSTOM_PROTO] = true;
+    }
+  }
   extend && extend(newTarget);
   return (newTarget[$PROXY] = new Proxy(newTarget, traps));
 }
@@ -2628,12 +3128,8 @@ function wrap(value, target) {
   return p;
 }
 function isWrappable(obj) {
-  return (
-    obj != null &&
-    typeof obj === "object" &&
-    !Object.isFrozen(obj) &&
-    !(typeof Node !== "undefined" && obj instanceof Node)
-  );
+  if (obj == null || typeof obj !== "object" || Object.isFrozen(obj)) return false;
+  return typeof Node === "undefined" || !(obj instanceof Node);
 }
 let writeOverride = false;
 function setWriteOverride(value) {
@@ -2642,6 +3138,18 @@ function setWriteOverride(value) {
 function writeOnly(proxy) {
   return writeOverride || !!Writing?.has(proxy);
 }
+function unwrapStoreValue(value) {
+  return value?.[$TARGET]?.[STORE_VALUE] ?? value;
+}
+function hasInheritedAccessor(source, property) {
+  let current = Object.getPrototypeOf(source);
+  while (current && current !== Object.prototype) {
+    const desc = Reflect.getOwnPropertyDescriptor(current, property);
+    if (desc) return !!desc.get;
+    current = Object.getPrototypeOf(current);
+  }
+  return false;
+}
 function getNodes(target, type) {
   let nodes = target[type];
   if (!nodes) target[type] = nodes = Object.create(null);
@@ -2654,7 +3162,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 +3236,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);
 }
@@ -2756,6 +3296,21 @@ const storeTraps = {
     }
     const nodes = getNodes(target, STORE_NODE);
     const tracked = nodes[property];
+    const source = target[STORE_VALUE];
+    if (
+      !tracked &&
+      !target[STORE_OVERRIDE] &&
+      !target[STORE_OPTIMISTIC_OVERRIDE] &&
+      !target[STORE_CUSTOM_PROTO] &&
+      !target[STORE_OPTIMISTIC] &&
+      !target[STORE_SNAPSHOT_PROPS] &&
+      !source[$TARGET] &&
+      !(property in source) &&
+      getObserver() &&
+      !writeOnly(receiver)
+    ) {
+      return read(getNode(nodes, property, undefined, target[STORE_FIREWALL]));
+    }
     const optOverridden =
       target[STORE_OPTIMISTIC_OVERRIDE] && property in target[STORE_OPTIMISTIC_OVERRIDE];
     const overridden =
@@ -2769,6 +3324,12 @@ const storeTraps = {
     if (!tracked) {
       const desc = Object.getOwnPropertyDescriptor(storeValue, property);
       if (desc && desc.get) return desc.get.call(receiver);
+      if (!desc && !overridden && target[STORE_CUSTOM_PROTO]) {
+        const source = unwrapStoreValue(storeValue);
+        if (hasInheritedAccessor(source, property)) {
+          return Reflect.get(storeValue, property, receiver);
+        }
+      }
     }
     if (writeOnly(receiver)) {
       let value =
@@ -2815,7 +3376,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",
@@ -2837,18 +3398,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,7 +3423,13 @@ const storeTraps = {
             : target[STORE_OVERRIDE] && property in target[STORE_OVERRIDE]
               ? target[STORE_OVERRIDE][property]
               : base;
-        const value = rawValue?.[$TARGET]?.[STORE_VALUE] ?? rawValue;
+        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 = unwrapStoreValue(rawValue);
         const isArrayIndexWrite = Array.isArray(state) && property !== "length";
         const nextIndex = isArrayIndexWrite ? parseInt(property) + 1 : 0;
         const len =
@@ -2886,11 +3448,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);
       });
@@ -2904,10 +3476,7 @@ const storeTraps = {
         const { base: base, overrideKey: overrideKey } = prepareStoreWrite(target, store, property);
         const normalizedDescriptor =
           "value" in descriptor
-            ? {
-                ...descriptor,
-                value: descriptor.value?.[$TARGET]?.[STORE_VALUE] ?? descriptor.value
-              }
+            ? { ...descriptor, value: unwrapStoreValue(descriptor.value) }
             : descriptor;
         Object.defineProperty(
           target[overrideKey] || (target[overrideKey] = Object.create(null)),
@@ -2948,7 +3517,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;
@@ -3016,12 +3585,17 @@ function createStore(first, second, options) {
   const derived = typeof first === "function",
     wrappedStore = derived ? createProjectionInternal(first, second, options).store : wrap(first);
   registerGraph(wrappedStore, getOwner());
-  return [wrappedStore, fn => storeSetter(wrappedStore, fn)];
+  return [
+    wrappedStore,
+    derived
+      ? fn => (storeSetter(wrappedStore, fn), suppressComputedRecompute(wrappedStore[$REFRESH]))
+      : fn => storeSetter(wrappedStore, fn)
+  ];
 }
 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 +3629,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,42 +3652,33 @@ 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._preventAutoDisposal = true;
+    };
+    node = computed(
+      () => {
+        setProjectionWriteActive(true);
+        try {
+          runProjectionComputed(wrappedStore, fn, options?.key || "id", wrapCommit);
+        } finally {
+          setProjectionWriteActive(false);
+        }
+      },
+      options?.name ? { name: options.name } : undefined
+    );
+    node._config &= ~CONFIG_AUTO_DISPOSE;
   }
   return { store: wrappedStore, node: node };
 }
 const DELETE = Symbol("STORE_PATH_DELETE");
+function isPrototypePollutionKey(part) {
+  return part === "__proto__" || part === "constructor" || part === "prototype";
+}
 function updatePath(current, args, i = 0) {
   let part,
     prev = current;
@@ -3121,6 +3686,7 @@ function updatePath(current, args, i = 0) {
     part = args[i];
     const partType = typeof part;
     const isArray = Array.isArray(current);
+    if (partType === "string" && isPrototypePollutionKey(part)) return;
     if (Array.isArray(part)) {
       for (let j = 0; j < part.length; j++) {
         args[i] = part[j];
@@ -3167,6 +3733,7 @@ function updatePath(current, args, i = 0) {
     const keys = Object.keys(value);
     for (let i = 0; i < keys.length; i++) {
       const key = keys[i];
+      if (isPrototypePollutionKey(key)) continue;
       const desc = Object.getOwnPropertyDescriptor(value, key);
       if (desc.get || desc.set) Object.defineProperty(target, key, desc);
       else target[key] = desc.value;
@@ -3281,8 +3848,9 @@ function merge(...sources) {
     const s = sources[i];
     proxy = proxy || (!!s && $PROXY in s);
     const childSources = !!s && s[$SOURCES];
-    if (childSources) flattened.push(...childSources);
-    else flattened.push(typeof s === "function" ? ((proxy = true), createMemo(s)) : s);
+    if (childSources) {
+      for (let i = 0; i < childSources.length; i++) flattened.push(childSources[i]);
+    } else flattened.push(typeof s === "function" ? ((proxy = true), createMemo(s)) : s);
   }
   if (SUPPORTS_PROXY && proxy) {
     return new Proxy(
@@ -3301,10 +3869,12 @@ function merge(...sources) {
           return false;
         },
         keys() {
-          const keys = [];
-          for (let i = 0; i < flattened.length; i++)
-            keys.push(...Object.keys(resolveSource(flattened[i])));
-          return [...new Set(keys)];
+          const keys = new Set();
+          for (let i = 0; i < flattened.length; i++) {
+            const sourceKeys = Object.keys(resolveSource(flattened[i]));
+            for (let j = 0; j < sourceKeys.length; j++) keys.add(sourceKeys[j]);
+          }
+          return [...keys];
         }
       },
       propTraps
@@ -3345,26 +3915,27 @@ function merge(...sources) {
   return target;
 }
 function omit(props, ...keys) {
-  const blocked = new Set(keys);
   if (SUPPORTS_PROXY && $PROXY in props) {
     return new Proxy(
       {
         get(property) {
-          return blocked.has(property) ? undefined : props[property];
+          return keys.includes(property) ? undefined : props[property];
         },
         has(property) {
-          return !blocked.has(property) && property in props;
+          return !keys.includes(property) && property in props;
         },
         keys() {
-          return Object.keys(props).filter(k => !blocked.has(k));
+          return Object.keys(props).filter(k => !keys.includes(k));
         }
       },
       propTraps
     );
   }
   const result = {};
-  for (const propName of Object.getOwnPropertyNames(props)) {
-    if (!blocked.has(propName)) {
+  const propNames = Object.getOwnPropertyNames(props);
+  const blocked = keys.length > 4 && propNames.length > keys.length ? new Set(keys) : undefined;
+  for (const propName of propNames) {
+    if (blocked ? !blocked.has(propName) : !keys.includes(propName)) {
       const desc = Object.getOwnPropertyDescriptor(props, propName);
       !desc.get && !desc.set && desc.enumerable && desc.writable && desc.configurable
         ? (result[propName] = desc.value)
@@ -3386,23 +3957,25 @@ function mapArray(list, map, options) {
         }
       }
     : map;
-  return createMemo(
-    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
-    })
-  );
+  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 = { pureWrite: true };
+const pureOptions = { ownedWrite: true };
 function updateKeyedMap() {
   const newItems = this._list() || [],
     newLen = newItems.length;
@@ -3539,17 +4112,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._config &= ~CONFIG_AUTO_DISPOSE;
+  return accessor(node);
 }
 function updateRepeat() {
   const newLen = this._count();
@@ -3606,7 +4183,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;
@@ -3614,7 +4191,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;
 }
@@ -3631,12 +4208,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 +4229,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 +4254,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 +4296,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 +4349,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;
@@ -3800,7 +4430,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",
@@ -3833,15 +4464,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);
@@ -3860,14 +4492,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();
     });