@solidjs/signals 2.0.0-beta.10 → 2.0.0-beta.11

package/dist/dev.js

@@ -35,12 +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;
@@ -53,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;
@@ -70,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;
@@ -78,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);
 }
@@ -150,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 };
@@ -241,6 +318,7 @@ 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;
@@ -250,6 +328,16 @@ 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) {
@@ -353,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;
@@ -420,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;
@@ -436,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();
@@ -475,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 {
@@ -531,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];
@@ -556,6 +660,21 @@ 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;
@@ -584,27 +703,44 @@ 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
     );
@@ -654,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(
@@ -741,141 +886,6 @@ function runInTransition(transition, fn) {
     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?.();
-      const c = dep;
-      c._fn && c._config & CONFIG_AUTO_DISPOSE && !(c._flags & REACTIVE_ZOMBIE) && unobserved(c);
-    }
-  }
-  return nextDep;
-}
-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;
-}
 const PENDING_OWNER = {};
 function markDisposal(el) {
   let child = el._firstChild;
@@ -899,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;
@@ -925,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) {
@@ -975,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;
@@ -987,6 +1015,7 @@ function createOwner(options) {
     _parentComputed: parent?._root ? parent._parentComputed : parent,
     _firstChild: null,
     _nextSibling: null,
+    _prevSibling: null,
     _disposal: null,
     _queue: parent?._queue ?? globalQueue,
     _context: parent?._context || defaultContext,
@@ -994,9 +1023,7 @@ function createOwner(options) {
     _pendingDisposal: null,
     _pendingFirstChild: null,
     _parent: parent,
-    dispose(self = true) {
-      disposeChildren(owner, self);
-    }
+    dispose: disposeRootSelf
   };
   if (parent && parent._config & CONFIG_CHILDREN_FORBIDDEN) {
     emitDiagnostic({
@@ -1015,15 +1042,91 @@ function createOwner(options) {
       parent._firstChild = owner;
     } else {
       owner._nextSibling = lastChild;
+      lastChild._prevSibling = owner;
       parent._firstChild = owner;
     }
   }
   DEV$1.hooks.onOwner?.(owner);
   return owner;
 }
-function createRoot(init, options) {
-  const owner = createOwner(options);
-  return runWithOwner(owner, () => init(owner.dispose));
+function createRoot(init, options) {
+  const owner = createOwner(options);
+  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;
@@ -1116,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 => {
@@ -1136,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);
@@ -1245,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 (
@@ -1304,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);
     }
   });
@@ -1404,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;
@@ -1412,7 +1537,7 @@ function recompute(el, create = false) {
       el._firstChild = null;
       el._childCount = 0;
       clearSignals(el);
-    }
+    } else clearSignals(el);
   }
   let isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
   const hasOverride = el._overrideValue !== undefined && el._overrideValue !== NOT_PENDING;
@@ -1451,15 +1576,26 @@ function recompute(el, create = false) {
       }
     }
   }
