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

package/build/dev.cjs

@@ -14,7 +14,7 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../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
 function actualInsertIntoHeap(n, heap) {
   const parentHeight = (n._parent?._root ? n._parent._parentComputed?._height : n._parent?._height) ?? -1;
   if (parentHeight >= n._height) n._height = parentHeight + 1;
@@ -97,6 +97,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;
@@ -130,36 +189,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) {
@@ -168,20 +221,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) {
@@ -196,8 +236,16 @@ function reassignPendingTransition(pendingNodes) {
   }
 }
 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();
   }
@@ -216,6 +264,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;
 }
@@ -249,7 +306,7 @@ function getOrCreateLane(signal) {
   };
   signalLanes.set(signal, lane);
   activeLanes.add(lane);
-  signal._laneVersion = signal._overrideVersion || 0;
+  signal._overrideSinceLane = false;
   return lane;
 }
 function findLane(lane) {
@@ -274,8 +331,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);
@@ -298,6 +358,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]);
@@ -310,21 +460,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);
       }
@@ -343,6 +493,7 @@ function handleAsync(el, result, setter) {
     } else {
       setSignal(el, () => value);
     }
+    settlePendingSource(el);
     schedule();
     flush();
     then?.();
@@ -362,7 +513,7 @@ function handleAsync(el, result, setter) {
     );
     isSync = false;
     if (!resolved) {
-      globalQueue.initTransition(el._transition);
+      globalQueue.initTransition(resolveTransition(el));
       throw new NotReadyError(context);
     }
   }
@@ -396,41 +547,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 {
@@ -438,48 +596,13 @@ 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);
+  });
 }
 function markDisposal(el) {
   let child = el._firstChild;
@@ -516,7 +639,6 @@ function disposeChildren(node, self = false, zombie) {
     node._pendingFirstChild = null;
   } else {
     node._firstChild = null;
-    node._nextSibling = null;
     node._childCount = 0;
   }
   runDisposal(node, zombie);
@@ -534,6 +656,32 @@ function runDisposal(node, zombie) {
   }
   zombie ? node._pendingDisposal = null : node._disposal = null;
 }
+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);
+}
 function recompute(el, create = false) {
   const isEffect = el._type;
   if (!create) {
@@ -551,7 +699,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;
@@ -574,7 +722,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);
@@ -589,6 +737,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,
@@ -612,21 +761,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) {
@@ -636,16 +785,17 @@ 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));
 }
 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;
@@ -653,36 +803,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;
@@ -698,7 +845,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) {
@@ -707,6 +858,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));
 }
@@ -783,9 +937,9 @@ function updatePath(current, args, i = 0) {
     current[part] = value;
   }
 }
-var NotReadyError, StatusError, REACTIVE_NONE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_RECOMPUTING_DEPS, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, REACTIVE_DISPOSED, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_SNAPSHOT_STALE, STATUS_PENDING, STATUS_ERROR, STATUS_UNINITIALIZED, EFFECT_RENDER, EFFECT_USER, EFFECT_TRACKED, NOT_PENDING, transitions, dirtyQueue, zombieQueue, clock, activeTransition, scheduled, projectionWriteActive, _onUnhandledAsync, Queue, GlobalQueue, globalQueue, signalLanes, activeLanes, leafEffectActive, tracking, context, currentOptimisticLane, strictRead, DELETE;
+var NotReadyError, StatusError, REACTIVE_NONE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_RECOMPUTING_DEPS, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_ZOMBIE, REACTIVE_DISPOSED, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_SNAPSHOT_STALE, STATUS_PENDING, STATUS_ERROR, STATUS_UNINITIALIZED, EFFECT_RENDER, EFFECT_USER, EFFECT_TRACKED, NOT_PENDING, transitions, dirtyQueue, zombieQueue, clock, activeTransition, scheduled, projectionWriteActive, inTrackedQueueCallback, stashedOptimisticReads, Queue, GlobalQueue, globalQueue, signalLanes, activeLanes, externalSourceConfig, tracking, context, currentOptimisticLane, strictRead, DELETE;
 var init_dev = __esm({
-  "../../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"() {
     NotReadyError = class extends Error {
       source;
       constructor(source) {
@@ -824,7 +978,8 @@ var init_dev = __esm({
     activeTransition = null;
     scheduled = false;
     projectionWriteActive = false;
-    _onUnhandledAsync = null;
+    inTrackedQueueCallback = false;
+    stashedOptimisticReads = null;
     Queue = class {
       _parent = null;
       _queues = [[], []];
@@ -904,19 +1059,32 @@ var init_dev = __esm({
           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);
@@ -942,14 +1110,14 @@ var init_dev = __esm({
       }
       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;
@@ -973,43 +1141,41 @@ var init_dev = __esm({
           };
         } 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;
+        }
       }
     };
     globalQueue = new GlobalQueue();
     signalLanes = /* @__PURE__ */ new WeakMap();
     activeLanes = /* @__PURE__ */ new Set();
-    leafEffectActive = false;
+    externalSourceConfig = null;
     GlobalQueue._update = recompute;
     GlobalQueue._dispose = disposeChildren;
     tracking = false;
@@ -1073,7 +1239,7 @@ function isHydrating(node) {
 }
 var effect, isServer, isDev;
 var init_dev2 = __esm({
-  "../../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"() {
     init_dev();
     effect = (fn, effectFn, initial) => solidJs.createRenderEffect(fn, effectFn, initial, {
       transparent: true
@@ -1128,9 +1294,18 @@ function SolidQueryDevtools(props) {
   solidJs.createEffect(() => props.theme, (theme) => {
     devtools.setTheme(theme || "system");
   });
-  solidJs.onSettled(() => {
+  let isMounted = false;
+  let isDisposed = false;
+  queueMicrotask(() => {
+    if (isDisposed) return;
     devtools.mount(ref2);
-    solidJs.onCleanup(() => devtools.unmount());
+    isMounted = true;
+  });
+  solidJs.onCleanup(() => {
+    isDisposed = true;
+    if (isMounted) {
+      devtools.unmount();
+    }
   });
   return (() => {
     var _el$ = _tmpl$();
@@ -1191,9 +1366,18 @@ function SolidQueryDevtoolsPanel(props) {
   solidJs.createEffect(() => props.theme, (theme) => {
     devtools.setTheme(theme || "system");
   });
-  solidJs.onSettled(() => {
+  let isMounted = false;
+  let isDisposed = false;
+  queueMicrotask(() => {
+    if (isDisposed) return;
     devtools.mount(ref2);
-    solidJs.onCleanup(() => devtools.unmount());
+    isMounted = true;
+  });
+  solidJs.onCleanup(() => {
+    isDisposed = true;
+    if (isMounted) {
+      devtools.unmount();
+    }
   });
   return (() => {
     var _el$ = _tmpl$2();