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

package/build/dev.cjs

@@ -1,6 +1,5 @@
 'use strict';
 
-var web = require('solid-js/web');
 var solidJs = require('solid-js');
 var solidQuery = require('@tanstack/solid-query');
 var queryDevtools = require('@tanstack/query-devtools');
@@ -15,6 +14,1241 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../../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;
+  const height = n._height;
+  const heapAtHeight = heap._heap[height];
+  if (heapAtHeight === void 0) heap._heap[height] = n;
+  else {
+    const tail = heapAtHeight._prevHeap;
+    tail._nextHeap = n;
+    n._prevHeap = tail;
+    heapAtHeight._prevHeap = n;
+  }
+  if (height > heap._max) heap._max = height;
+}
+function insertIntoHeap(n, heap) {
+  let flags = n._flags;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  if (flags & REACTIVE_CHECK) {
+    n._flags = flags & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else n._flags = flags | REACTIVE_IN_HEAP;
+  if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
+}
+function insertIntoHeapHeight(n, heap) {
+  let flags = n._flags;
+  if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  n._flags = flags | REACTIVE_IN_HEAP_HEIGHT;
+  actualInsertIntoHeap(n, heap);
+}
+function deleteFromHeap(n, heap) {
+  const flags = n._flags;
+  if (!(flags & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+  n._flags = flags & -25;
+  const height = n._height;
+  if (n._prevHeap === n) heap._heap[height] = void 0;
+  else {
+    const next = n._nextHeap;
+    const dhh = heap._heap[height];
+    const end = next ?? dhh;
+    if (n === dhh) heap._heap[height] = next;
+    else n._prevHeap._nextHeap = next;
+    end._prevHeap = n._prevHeap;
+  }
+  n._prevHeap = n;
+  n._nextHeap = void 0;
+}
+function runHeap(heap, recompute2) {
+  heap._marked = false;
+  for (heap._min = 0; heap._min <= heap._max; heap._min++) {
+    let el = heap._heap[heap._min];
+    while (el !== void 0) {
+      if (el._flags & REACTIVE_IN_HEAP) recompute2(el);
+      else adjustHeight(el, heap);
+      el = heap._heap[heap._min];
+    }
+  }
+  heap._max = 0;
+}
+function adjustHeight(el, heap) {
+  deleteFromHeap(el, heap);
+  let newHeight = el._height;
+  for (let d = el._deps; d; d = d._nextDep) {
+    const dep1 = d._dep;
+    const dep = dep1._firewall || dep1;
+    if (dep._fn && dep._height >= newHeight) newHeight = dep._height + 1;
+  }
+  if (el._height !== newHeight) {
+    el._height = newHeight;
+    for (let s = el._subs; s !== null; s = s._nextSub) {
+      insertIntoHeapHeight(s._sub, heap);
+    }
+  }
+}
+function runLaneEffects(type) {
+  for (const lane of activeLanes) {
+    if (lane._mergedInto || lane._pendingAsync.size > 0) continue;
+    const effects = lane._effectQueues[type - 1];
+    if (effects.length) {
+      lane._effectQueues[type - 1] = [];
+      runQueue(effects, 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;
+  if (!globalQueue._running && !projectionWriteActive) queueMicrotask(flush);
+}
+function insertSubs(node, optimistic = false) {
+  const sourceLane = node._optimisticLane || currentOptimisticLane;
+  const hasSnapshot = node._snapshotValue !== void 0;
+  for (let s = node._subs; s !== null; s = s._nextSub) {
+    if (hasSnapshot && s._sub._inSnapshotScope) {
+      s._sub._flags |= REACTIVE_SNAPSHOT_STALE;
+      continue;
+    }
+    if (optimistic && sourceLane) {
+      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(s._sub, sourceLane);
+    } else if (optimistic) {
+      s._sub._flags |= REACTIVE_OPTIMISTIC_DIRTY;
+      s._sub._optimisticLane = void 0;
+    }
+    const sub = s._sub;
+    if (sub._type === EFFECT_TRACKED) {
+      if (!sub._modified) {
+        sub._modified = true;
+        sub._queue.enqueue(EFFECT_USER, sub._run);
+      }
+      continue;
+    }
+    const queue = s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (queue._min > s._sub._height) queue._min = s._sub._height;
+    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) {
+  const resolvePending = !incomplete;
+  if (resolvePending) commitPendingNodes();
+  if (!incomplete) checkBoundaryChildren(globalQueue);
+  if (dirtyQueue._max >= dirtyQueue._min) runHeap(dirtyQueue, GlobalQueue._update);
+  if (resolvePending) {
+    commitPendingNodes();
+    resolveOptimisticNodes(
+      completingTransition ? completingTransition._optimisticNodes : globalQueue._optimisticNodes
+    );
+    const optimisticStores = completingTransition ? completingTransition._optimisticStores : globalQueue._optimisticStores;
+    if (GlobalQueue._clearOptimisticStore && optimisticStores.size) {
+      for (const store of optimisticStores) {
+        GlobalQueue._clearOptimisticStore(store);
+      }
+      optimisticStores.clear();
+      schedule();
+    }
+    cleanupCompletedLanes(completingTransition);
+  }
+}
+function checkBoundaryChildren(queue) {
+  for (const child of queue._children) {
+    child.checkSources?.();
+    checkBoundaryChildren(child);
+  }
+}
+function reassignPendingTransition(pendingNodes) {
+  for (let i = 0; i < pendingNodes.length; i++) {
+    pendingNodes[i]._transition = activeTransition;
+  }
+}
+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 || activeTransition) {
+    if (++count === 1e5) throw new Error("Potential Infinite Loop Detected.");
+    globalQueue.flush();
+  }
+}
+function runQueue(queue, type) {
+  for (let i = 0; i < queue.length; i++) queue[i](type);
+}
+function transitionComplete(transition) {
+  if (transition._done) return true;
+  if (transition._actions.length) return false;
+  let done = true;
+  for (let i = 0; i < transition._asyncNodes.length; i++) {
+    const node = transition._asyncNodes[i];
+    if (node._statusFlags & STATUS_PENDING && node._error?.source === node) {
+      done = false;
+      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;
+}
+function currentTransition(transition) {
+  while (transition._done && typeof transition._done === "object") transition = transition._done;
+  return transition;
+}
+function runInTransition(transition, fn) {
+  const prevTransition = activeTransition;
+  try {
+    activeTransition = currentTransition(transition);
+    return fn();
+  } finally {
+    activeTransition = prevTransition;
+  }
+}
+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: /* @__PURE__ */ 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 void 0;
+  const root = findLane(lane);
+  if (activeLanes.has(root)) return root;
+  el._optimisticLane = void 0;
+  return void 0;
+}
+function resolveTransition(el) {
+  return resolveLane(el)?._transition ?? el._transition;
+}
+function hasActiveOverride(el) {
+  return !!(el._overrideValue !== void 0 && 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 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]);
+  const isThenable = !iterator && isObject && untrack(() => typeof result.then === "function");
+  if (!isThenable && !iterator) {
+    el._inFlight = null;
+    return result;
+  }
+  el._inFlight = result;
+  let syncValue;
+  const handleError = (error) => {
+    if (el._inFlight !== result) return;
+    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(resolveTransition(el));
+    clearStatus(el);
+    const lane = resolveLane(el);
+    if (lane) lane._pendingAsync.delete(el);
+    if (el._overrideValue !== void 0) {
+      if (el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING)
+        el._pendingValue = value;
+      else {
+        el._value = value;
+        insertSubs(el);
+      }
+      el._time = clock;
+    } else if (lane) {
+      const prevValue = el._value;
+      const equals = el._equals;
+      if (!equals || !equals(value, prevValue)) {
+        el._value = value;
+        el._time = clock;
+        if (el._latestValueComputed) {
+          setSignal(el._latestValueComputed, value);
+        }
+        insertSubs(el, true);
+      }
+    } else {
+      setSignal(el, () => value);
+    }
+    settlePendingSource(el);
+    schedule();
+    flush();
+    then?.();
+  };
+  if (isThenable) {
+    let resolved = false, isSync = true;
+    result.then(
+      (v) => {
+        if (isSync) {
+          syncValue = v;
+          resolved = true;
+        } else asyncWrite(v);
+      },
+      (e) => {
+        if (!isSync) handleError(e);
+      }
+    );
+    isSync = false;
+    if (!resolved) {
+      globalQueue.initTransition(resolveTransition(el));
+      throw new NotReadyError(context);
+    }
+  }
+  if (iterator) {
+    const it = result[Symbol.asyncIterator]();
+    let hadSyncValue = false;
+    const iterate = () => {
+      let syncResult, resolved = false, isSync = true;
+      it.next().then(
+        (r) => {
+          if (isSync) {
+            syncResult = r;
+            resolved = true;
+          } else if (!r.done) asyncWrite(r.value, iterate);
+          else {
+            schedule();
+            flush();
+          }
+        },
+        (e) => {
+          if (!isSync) handleError(e);
+        }
+      );
+      isSync = false;
+      if (resolved && !syncResult.done) {
+        syncValue = syncResult.value;
+        hadSyncValue = true;
+        return iterate();
+      }
+      return resolved && syncResult.done;
+    };
+    const immediatelyDone = iterate();
+    if (!hadSyncValue && !immediatelyDone) {
+      globalQueue.initTransition(resolveTransition(el));
+      throw new NotReadyError(context);
+    }
+  }
+  return syncValue;
+}
+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 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) {
+    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);
+  }
+  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 {
+      el._notifyStatus();
+    }
+    return;
+  }
+  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);
+    }
+  });
+}
+function markDisposal(el) {
+  let child = el._firstChild;
+  while (child) {
+    child._flags |= REACTIVE_ZOMBIE;
+    if (child._flags & REACTIVE_IN_HEAP) {
+      deleteFromHeap(child, dirtyQueue);
+      insertIntoHeap(child, zombieQueue);
+    }
+    markDisposal(child);
+    child = child._nextSibling;
+  }
+}
+function disposeChildren(node, self = false, zombie) {
+  if (node._flags & REACTIVE_DISPOSED) return;
+  if (self) node._flags = REACTIVE_DISPOSED;
+  let child = zombie ? node._pendingFirstChild : node._firstChild;
+  while (child) {
+    const nextChild = child._nextSibling;
+    if (child._deps) {
+      const n = child;
+      deleteFromHeap(n, n._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let toRemove = n._deps;
+      do {
+        toRemove = unlinkSubs(toRemove);
+      } while (toRemove !== null);
+      n._deps = null;
+      n._depsTail = null;
+    }
+    disposeChildren(child, true);
+    child = nextChild;
+  }
+  if (zombie) {
+    node._pendingFirstChild = null;
+  } else {
+    node._firstChild = null;
+    node._childCount = 0;
+  }
+  runDisposal(node, zombie);
+}
+function runDisposal(node, zombie) {
+  let disposal = zombie ? node._pendingDisposal : node._disposal;
+  if (!disposal) return;
+  if (Array.isArray(disposal)) {
+    for (let i = 0; i < disposal.length; i++) {
+      const callable = disposal[i];
+      callable.call(callable);
+    }
+  } else {
+    disposal.call(disposal);
+  }
+  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) {
+    if (el._transition && (!isEffect || activeTransition) && activeTransition !== el._transition)
+      globalQueue.initTransition(el._transition);
+    deleteFromHeap(el, el._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (el._transition || isEffect === EFFECT_TRACKED) disposeChildren(el);
+    else {
+      markDisposal(el);
+      el._pendingDisposal = el._disposal;
+      el._pendingFirstChild = el._firstChild;
+      el._disposal = null;
+      el._firstChild = null;
+      el._childCount = 0;
+    }
+  }
+  const isOptimisticDirty = !!(el._flags & REACTIVE_OPTIMISTIC_DIRTY);
+  const hasOverride = el._overrideValue !== void 0 && el._overrideValue !== NOT_PENDING;
+  const wasPending = !!(el._statusFlags & STATUS_PENDING);
+  const oldcontext = context;
+  context = el;
+  el._depsTail = null;
+  el._flags = REACTIVE_RECOMPUTING_DEPS;
+  el._time = clock;
+  let value = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
+  let oldHeight = el._height;
+  let prevTracking = tracking;
+  let prevLane = currentOptimisticLane;
+  let prevStrictRead = false;
+  {
+    prevStrictRead = strictRead;
+    strictRead = false;
+  }
+  tracking = true;
+  if (isOptimisticDirty) {
+    const lane = resolveLane(el);
+    if (lane) currentOptimisticLane = lane;
+  }
+  try {
+    value = handleAsync(el, el._fn(value));
+    clearStatus(el, create);
+    const resolvedLane = resolveLane(el);
+    if (resolvedLane) {
+      resolvedLane._pendingAsync.delete(el);
+      updatePendingSignal(resolvedLane._source);
+    }
+  } catch (e) {
+    if (e instanceof NotReadyError && currentOptimisticLane) {
+      const lane = findLane(currentOptimisticLane);
+      if (lane._source !== el) {
+        lane._pendingAsync.add(el);
+        el._optimisticLane = lane;
+        updatePendingSignal(lane._source);
+      }
+    }
+    if (e instanceof NotReadyError) el._blocked = true;
+    notifyStatus(
+      el,
+      e instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
+      e,
+      void 0,
+      e instanceof NotReadyError ? el._optimisticLane : void 0
+    );
+  } finally {
+    tracking = prevTracking;
+    strictRead = prevStrictRead;
+    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;
+    }
+    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._overrideValue : void 0;
+      if (create || isEffect && activeTransition !== el._transition || isOptimisticDirty) {
+        el._value = value;
+        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) {
+      for (let s = el._subs; s !== null; s = s._nextSub) {
+        insertIntoHeapHeight(s._sub, s._sub._flags & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
+    }
+  }
+  currentOptimisticLane = prevLane;
+  (!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 (!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;
+    strictRead = prevStrictRead;
+  }
+}
+function setSignal(el, v) {
+  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._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 && hasOverride && el._fn) {
+      insertSubs(el, true);
+      schedule();
+    }
+    return v;
+  }
+  if (isOptimistic) {
+    const firstOverride = el._overrideValue === NOT_PENDING;
+    if (!firstOverride) globalQueue.initTransition(resolveTransition(el));
+    if (firstOverride) {
+      el._pendingValue = el._value;
+      globalQueue._optimisticNodes.push(el);
+    }
+    el._overrideSinceLane = true;
+    const lane = getOrCreateLane(el);
+    el._optimisticLane = lane;
+    el._overrideValue = v;
+  } else {
+    if (el._pendingValue === NOT_PENDING) globalQueue._pendingNodes.push(el);
+    el._pendingValue = v;
+  }
+  updatePendingSignal(el);
+  if (el._latestValueComputed) {
+    setSignal(el._latestValueComputed, v);
+  }
+  el._time = clock;
+  insertSubs(el, isOptimistic);
+  schedule();
+  return v;
+}
+function computePendingState(el) {
+  const comp = el;
+  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) {
+      const lane = el._optimisticLane ? findLane(el._optimisticLane) : null;
+      return !!(lane && lane._pendingAsync.size > 0);
+    }
+    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));
+}
+function updatePendingSignal(el) {
+  if (el._pendingSignal) {
+    const pending = computePendingState(el);
+    const sig = el._pendingSignal;
+    setSignal(sig, pending);
+    if (!pending && sig._optimisticLane) {
+      const sourceLane = resolveLane(el);
+      if (sourceLane && sourceLane._pendingAsync.size > 0) {
+        const sigLane = findLane(sig._optimisticLane);
+        if (sigLane !== sourceLane) {
+          mergeLanes(sourceLane, sigLane);
+        }
+      }
+      signalLanes.delete(sig);
+      sig._optimisticLane = void 0;
+    }
+  }
+}
+function isWrappable(obj) {
+  return obj != null && typeof obj === "object" && !Object.isFrozen(obj);
+}
+function updatePath(current, args, i = 0) {
+  let part, prev = current;
+  if (i < args.length - 1) {
+    part = args[i];
+    const partType = typeof part;
+    const isArray = Array.isArray(current);
+    if (Array.isArray(part)) {
+      for (let j = 0; j < part.length; j++) {
+        args[i] = part[j];
+        updatePath(current, args, i);
+      }
+      args[i] = part;
+      return;
+    } else if (isArray && partType === "function") {
+      for (let j = 0; j < current.length; j++) {
+        if (part(current[j], j)) {
+          args[i] = j;
+          updatePath(current, args, i);
+        }
+      }
+      args[i] = part;
+      return;
+    } else if (isArray && partType === "object") {
+      const { from = 0, to = current.length - 1, by = 1 } = part;
+      for (let j = from; j <= to; j += by) {
+        args[i] = j;
+        updatePath(current, args, i);
+      }
+      args[i] = part;
+      return;
+    } else if (i < args.length - 2) {
+      updatePath(current[part], args, i + 1);
+      return;
+    }
+    prev = current[part];
+  }
+  let value = args[args.length - 1];
+  if (typeof value === "function") {
+    value = value(prev);
+    if (value === prev) return;
+  }
+  if (part === void 0 && value == void 0) return;
+  if (value === DELETE) {
+    delete current[part];
+  } else if (part === void 0 || isWrappable(prev) && isWrappable(value) && !Array.isArray(value)) {
+    const target = part !== void 0 ? current[part] : current;
+    const keys = Object.keys(value);
+    for (let i2 = 0; i2 < keys.length; i2++) target[keys[i2]] = value[keys[i2]];
+  } else {
+    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, inTrackedQueueCallback, stashedOptimisticReads, Queue, GlobalQueue, globalQueue, signalLanes, activeLanes, externalSourceConfig, tracking, context, currentOptimisticLane, strictRead, DELETE;
+var init_dev = __esm({
+  "../../node_modules/.pnpm/@solidjs+signals@0.13.6/node_modules/@solidjs/signals/dist/dev.js"() {
+    NotReadyError = class extends Error {
+      source;
+      constructor(source) {
+        super();
+        this.source = source;
+      }
+    };
+    StatusError = class extends Error {
+      source;
+      constructor(source, original) {
+        super(original instanceof Error ? original.message : String(original), { cause: original });
+        this.source = source;
+      }
+    };
+    REACTIVE_NONE = 0;
+    REACTIVE_CHECK = 1 << 0;
+    REACTIVE_DIRTY = 1 << 1;
+    REACTIVE_RECOMPUTING_DEPS = 1 << 2;
+    REACTIVE_IN_HEAP = 1 << 3;
+    REACTIVE_IN_HEAP_HEIGHT = 1 << 4;
+    REACTIVE_ZOMBIE = 1 << 5;
+    REACTIVE_DISPOSED = 1 << 6;
+    REACTIVE_OPTIMISTIC_DIRTY = 1 << 7;
+    REACTIVE_SNAPSHOT_STALE = 1 << 8;
+    STATUS_PENDING = 1 << 0;
+    STATUS_ERROR = 1 << 1;
+    STATUS_UNINITIALIZED = 1 << 2;
+    EFFECT_RENDER = 1;
+    EFFECT_USER = 2;
+    EFFECT_TRACKED = 3;
+    NOT_PENDING = {};
+    transitions = /* @__PURE__ */ new Set();
+    dirtyQueue = { _heap: new Array(2e3).fill(void 0), _marked: false, _min: 0, _max: 0 };
+    zombieQueue = { _heap: new Array(2e3).fill(void 0), _marked: false, _min: 0, _max: 0 };
+    clock = 0;
+    activeTransition = null;
+    scheduled = false;
+    projectionWriteActive = false;
+    inTrackedQueueCallback = false;
+    stashedOptimisticReads = null;
+    Queue = class {
+      _parent = null;
+      _queues = [[], []];
+      _children = [];
+      created = clock;
+      addChild(child) {
+        this._children.push(child);
+        child._parent = this;
+      }
+      removeChild(child) {
+        const index = this._children.indexOf(child);
+        if (index >= 0) {
+          this._children.splice(index, 1);
+          child._parent = null;
+        }
+      }
+      notify(node, mask, flags, error) {
+        if (this._parent) return this._parent.notify(node, mask, flags, error);
+        return false;
+      }
+      run(type) {
+        if (this._queues[type - 1].length) {
+          const effects = this._queues[type - 1];
+          this._queues[type - 1] = [];
+          runQueue(effects, type);
+        }
+        for (let i = 0; i < this._children.length; i++) this._children[i].run?.(type);
+      }
+      enqueue(type, fn) {
+        if (type) {
+          if (currentOptimisticLane) {
+            const lane = findLane(currentOptimisticLane);
+            lane._effectQueues[type - 1].push(fn);
+          } else {
+            this._queues[type - 1].push(fn);
+          }
+        }
+        schedule();
+      }
+      stashQueues(stub) {
+        stub._queues[0].push(...this._queues[0]);
+        stub._queues[1].push(...this._queues[1]);
+        this._queues = [[], []];
+        for (let i = 0; i < this._children.length; i++) {
+          let child = this._children[i];
+          let childStub = stub._children[i];
+          if (!childStub) {
+            childStub = { _queues: [[], []], _children: [] };
+            stub._children[i] = childStub;
+          }
+          child.stashQueues(childStub);
+        }
+      }
+      restoreQueues(stub) {
+        this._queues[0].push(...stub._queues[0]);
+        this._queues[1].push(...stub._queues[1]);
+        for (let i = 0; i < stub._children.length; i++) {
+          const childStub = stub._children[i];
+          let child = this._children[i];
+          if (child) child.restoreQueues(childStub);
+        }
+      }
+    };
+    GlobalQueue = class _GlobalQueue extends Queue {
+      _running = false;
+      _pendingNodes = [];
+      _optimisticNodes = [];
+      _optimisticStores = /* @__PURE__ */ new Set();
+      static _update;
+      static _dispose;
+      static _clearOptimisticStore = null;
+      flush() {
+        if (this._running) return;
+        this._running = true;
+        try {
+          runHeap(dirtyQueue, _GlobalQueue._update);
+          if (activeTransition) {
+            const isComplete = transitionComplete(activeTransition);
+            if (!isComplete) {
+              const stashedTransition = activeTransition;
+              runHeap(zombieQueue, _GlobalQueue._update);
+              this._pendingNodes = [];
+              this._optimisticNodes = [];
+              this._optimisticStores = /* @__PURE__ */ new Set();
+              runLaneEffects(EFFECT_RENDER);
+              runLaneEffects(EFFECT_USER);
+              this.stashQueues(stashedTransition._queueStash);
+              clock++;
+              scheduled = dirtyQueue._max >= dirtyQueue._min;
+              reassignPendingTransition(stashedTransition._pendingNodes);
+              activeTransition = null;
+              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);
+            this.restoreQueues(activeTransition._queueStash);
+            transitions.delete(activeTransition);
+            const completingTransition = activeTransition;
+            activeTransition = null;
+            reassignPendingTransition(this._pendingNodes);
+            finalizePureQueue(completingTransition);
+          } else {
+            if (transitions.size) runHeap(zombieQueue, _GlobalQueue._update);
+            finalizePureQueue();
+          }
+          clock++;
+          scheduled = dirtyQueue._max >= dirtyQueue._min;
+          runLaneEffects(EFFECT_RENDER);
+          this.run(EFFECT_RENDER);
+          runLaneEffects(EFFECT_USER);
+          this.run(EFFECT_USER);
+        } finally {
+          this._running = false;
+        }
+      }
+      notify(node, mask, flags, error) {
+        if (mask & STATUS_PENDING) {
+          if (flags & STATUS_PENDING) {
+            const actualError = error !== void 0 ? error : node._error;
+            if (activeTransition && actualError) {
+              const source = actualError.source;
+              if (!activeTransition._asyncNodes.includes(source)) {
+                activeTransition._asyncNodes.push(source);
+                schedule();
+              }
+            }
+          }
+          return true;
+        }
+        return false;
+      }
+      initTransition(transition) {
+        if (transition) transition = currentTransition(transition);
+        if (transition && transition === activeTransition) return;
+        if (!transition && activeTransition && activeTransition._time === clock) return;
+        if (!activeTransition) {
+          activeTransition = transition ?? {
+            _time: clock,
+            _pendingNodes: [],
+            _asyncNodes: [],
+            _optimisticNodes: [],
+            _optimisticStores: /* @__PURE__ */ new Set(),
+            _actions: [],
+            _queueStash: { _queues: [[], []], _children: [] },
+            _done: false
+          };
+        } else if (transition) {
+          const outgoing = activeTransition;
+          mergeTransitionState(transition, outgoing);
+          transitions.delete(outgoing);
+          activeTransition = transition;
+        }
+        transitions.add(activeTransition);
+        activeTransition._time = clock;
+        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;
+        }
+        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;
+        }
+        for (const lane of activeLanes) {
+          if (!lane._transition) lane._transition = activeTransition;
+        }
+        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();
+    externalSourceConfig = null;
+    GlobalQueue._update = recompute;
+    GlobalQueue._dispose = disposeChildren;
+    tracking = false;
+    context = null;
+    currentOptimisticLane = null;
+    strictRead = false;
+    DELETE = /* @__PURE__ */ Symbol("STORE_PATH_DELETE");
+    Object.assign(
+      function storePath2(...args) {
+        return (state) => {
+          updatePath(state, args);
+        };
+      },
+      { DELETE }
+    );
+  }
+});
+function template(html, isImportNode, isSVG, isMathML) {
+  let node;
+  const create = (bypassGuard) => {
+    if (isHydrating() && !bypassGuard) throw new Error("Failed attempt to create new DOM elements during hydration. Check that the libraries you are using support hydration.");
+    const t = document.createElement("template");
+    t.innerHTML = html;
+    return t.content.firstChild;
+  };
+  const fn = isImportNode ? (bypassGuard) => solidJs.untrack(() => document.importNode(node || (node = create(bypassGuard)), true)) : (bypassGuard) => (node || (node = create(bypassGuard))).cloneNode(true);
+  fn._html = html;
+  return fn;
+}
+function setAttribute(node, name, value) {
+  if (isHydrating(node)) return;
+  node.removeAttribute(name);
+}
+function style(node, value, prev) {
+  if (!value) {
+    if (prev) setAttribute(node, "style");
+    return;
+  }
+  const nodeStyle = node.style;
+  if (typeof value === "string") return nodeStyle.cssText = value;
+  typeof prev === "string" && (nodeStyle.cssText = prev = void 0);
+  prev || (prev = {});
+  value || (value = {});
+  let v, s;
+  for (s in value) {
+    v = value[s];
+    if (v !== prev[s]) nodeStyle.setProperty(s, v);
+    delete prev[s];
+  }
+  for (s in prev) value[s] == null && nodeStyle.removeProperty(s);
+}
+function applyRef(r, element) {
+  Array.isArray(r) ? r.flat(Infinity).forEach((f) => f && f(element)) : r(element);
+}
+function ref(fn, element) {
+  const resolved = solidJs.untrack(fn);
+  solidJs.runWithOwner(null, () => applyRef(resolved, element));
+}
+function isHydrating(node) {
+  return solidJs.sharedConfig.hydrating && (!node || node.isConnected);
+}
+var effect, isServer, isDev;
+var init_dev2 = __esm({
+  "../../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
+    });
+    isServer = false;
+    isDev = true;
+  }
+});
+
 // src/devtools.tsx
 var devtools_exports = {};
 __export(devtools_exports, {
@@ -23,7 +1257,7 @@ __export(devtools_exports, {
 function SolidQueryDevtools(props) {
   const queryClient = solidQuery.useQueryClient(props.client);
   const client = solidJs.createMemo(() => queryClient);
-  let ref;
+  let ref2;
   const devtools = new queryDevtools.TanstackQueryDevtools({
     client: client(),
     queryFlavor: "Solid Query",
@@ -38,45 +1272,54 @@ function SolidQueryDevtools(props) {
     hideDisabledQueries: props.hideDisabledQueries,
     theme: props.theme
   });
-  solidJs.createEffect(() => {
-    devtools.setClient(client());
+  solidJs.createEffect(() => client(), (c) => {
+    devtools.setClient(c);
   });
-  solidJs.createEffect(() => {
-    const buttonPos = props.buttonPosition;
+  solidJs.createEffect(() => props.buttonPosition, (buttonPos) => {
     if (buttonPos) {
       devtools.setButtonPosition(buttonPos);
     }
   });
-  solidJs.createEffect(() => {
-    const pos = props.position;
+  solidJs.createEffect(() => props.position, (pos) => {
     if (pos) {
       devtools.setPosition(pos);
     }
   });
-  solidJs.createEffect(() => {
-    devtools.setInitialIsOpen(props.initialIsOpen || false);
+  solidJs.createEffect(() => props.initialIsOpen, (initialIsOpen) => {
+    devtools.setInitialIsOpen(initialIsOpen || false);
   });
-  solidJs.createEffect(() => {
-    devtools.setErrorTypes(props.errorTypes || []);
+  solidJs.createEffect(() => props.errorTypes, (errorTypes) => {
+    devtools.setErrorTypes(errorTypes || []);
   });
-  solidJs.createEffect(() => {
-    devtools.setTheme(props.theme || "system");
+  solidJs.createEffect(() => props.theme, (theme) => {
+    devtools.setTheme(theme || "system");
   });
-  solidJs.onMount(() => {
-    devtools.mount(ref);
-    solidJs.onCleanup(() => devtools.unmount());
+  let isMounted = false;
+  let isDisposed = false;
+  queueMicrotask(() => {
+    if (isDisposed) return;
+    devtools.mount(ref2);
+    isMounted = true;
+  });
+  solidJs.onCleanup(() => {
+    isDisposed = true;
+    if (isMounted) {
+      devtools.unmount();
+    }
   });
   return (() => {
     var _el$ = _tmpl$();
-    var _ref$ = ref;
-    typeof _ref$ === "function" ? web.use(_ref$, _el$) : ref = _el$;
+    var _ref$ = ref2;
+    typeof _ref$ === "function" || Array.isArray(_ref$) ? ref(() => _ref$, _el$) : ref2 = _el$;
     return _el$;
   })();
 }
 var _tmpl$;
 var init_devtools = __esm({
   "src/devtools.tsx"() {
-    _tmpl$ = /* @__PURE__ */ web.template(`<div class=tsqd-parent-container>`);
+    init_dev2();
+    init_dev2();
+    _tmpl$ = /* @__PURE__ */ template(`<div class=tsqd-parent-container>`);
   }
 });
 
@@ -88,7 +1331,7 @@ __export(devtoolsPanel_exports, {
 function SolidQueryDevtoolsPanel(props) {
   const queryClient = solidQuery.useQueryClient(props.client);
   const client = solidJs.createMemo(() => queryClient);
-  let ref;
+  let ref2;
   const {
     errorTypes,
     styleNonce,
@@ -110,58 +1353,81 @@ function SolidQueryDevtoolsPanel(props) {
     hideDisabledQueries,
     theme: props.theme
   });
-  solidJs.createEffect(() => {
-    devtools.setClient(client());
+  solidJs.createEffect(() => client(), (c) => {
+    devtools.setClient(c);
   });
-  solidJs.createEffect(() => {
-    devtools.setOnClose(props.onClose ?? (() => {
+  solidJs.createEffect(() => props.onClose, (onClose) => {
+    devtools.setOnClose(onClose ?? (() => {
     }));
   });
-  solidJs.createEffect(() => {
-    devtools.setErrorTypes(props.errorTypes || []);
+  solidJs.createEffect(() => props.errorTypes, (errorTypes2) => {
+    devtools.setErrorTypes(errorTypes2 || []);
   });
-  solidJs.createEffect(() => {
-    devtools.setTheme(props.theme || "system");
+  solidJs.createEffect(() => props.theme, (theme) => {
+    devtools.setTheme(theme || "system");
   });
-  solidJs.onMount(() => {
-    devtools.mount(ref);
-    solidJs.onCleanup(() => devtools.unmount());
+  let isMounted = false;
+  let isDisposed = false;
+  queueMicrotask(() => {
+    if (isDisposed) return;
+    devtools.mount(ref2);
+    isMounted = true;
+  });
+  solidJs.onCleanup(() => {
+    isDisposed = true;
+    if (isMounted) {
+      devtools.unmount();
+    }
   });
   return (() => {
     var _el$ = _tmpl$2();
-    var _ref$ = ref;
-    typeof _ref$ === "function" ? web.use(_ref$, _el$) : ref = _el$;
-    web.effect((_$p) => web.style(_el$, {
+    var _ref$ = ref2;
+    typeof _ref$ === "function" || Array.isArray(_ref$) ? ref(() => _ref$, _el$) : ref2 = _el$;
+    effect(() => ({
       ...props.style
-    }, _$p));
+    }), (_v$, _$p) => {
+      style(_el$, _v$, _$p);
+    });
     return _el$;
   })();
 }
 var _tmpl$2;
 var init_devtoolsPanel = __esm({
   "src/devtoolsPanel.tsx"() {
-    _tmpl$2 = /* @__PURE__ */ web.template(`<div class=tsqd-parent-container style=height:500px>`);
+    init_dev2();
+    init_dev2();
+    init_dev2();
+    init_dev2();
+    _tmpl$2 = /* @__PURE__ */ template(`<div class=tsqd-parent-container style=height:500px>`);
   }
 });
+
+// src/index.tsx
+init_dev2();
+
+// src/clientOnly.tsx
+init_dev2();
 function clientOnly(fn) {
-  if (web.isServer) return (props) => props.fallback;
+  if (isServer) return (props) => props.fallback;
   const [comp, setComp] = solidJs.createSignal();
   fn().then((m) => setComp(() => m.default));
   return (props) => {
     let Comp;
     let m;
-    const [, rest] = solidJs.splitProps(props, ["fallback"]);
-    if ((Comp = comp()) && !solidJs.sharedConfig.context) return Comp(rest);
-    const [mounted, setMounted] = solidJs.createSignal(!solidJs.sharedConfig.context);
-    solidJs.onMount(() => setMounted(true));
+    const rest = solidJs.omit(props, "fallback");
+    if ((Comp = comp()) && !solidJs.sharedConfig.hydrating) return Comp(rest);
+    const [mounted, setMounted] = solidJs.createSignal(!solidJs.sharedConfig.hydrating);
+    solidJs.onSettled(() => {
+      setMounted(true);
+    });
     return solidJs.createMemo(() => (Comp = comp(), m = mounted(), solidJs.untrack(() => Comp && m ? Comp(rest) : props.fallback)));
   };
 }
 
 // src/index.tsx
-exports.SolidQueryDevtools = web.isDev ? clientOnly(() => Promise.resolve().then(() => (init_devtools(), devtools_exports))) : function() {
+exports.SolidQueryDevtools = isDev ? clientOnly(() => Promise.resolve().then(() => (init_devtools(), devtools_exports))) : function() {
   return null;
 };
-exports.SolidQueryDevtoolsPanel = web.isDev ? clientOnly(() => Promise.resolve().then(() => (init_devtoolsPanel(), devtoolsPanel_exports))) : function() {
+exports.SolidQueryDevtoolsPanel = isDev ? clientOnly(() => Promise.resolve().then(() => (init_devtoolsPanel(), devtoolsPanel_exports))) : function() {
   return null;
 };