+  const isStaleEffect = isEffect && isEffect !== EFFECT_USER;
+  const prevStale = stale;
+  if (isStaleEffect) stale = true;
   try {
-    const prevInFlight = el._inFlight;
-    const fnResult = el._fn(value);
-    value = el._inFlight !== prevInFlight ? fnResult : handleAsync(el, fnResult);
+    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) {
@@ -1481,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
@@ -1501,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) {
@@ -1523,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 &&
@@ -1563,6 +1702,7 @@ function computed(fn, options) {
       (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,
     _unobserved: options?.unobserved,
@@ -1582,6 +1722,7 @@ function computed(fn, options) {
     _subsTail: null,
     _parent: context,
     _nextSibling: null,
+    _prevSibling: null,
     _firstChild: null,
     _flags: options?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
     _statusFlags: STATUS_UNINITIALIZED,
@@ -1593,6 +1734,63 @@ function computed(fn, 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 && context._config & CONFIG_CHILDREN_FORBIDDEN) {
@@ -1612,6 +1810,7 @@ function computed(fn, options) {
       context._firstChild = self;
     } else {
       self._nextSibling = lastChild;
+      lastChild._prevSibling = self;
       context._firstChild = self;
     }
   }
@@ -1635,7 +1834,6 @@ function computed(fn, options) {
       snapshotSources.add(self);
     }
   }
-  return self;
 }
 function signal(v, options, firewall = null) {
   const s = {
@@ -1756,7 +1954,6 @@ function read(el) {
   const computed = el;
   if (typeof computed._fn === "function") {
     const comp = el;
-    if (refreshing && !(comp._flags & REACTIVE_DISPOSED)) recompute(comp);
     if (comp._flags & REACTIVE_LAZY) {
       comp._flags &= ~REACTIVE_LAZY;
       recompute(comp, true);
@@ -1765,6 +1962,19 @@ function read(el) {
     }
   }
   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 =
       `[PENDING_ASYNC_UNTRACKED_READ] Reading a pending async value directly in ${strictRead}. ` +
@@ -1955,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);
   }
@@ -1967,6 +2177,17 @@ 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 =
@@ -2090,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) {
@@ -2138,69 +2370,20 @@ function isUndefined(value) {
   return typeof value === "undefined";
 }
 function effect(compute, effect, error, options) {
-  let initialized = false;
   const isUser = !!options?.user;
-  const node = computed(isUser ? compute : p => staleValues(() => compute(p)), {
-    ...options,
-    equals: () => {
-      node._modified = !node._error;
-      if (initialized) node._queue.enqueue(node._type, runEffect.bind(node));
-      return false;
-    },
-    lazy: true
-  });
-  node._config &= ~CONFIG_AUTO_DISPOSE;
-  node._prevValue = undefined;
-  node._effectFn = effect;
-  node._errorFn = error;
-  node._cleanup = undefined;
-  node._type = isUser ? EFFECT_USER : EFFECT_RENDER;
-  node._notifyStatus = (status, error) => {
-    const actualStatus = status !== undefined ? status : node._statusFlags;
-    const actualError = error !== undefined ? error : node._error;
-    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();
-        if (!node._queue.notify(node, 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: node.id,
-            ownerName: node._name
-          });
-          console.warn(message);
-        }
-      }
-    }
-  };
+  const node = createEffectNode(
+    compute,
+    effect,
+    error,
+    isUser ? EFFECT_USER : EFFECT_RENDER,
+    notifyEffectStatus,
+    options
+  );
   recompute(node, true);
   !options?.defer &&
     (node._type === EFFECT_USER || options?.schedule
-      ? node._queue.enqueue(node._type, runEffect.bind(node))
-      : runEffect.call(node));
-  initialized = true;
-  cleanup(() => node._cleanup?.());
+      ? node._queue.enqueue(node._type, runEffect.bind(null, node))
+      : runEffect(node));
   if (!node._parent) {
     const message =
       "[NO_OWNER_EFFECT] Effects created outside a reactive context will never be disposed";
@@ -2216,32 +2399,76 @@ function effect(compute, effect, error, 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;
@@ -2371,13 +2598,15 @@ function onCleanup(fn) {
   return cleanup(fn);
 }
 function accessor(node) {
-  return read.bind(null, node);
+  const fn = read.bind(null, node);
+  fn[$REFRESH] = node;
+  return fn;
 }
 function createSignal(first, second) {
   if (typeof first === "function") {
     const node = computed(first, second);
     node._config &= ~CONFIG_AUTO_DISPOSE;
-    return [accessor(node), setSignal.bind(null, node)];
+    return [accessor(node), setMemo.bind(null, node)];
   }
   const node = signal(first, second);
   registerGraph(node, getOwner());
@@ -2488,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];
 }
@@ -2500,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++
       ) {
@@ -2528,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--
       ) {
@@ -2560,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) {
@@ -2579,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]);
@@ -2598,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 (
@@ -2756,8 +3109,14 @@ function createStoreProxy(value, traps = storeTraps, extend) {
   if (Array.isArray(value)) {
     newTarget = [];
     newTarget.v = value;
-  } else newTarget = { v: value };
-  newTarget[STORE_CUSTOM_PROTO] = hasCustomPrototype(unwrapStoreValue(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));
 }
@@ -2769,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) {
@@ -2786,11 +3141,6 @@ function writeOnly(proxy) {
 function unwrapStoreValue(value) {
   return value?.[$TARGET]?.[STORE_VALUE] ?? value;
 }
-function hasCustomPrototype(value) {
-  if (Array.isArray(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto !== null && proto !== Object.prototype;
-}
 function hasInheritedAccessor(source, property) {
   let current = Object.getPrototypeOf(source);
   while (current && current !== Object.prototype) {
@@ -2946,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 =
@@ -3220,7 +3585,12 @@ 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;
@@ -3478,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(
@@ -3498,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
@@ -3542,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)