@tanstack/solid-query-devtools 6.0.0-alpha.0 → 6.0.0-alpha.1

package/build/chunk/{KLS34EMT.js → 75V4Q6CI.js}

@@ -1,8 +1,8 @@
 import { createRenderEffect, untrack as untrack$1, runWithOwner, sharedConfig } from 'solid-js';
 
-// ../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.2_@solidjs+signals@0.12.0_solid-js@2.0.0-beta.2/node_modules/@solidjs/web/dist/dev.js
+// ../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.4_@solidjs+signals@0.13.6_solid-js@2.0.0-beta.4/node_modules/@solidjs/web/dist/dev.js
 
-// ../../node_modules/.pnpm/@solidjs+signals@0.12.0/node_modules/@solidjs/signals/dist/dev.js
+// ../../node_modules/.pnpm/@solidjs+signals@0.13.6/node_modules/@solidjs/signals/dist/dev.js
 var NotReadyError = class extends Error {
   source;
   constructor(source) {
@@ -113,7 +113,8 @@ var clock = 0;
 var activeTransition = null;
 var scheduled = false;
 var projectionWriteActive = false;
-var _onUnhandledAsync = null;
+var inTrackedQueueCallback = false;
+var stashedOptimisticReads = null;
 function runLaneEffects(type) {
   for (const lane of activeLanes) {
     if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
@@ -124,6 +125,65 @@ function runLaneEffects(type) {
     }
   }
 }
+function queueStashedOptimisticEffects(node) {
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    const sub = s._sub;
+    if (!sub._type) 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);
+  }
+}
+function mergeTransitionState(target, outgoing) {
+  outgoing._done = target;
+  target._actions.push(...outgoing._actions);
+  for (const lane of activeLanes) {
+    if (lane._transition === outgoing) lane._transition = target;
+  }
+  target._optimisticNodes.push(...outgoing._optimisticNodes);
+  for (const store of outgoing._optimisticStores) target._optimisticStores.add(store);
+  for (const node of outgoing._asyncNodes) {
+    if (!target._asyncNodes.includes(node)) target._asyncNodes.push(node);
+  }
+}
+function resolveOptimisticNodes(nodes) {
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    node._optimisticLane = void 0;
+    if (node._pendingValue !== NOT_PENDING) {
+      node._value = node._pendingValue;
+      node._pendingValue = NOT_PENDING;
+    }
+    const prevOverride = node._overrideValue;
+    node._overrideValue = NOT_PENDING;
+    if (prevOverride !== NOT_PENDING && node._value !== prevOverride) insertSubs(node, true);
+    node._transition = null;
+  }
+  nodes.length = 0;
+}
+function cleanupCompletedLanes(completingTransition) {
+  for (const lane of activeLanes) {
+    const owned = completingTransition ? lane._transition === completingTransition : !lane._transition;
+    if (!owned) continue;
+    if (!lane._mergedInto) {
+      if (lane._effectQueues[0].length) runQueue(lane._effectQueues[0], EFFECT_RENDER);
+      if (lane._effectQueues[1].length) runQueue(lane._effectQueues[1], EFFECT_USER);
+    }
+    if (lane._source._optimisticLane === lane) lane._source._optimisticLane = void 0;
+    lane._pendingAsync.clear();
+    lane._effectQueues[0].length = 0;
+    lane._effectQueues[1].length = 0;
+    activeLanes.delete(lane);
+    signalLanes.delete(lane._source);
+  }
+}
 function schedule() {
   if (scheduled) return;
   scheduled = true;
@@ -208,19 +268,32 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       if (activeTransition) {
         const isComplete = transitionComplete(activeTransition);
         if (!isComplete) {
-          let t = activeTransition;
+          const stashedTransition = activeTransition;
           runHeap(zombieQueue, _GlobalQueue._update);
           this._pendingNodes = [];
           this._optimisticNodes = [];
           this._optimisticStores = /* @__PURE__ */ new Set();
           runLaneEffects(EFFECT_RENDER);
           runLaneEffects(EFFECT_USER);
-          this.stashQueues(activeTransition._queueStash);
+          this.stashQueues(stashedTransition._queueStash);
           clock++;
           scheduled = dirtyQueue._max >= dirtyQueue._min;
-          reassignPendingTransition(activeTransition._pendingNodes);
+          reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
-          finalizePureQueue(null, true);
+          if (!stashedTransition._actions.length && stashedTransition._optimisticNodes.length) {
+            stashedOptimisticReads = /* @__PURE__ */ new Set();
+            for (let i = 0; i < stashedTransition._optimisticNodes.length; i++) {
+              const node = stashedTransition._optimisticNodes[i];
+              if (node._fn || node._pureWrite) continue;
+              stashedOptimisticReads.add(node);
+              queueStashedOptimisticEffects(node);
+            }
+          }
+          try {
+            finalizePureQueue(null, true);
+          } finally {
+            stashedOptimisticReads = null;
+          }
           return;
         }
         this._pendingNodes !== activeTransition._pendingNodes && this._pendingNodes.push(...activeTransition._pendingNodes);
@@ -246,14 +319,14 @@ var GlobalQueue = class _GlobalQueue extends Queue {
   }
   notify(node, mask, flags, error) {
     if (mask & STATUS_PENDING) {
-      if (_onUnhandledAsync && flags & STATUS_PENDING) {
-        _onUnhandledAsync();
-      }
       if (flags & STATUS_PENDING) {
         const actualError = error !== void 0 ? error : node._error;
-        if (activeTransition && actualError && !activeTransition._asyncNodes.includes(actualError.source)) {
-          activeTransition._asyncNodes.push(actualError.source);
-          schedule();
+        if (activeTransition && actualError) {
+          const source = actualError.source;
+          if (!activeTransition._asyncNodes.includes(source)) {
+            activeTransition._asyncNodes.push(source);
+            schedule();
+          }
         }
       }
       return true;
@@ -277,37 +350,35 @@ var GlobalQueue = class _GlobalQueue extends Queue {
       };
     } else if (transition) {
       const outgoing = activeTransition;
-      outgoing._done = transition;
-      transition._actions.push(...outgoing._actions);
-      for (const lane of activeLanes) {
-        if (lane._transition === outgoing) lane._transition = transition;
-      }
-      transition._optimisticNodes.push(...outgoing._optimisticNodes);
-      for (const store of outgoing._optimisticStores) {
-        transition._optimisticStores.add(store);
-      }
+      mergeTransitionState(transition, outgoing);
       transitions.delete(outgoing);
       activeTransition = transition;
     }
     transitions.add(activeTransition);
     activeTransition._time = clock;
-    for (let i = 0; i < this._pendingNodes.length; i++) {
-      const n = this._pendingNodes[i];
-      n._transition = activeTransition;
-      activeTransition._pendingNodes.push(n);
+    if (this._pendingNodes !== activeTransition._pendingNodes) {
+      for (let i = 0; i < this._pendingNodes.length; i++) {
+        const node = this._pendingNodes[i];
+        node._transition = activeTransition;
+        activeTransition._pendingNodes.push(node);
+      }
+      this._pendingNodes = activeTransition._pendingNodes;
     }
-    this._pendingNodes = activeTransition._pendingNodes;
-    for (let i = 0; i < this._optimisticNodes.length; i++) {
-      const node = this._optimisticNodes[i];
-      node._transition = activeTransition;
-      activeTransition._optimisticNodes.push(node);
+    if (this._optimisticNodes !== activeTransition._optimisticNodes) {
+      for (let i = 0; i < this._optimisticNodes.length; i++) {
+        const node = this._optimisticNodes[i];
+        node._transition = activeTransition;
+        activeTransition._optimisticNodes.push(node);
+      }
+      this._optimisticNodes = activeTransition._optimisticNodes;
     }
-    this._optimisticNodes = activeTransition._optimisticNodes;
     for (const lane of activeLanes) {
       if (!lane._transition) lane._transition = activeTransition;
     }
-    for (const store of this._optimisticStores) activeTransition._optimisticStores.add(store);
-    this._optimisticStores = activeTransition._optimisticStores;
+    if (this._optimisticStores !== activeTransition._optimisticStores) {
+      for (const store of this._optimisticStores) activeTransition._optimisticStores.add(store);
+      this._optimisticStores = activeTransition._optimisticStores;
+    }
   }
 };
 function insertSubs(node, optimistic = false) {
@@ -338,36 +409,30 @@ 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];
+    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);
+  }
+  pendingNodes.length = 0;
+}
 function finalizePureQueue(completingTransition = null, incomplete = false) {
-  let resolvePending = !incomplete;
+  const resolvePending = !incomplete;
+  if (resolvePending) commitPendingNodes();
   if (!incomplete) checkBoundaryChildren(globalQueue);
   if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
   if (resolvePending) {
-    const pendingNodes = globalQueue._pendingNodes;
-    for (let i = 0; i < pendingNodes.length; i++) {
-      const n = pendingNodes[i];
-      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);
-    }
-    pendingNodes.length = 0;
-    const optimisticNodes = completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes;
-    for (let i = 0; i < optimisticNodes.length; i++) {
-      const n = optimisticNodes[i];
-      const original = n._pendingValue;
-      n._optimisticLane = void 0;
-      if (original !== NOT_PENDING && n._value !== original) {
-        n._value = original;
-        insertSubs(n, true);
-      }
-      n._pendingValue = NOT_PENDING;
-      n._transition = null;
-    }
-    optimisticNodes.length = 0;
+    commitPendingNodes();
+    resolveOptimisticNodes(
+      completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes
+    );
     const optimisticStores = completingTransition ? completingTransition._optimisticStores : globalQueue._optimisticStores;
     if (GlobalQueue._clearOptimisticStore && optimisticStores.size) {
       for (const store of optimisticStores) {
@@ -376,20 +441,7 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
       optimisticStores.clear();
       schedule();
     }
-    for (const lane of activeLanes) {
-      const owned = completingTransition ? lane._transition === completingTransition : !lane._transition;
-      if (!owned) continue;
-      if (!lane._mergedInto) {
-        if (lane._effectQueues[0].length) runQueue(lane._effectQueues[0], EFFECT_RENDER);
-        if (lane._effectQueues[1].length) runQueue(lane._effectQueues[1], EFFECT_USER);
-      }
-      if (lane._source._optimisticLane === lane) lane._source._optimisticLane = void 0;
-      lane._pendingAsync.clear();
-      lane._effectQueues[0].length = 0;
-      lane._effectQueues[1].length = 0;
-      activeLanes.delete(lane);
-      signalLanes.delete(lane._source);
-    }
+    cleanupCompletedLanes(completingTransition);
   }
 }
 function checkBoundaryChildren(queue) {
@@ -405,8 +457,16 @@ function reassignPendingTransition(pendingNodes) {
 }
 var globalQueue = new GlobalQueue();
 function flush() {
+  if (globalQueue._running) {
+    if (inTrackedQueueCallback) {
+      throw new Error(
+        "Cannot call flush() from inside onSettled or createTrackedEffect. flush() is not reentrant there."
+      );
+    }
+    return;
+  }
   let count = 0;
-  while (scheduled) {
+  while (scheduled || activeTransition) {
     if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
     globalQueue.flush();
   }
@@ -425,6 +485,15 @@ function transitionComplete(transition) {
       break;
     }
   }
+  if (done) {
+    for (let i = 0; i < transition._optimisticNodes.length; i++) {
+      const node = transition._optimisticNodes[i];
+      if (hasActiveOverride(node) && "_statusFlags" in node && node._statusFlags & STATUS_PENDING && node._error instanceof NotReadyError && node._error.source !== node) {
+        done = false;
+        break;
+      }
+    }
+  }
   done && (transition._done = true);
   return done;
 }
@@ -460,7 +529,7 @@ function getOrCreateLane(signal) {
   };
   signalLanes.set(signal, lane);
   activeLanes.add(lane);
-  signal._laneVersion = signal._overrideVersion || 0;
+  signal._overrideSinceLane = false;
   return lane;
 }
 function findLane(lane) {
@@ -485,8 +554,11 @@ function resolveLane(el) {
   el._optimisticLane = void 0;
   return void 0;
 }
+function resolveTransition(el) {
+  return resolveLane(el)?._transition ?? el._transition;
+}
 function hasActiveOverride(el) {
-  return !!(el._optimistic && el._pendingValue !== NOT_PENDING);
+  return !!(el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING);
 }
 function assignOrMergeLane(el, sourceLane) {
   const sourceRoot = findLane(sourceLane);
@@ -509,6 +581,96 @@ function assignOrMergeLane(el, sourceLane) {
   }
   el._optimisticLane = sourceLane;
 }
+function addPendingSource(el, source) {
+  if (el._pendingSource === source || el._pendingSources?.has(source)) return false;
+  if (!el._pendingSource) {
+    el._pendingSource = source;
+    return true;
+  }
+  if (!el._pendingSources) {
+    el._pendingSources = /* @__PURE__ */ new Set([el._pendingSource, source]);
+  } else {
+    el._pendingSources.add(source);
+  }
+  el._pendingSource = void 0;
+  return true;
+}
+function removePendingSource(el, source) {
+  if (el._pendingSource) {
+    if (el._pendingSource !== source) return false;
+    el._pendingSource = void 0;
+    return true;
+  }
+  if (!el._pendingSources?.delete(source)) return false;
+  if (el._pendingSources.size === 1) {
+    el._pendingSource = el._pendingSources.values().next().value;
+    el._pendingSources = void 0;
+  } else if (el._pendingSources.size === 0) {
+    el._pendingSources = void 0;
+  }
+  return true;
+}
+function clearPendingSources(el) {
+  el._pendingSource = void 0;
+  el._pendingSources?.clear();
+  el._pendingSources = void 0;
+}
+function setPendingError(el, source, error) {
+  if (!source) {
+    el._error = null;
+    return;
+  }
+  if (error instanceof NotReadyError && error.source === source) {
+    el._error = error;
+    return;
+  }
+  const current = el._error;
+  if (!(current instanceof NotReadyError) || current.source !== source) {
+    el._error = new NotReadyError(source);
+  }
+}
+function forEachDependent(el, fn) {
+  for (let s = el._subs; s !== null; s = s._nextSub) fn(s._sub);
+  for (let child = el._child; child !== null; child = child._nextChild) {
+    for (let s = child._subs; s !== null; s = s._nextSub) fn(s._sub);
+  }
+}
+function settlePendingSource(el) {
+  let scheduled2 = false;
+  const visited = /* @__PURE__ */ new Set();
+  const settle = (node) => {
+    if (visited.has(node) || !removePendingSource(node, el)) return;
+    visited.add(node);
+    node._time = clock;
+    const source = node._pendingSource ?? node._pendingSources?.values().next().value;
+    if (source) {
+      setPendingError(node, source);
+      updatePendingSignal(node);
+    } else {
+      node._statusFlags &= ~STATUS_PENDING;
+      setPendingError(node);
+      updatePendingSignal(node);
+      if (node._blocked) {
+        if (node._type === EFFECT_TRACKED) {
+          const tracked = node;
+          if (!tracked._modified) {
+            tracked._modified = true;
+            tracked._queue.enqueue(EFFECT_USER, tracked._run);
+          }
+        } else {
+          const queue = node._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+          if (queue._min > node._height) queue._min = node._height;
+          insertIntoHeap(node, queue);
+        }
+        scheduled2 = true;
+      }
+      node._blocked = false;
+    }
+    forEachDependent(node, settle);
+  };
+  forEachDependent(el, settle);
+  if (scheduled2) schedule();
+}
 function handleAsync(el, result, setter) {
   const isObject = typeof result === "object" && result !== null;
   const iterator = isObject && untrack(() => result[Symbol.asyncIterator]);
@@ -521,21 +683,21 @@ function handleAsync(el, result, setter) {
   let syncValue;
   const handleError = (error) => {
     if (el._inFlight !== result) return;
-    globalQueue.initTransition(el._transition);
+    globalQueue.initTransition(resolveTransition(el));
     notifyStatus(el, error instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, error);
     el._time = clock;
   };
   const asyncWrite = (value, then) => {
     if (el._inFlight !== result) return;
     if (el._flags & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-    globalQueue.initTransition(el._transition);
+    globalQueue.initTransition(resolveTransition(el));
     clearStatus(el);
     const lane = resolveLane(el);
     if (lane) lane._pendingAsync.delete(el);
-    if (el._optimistic) {
-      const hadOverride = el._pendingValue !== NOT_PENDING;
-      if (el._fn) el._pendingValue = value;
-      if (!hadOverride) {
+    if (el._overrideValue !== void 0) {
+      if (el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING)
+        el._pendingValue = value;
+      else {
         el._value = value;
         insertSubs(el);
       }
@@ -554,6 +716,7 @@ function handleAsync(el, result, setter) {
     } else {
       setSignal(el, () => value);
     }
+    settlePendingSource(el);
     schedule();
     flush();
     then?.();
@@ -573,7 +736,7 @@ function handleAsync(el, result, setter) {
     );
     isSync = false;
     if (!resolved) {
-      globalQueue.initTransition(el._transition);
+      globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
   }
@@ -607,41 +770,48 @@ function handleAsync(el, result, setter) {
     };
     const immediatelyDone = iterate();
     if (!hadSyncValue && !immediatelyDone) {
-      globalQueue.initTransition(el._transition);
+      globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
   }
   return syncValue;
 }
-function clearStatus(el) {
-  el._statusFlags = el._statusFlags & STATUS_UNINITIALIZED;
-  el._error = null;
+function clearStatus(el, clearUninitialized = false) {
+  clearPendingSources(el);
+  el._blocked = false;
+  el._statusFlags = clearUninitialized ? 0 : el._statusFlags & STATUS_UNINITIALIZED;
+  setPendingError(el);
   updatePendingSignal(el);
   el._notifyStatus?.();
 }
 function notifyStatus(el, status, error, blockStatus, lane) {
   if (status === STATUS_ERROR && !(error instanceof StatusError) && !(error instanceof NotReadyError))
     error = new StatusError(el, error);
-  const isSource = error instanceof NotReadyError && error.source === el;
-  const isOptimisticBoundary = status === STATUS_PENDING && el._optimistic && !isSource;
+  const pendingSource = status === STATUS_PENDING && error instanceof NotReadyError ? error.source : void 0;
+  const isSource = pendingSource === el;
+  const isOptimisticBoundary = status === STATUS_PENDING && el._overrideValue !== void 0 && !isSource;
   const startsBlocking = isOptimisticBoundary && hasActiveOverride(el);
   if (!blockStatus) {
-    el._statusFlags = status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
-    el._error = error;
+    if (status === STATUS_PENDING && pendingSource) {
+      addPendingSource(el, pendingSource);
+      el._statusFlags = STATUS_PENDING | el._statusFlags & STATUS_UNINITIALIZED;
+      setPendingError(el, pendingSource, error);
+    } else {
+      clearPendingSources(el);
+      el._statusFlags = status | (status !== STATUS_ERROR ? el._statusFlags & STATUS_UNINITIALIZED : 0);
+      el._error = error;
+    }
     updatePendingSignal(el);
   }
   if (lane && !blockStatus) {
     assignOrMergeLane(el, lane);
   }
-  if (startsBlocking && activeTransition && error instanceof NotReadyError) {
-    const source = error.source;
-    if (!activeTransition._asyncNodes.includes(source)) {
-      activeTransition._asyncNodes.push(source);
-    }
-  }
   const downstreamBlockStatus = blockStatus || startsBlocking;
   const downstreamLane = blockStatus || isOptimisticBoundary ? void 0 : lane;
   if (el._notifyStatus) {
+    if (blockStatus && status === STATUS_PENDING) {
+      return;
+    }
     if (downstreamBlockStatus) {
       el._notifyStatus(status, error);
     } else {
@@ -649,49 +819,15 @@ function notifyStatus(el, status, error, blockStatus, lane) {
     }
     return;
   }
-  for (let s = el._subs; s !== null; s = s._nextSub) {
-    s._sub._time = clock;
-    if (s._sub._error !== error) {
-      !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
-      notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
-    }
-  }
-  for (let child = el._child; child !== null; child = child._nextChild) {
-    for (let s = child._subs; s !== null; s = s._nextSub) {
-      s._sub._time = clock;
-      if (s._sub._error !== error) {
-        !s._sub._transition && globalQueue._pendingNodes.push(s._sub);
-        notifyStatus(s._sub, status, error, downstreamBlockStatus, downstreamLane);
-      }
-    }
-  }
-}
-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);
+  forEachDependent(el, (sub) => {
+    sub._time = clock;
+    if (status === STATUS_PENDING && pendingSource && sub._pendingSource !== pendingSource && !sub._pendingSources?.has(pendingSource) || status !== STATUS_PENDING && (sub._error !== error || sub._pendingSource || sub._pendingSources)) {
+      if (!downstreamBlockStatus && !sub._transition) globalQueue._pendingNodes.push(sub);
+      notifyStatus(sub, status, error, downstreamBlockStatus, downstreamLane);
     }
-  }
-  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;
-  disposeChildren(el, true);
+  });
 }
+var externalSourceConfig = null;
 function markDisposal(el) {
   let child = el._firstChild;
   while (child) {
@@ -727,7 +863,6 @@ function disposeChildren(node, self = false, zombie) {
     node._pendingFirstChild = null;
   } else {
     node._firstChild = null;
-    node._nextSibling = null;
     node._childCount = 0;
   }
   runDisposal(node, zombie);
@@ -745,7 +880,32 @@ function runDisposal(node, zombie) {
   }
   zombie ? node._pendingDisposal = null : node._disposal = null;
 }
-var leafEffectActive = false;
+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;
+}
+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);
+}
 GlobalQueue._update = recompute;
 GlobalQueue._dispose = disposeChildren;
 var tracking = false;
@@ -768,7 +928,7 @@ function recompute(el, create = false) {
     }
   }
   const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
-  const hasOverride = hasActiveOverride(el);
+  const hasOverride = el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING;
   const wasPending = !!(el._statusFlags & STATUS_PENDING);
   const oldcontext = context;
   context = el;
@@ -791,7 +951,7 @@ function recompute(el, create = false) {
   }
   try {
     value = handleAsync(el, el._fn(value));
-    clearStatus(el);
+    clearStatus(el, create);
     const resolvedLane = resolveLane(el);
     if (resolvedLane) {
       resolvedLane._pendingAsync.delete(el);
@@ -806,6 +966,7 @@ function recompute(el, create = false) {
         updatePendingSignal(lane._source);
       }
     }
+    if (e instanceof NotReadyError) el._blocked = true;
     notifyStatus(
       el,
       e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
@@ -829,21 +990,21 @@ function recompute(el, create = false) {
       if (depsTail !== null) depsTail._nextDep = null;
       else el._deps = null;
     }
-    const compareValue = hasOverride ? el._value : el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+    const compareValue = hasOverride ? el._overrideValue : el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
     const valueChanged = !el._equals || !el._equals(compareValue, value);
     if (valueChanged) {
-      const prevVisible = hasOverride ? el._value : void 0;
-      if (create || isEffect && activeTransition !== el._transition || isOptimisticDirty)
+      const prevVisible = hasOverride ? el._overrideValue : void 0;
+      if (create || isEffect && activeTransition !== el._transition || isOptimisticDirty) {
         el._value = value;
-      else el._pendingValue = value;
-      if (hasOverride && !isOptimisticDirty && wasPending) {
-        const ov = el._overrideVersion || 0;
-        const lv = el._laneVersion || 0;
-        if (ov <= lv) el._value = value;
-      }
-      if (!hasOverride || isOptimisticDirty || el._value !== prevVisible) {
+        if (hasOverride && isOptimisticDirty) {
+          el._overrideValue = value;
+          el._pendingValue = value;
+        }
+      } else el._pendingValue = value;
+      if (hasOverride && !isOptimisticDirty && wasPending && !el._overrideSinceLane)
+        el._overrideValue = value;
+      if (!hasOverride || isOptimisticDirty || el._overrideValue !== prevVisible)
         insertSubs(el, isOptimisticDirty || hasOverride);
-      }
     } else if (hasOverride) {
       el._pendingValue = value;
     } else if (el._height != oldHeight) {
@@ -853,17 +1014,18 @@ function recompute(el, create = false) {
     }
   }
   currentOptimisticLane = prevLane;
-  (!create || el._statusFlags & STATUS_PENDING) && !el._transition && !(activeTransition && el._optimistic) && globalQueue._pendingNodes.push(el);
+  (!create || el._statusFlags & STATUS_PENDING) && !el._transition && !(activeTransition && hasOverride) && globalQueue._pendingNodes.push(el);
   el._transition && isEffect && activeTransition !== el._transition && runInTransition(el._transition, () => recompute(el));
 }
 var strictRead = false;
 function untrack(fn, strictReadLabel) {
-  if (!tracking && !strictRead && true) return fn();
+  if (!externalSourceConfig && !tracking && !strictRead && true) return fn();
   const prevTracking = tracking;
   const prevStrictRead = strictRead;
   tracking = false;
   strictRead = false;
   try {
+    if (externalSourceConfig) return externalSourceConfig.untrack(fn);
     return fn();
   } finally {
     tracking = prevTracking;
@@ -871,36 +1033,33 @@ function untrack(fn, strictReadLabel) {
   }
 }
 function setSignal(el, v) {
-  if (!el._pureWrite && !leafEffectActive && context && el._firewall !== context)
+  if (!el._pureWrite && !context?._childrenForbidden && context && el._firewall !== context)
     console.warn("A Signal was written to in an owned scope.");
   if (el._transition && activeTransition !== el._transition)
     globalQueue.initTransition(el._transition);
-  const isOptimistic = el._optimistic && !projectionWriteActive;
-  const currentValue = isOptimistic ? el._value : el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  const isOptimistic = el._overrideValue !== void 0 && !projectionWriteActive;
+  const hasOverride = el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING;
+  const currentValue = isOptimistic ? hasOverride ? el._overrideValue : el._value : el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   if (typeof v === "function") v = v(currentValue);
   const valueChanged = !el._equals || !el._equals(currentValue, v) || !!(el._statusFlags & STATUS_UNINITIALIZED);
   if (!valueChanged) {
-    if (isOptimistic && el._pendingValue !== NOT_PENDING && el._fn) {
+    if (isOptimistic && hasOverride && el._fn) {
       insertSubs(el, true);
       schedule();
     }
     return v;
   }
   if (isOptimistic) {
-    const alreadyTracked = globalQueue._optimisticNodes.includes(el);
-    if (el._transition && alreadyTracked) {
-      globalQueue.initTransition(el._transition);
-    }
-    if (el._pendingValue === NOT_PENDING) {
+    const firstOverride = el._overrideValue === NOT_PENDING;
+    if (!firstOverride) globalQueue.initTransition(resolveTransition(el));
+    if (firstOverride) {
       el._pendingValue = el._value;
-    }
-    if (!alreadyTracked) {
       globalQueue._optimisticNodes.push(el);
     }
-    el._overrideVersion = (el._overrideVersion || 0) + 1;
+    el._overrideSinceLane = true;
     const lane = getOrCreateLane(el);
     el._optimisticLane = lane;
-    el._value = v;
+    el._overrideValue = v;
   } else {
     if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
     el._pendingValue = v;
@@ -916,7 +1075,11 @@ function setSignal(el, v) {
 }
 function computePendingState(el) {
   const comp = el;
-  if (el._optimistic && el._pendingValue !== NOT_PENDING) {
+  const firewall = el._firewall;
+  if (firewall && el._pendingValue !== NOT_PENDING) {
+    return !firewall._inFlight && !(firewall._statusFlags & STATUS_PENDING);
+  }
+  if (el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING) {
     if (comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED))
       return true;
     if (el._parentSource) {
@@ -925,6 +1088,9 @@ function computePendingState(el) {
     }
     return true;
   }
+  if (el._overrideValue !== void 0 && el._overrideValue === NOT_PENDING && !el._parentSource) {
+    return false;
+  }
   if (el._pendingValue !== NOT_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED)) return true;
   return !!(comp._statusFlags & STATUS_PENDING && !(comp._statusFlags & STATUS_UNINITIALIZED));
 }
@@ -1011,7 +1177,7 @@ Object.assign(
   { DELETE }
 );
 
-// ../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.2_@solidjs+signals@0.12.0_solid-js@2.0.0-beta.2/node_modules/@solidjs/web/dist/dev.js
+// ../../node_modules/.pnpm/@solidjs+web@2.0.0-beta.4_@solidjs+signals@0.13.6_solid-js@2.0.0-beta.4/node_modules/@solidjs/web/dist/dev.js
 var effect = (fn, effectFn, initial) => createRenderEffect(fn, effectFn, initial, {
   transparent: true
 });