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

package/build/index.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,1205 @@ 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/prod.js
+function actualInsertIntoHeap(e, t) {
+  const n = (e.i?.t ? e.i.u?.o : e.i?.o) ?? -1;
+  if (n >= e.o) e.o = n + 1;
+  const i = e.o;
+  const r = t.l[i];
+  if (r === void 0) t.l[i] = e;
+  else {
+    const t2 = r.T;
+    t2.S = e;
+    e.T = t2;
+    r.T = e;
+  }
+  if (i > t.R) t.R = i;
+}
+function insertIntoHeap(e, t) {
+  let n = e.O;
+  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS)) return;
+  if (n & REACTIVE_CHECK) {
+    e.O = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+  } else e.O = n | REACTIVE_IN_HEAP;
+  if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
+}
+function insertIntoHeapHeight(e, t) {
+  let n = e.O;
+  if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT)) return;
+  e.O = n | REACTIVE_IN_HEAP_HEIGHT;
+  actualInsertIntoHeap(e, t);
+}
+function deleteFromHeap(e, t) {
+  const n = e.O;
+  if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
+  e.O = n & -25;
+  const i = e.o;
+  if (e.T === e) t.l[i] = void 0;
+  else {
+    const n2 = e.S;
+    const r = t.l[i];
+    const s = n2 ?? r;
+    if (e === r) t.l[i] = n2;
+    else e.T.S = n2;
+    s.T = e.T;
+  }
+  e.T = e;
+  e.S = void 0;
+}
+function runHeap(e, t) {
+  e._ = false;
+  for (e.P = 0; e.P <= e.R; e.P++) {
+    let n = e.l[e.P];
+    while (n !== void 0) {
+      if (n.O & REACTIVE_IN_HEAP) t(n);
+      else adjustHeight(n, e);
+      n = e.l[e.P];
+    }
+  }
+  e.R = 0;
+}
+function adjustHeight(e, t) {
+  deleteFromHeap(e, t);
+  let n = e.o;
+  for (let t2 = e.C; t2; t2 = t2.D) {
+    const e2 = t2.m;
+    const i = e2.V || e2;
+    if (i.L && i.o >= n) n = i.o + 1;
+  }
+  if (e.o !== n) {
+    e.o = n;
+    for (let n2 = e.I; n2 !== null; n2 = n2.p) {
+      insertIntoHeapHeight(n2.h, t);
+    }
+  }
+}
+function runLaneEffects(e) {
+  for (const t of activeLanes) {
+    if (t.U || t.k.size > 0) continue;
+    const n = t.G[e - 1];
+    if (n.length) {
+      t.G[e - 1] = [];
+      runQueue(n, e);
+    }
+  }
+}
+function queueStashedOptimisticEffects(e) {
+  for (let t = e.I; t !== null; t = t.p) {
+    const e2 = t.h;
+    if (!e2.W) continue;
+    if (e2.W === EFFECT_TRACKED) {
+      if (!e2.H) {
+        e2.H = true;
+        e2.F.enqueue(EFFECT_USER, e2.M);
+      }
+      continue;
+    }
+    const n = e2.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (n.P > e2.o) n.P = e2.o;
+    insertIntoHeap(e2, n);
+  }
+}
+function mergeTransitionState(e, t) {
+  t.$ = e;
+  e.j.push(...t.j);
+  for (const n of activeLanes) {
+    if (n.K === t) n.K = e;
+  }
+  e.Y.push(...t.Y);
+  for (const n of t.Z) e.Z.add(n);
+  for (const n of t.B) {
+    if (!e.B.includes(n)) e.B.push(n);
+  }
+}
+function resolveOptimisticNodes(e) {
+  for (let t = 0; t < e.length; t++) {
+    const n = e[t];
+    n.q = void 0;
+    if (n.X !== NOT_PENDING) {
+      n.J = n.X;
+      n.X = NOT_PENDING;
+    }
+    const i = n.ee;
+    n.ee = NOT_PENDING;
+    if (i !== NOT_PENDING && n.J !== i) insertSubs(n, true);
+    n.K = null;
+  }
+  e.length = 0;
+}
+function cleanupCompletedLanes(e) {
+  for (const t of activeLanes) {
+    const n = e ? t.K === e : !t.K;
+    if (!n) continue;
+    if (!t.U) {
+      if (t.G[0].length) runQueue(t.G[0], EFFECT_RENDER);
+      if (t.G[1].length) runQueue(t.G[1], EFFECT_USER);
+    }
+    if (t.te.q === t) t.te.q = void 0;
+    t.k.clear();
+    t.G[0].length = 0;
+    t.G[1].length = 0;
+    activeLanes.delete(t);
+    signalLanes.delete(t.te);
+  }
+}
+function schedule() {
+  if (scheduled) return;
+  scheduled = true;
+  if (!globalQueue.ne && !projectionWriteActive) queueMicrotask(flush);
+}
+function insertSubs(e, t = false) {
+  const n = e.q || currentOptimisticLane;
+  const i = e.Te !== void 0;
+  for (let r = e.I; r !== null; r = r.p) {
+    if (i && r.h.de) {
+      r.h.O |= REACTIVE_SNAPSHOT_STALE;
+      continue;
+    }
+    if (t && n) {
+      r.h.O |= REACTIVE_OPTIMISTIC_DIRTY;
+      assignOrMergeLane(r.h, n);
+    } else if (t) {
+      r.h.O |= REACTIVE_OPTIMISTIC_DIRTY;
+      r.h.q = void 0;
+    }
+    const e2 = r.h;
+    if (e2.W === EFFECT_TRACKED) {
+      if (!e2.H) {
+        e2.H = true;
+        e2.F.enqueue(EFFECT_USER, e2.M);
+      }
+      continue;
+    }
+    const s = r.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    if (s.P > r.h.o) s.P = r.h.o;
+    insertIntoHeap(r.h, s);
+  }
+}
+function commitPendingNodes() {
+  const e = globalQueue.se;
+  for (let t = 0; t < e.length; t++) {
+    const n = e[t];
+    if (n.X !== NOT_PENDING) {
+      n.J = n.X;
+      n.X = NOT_PENDING;
+      if (n.W && n.W !== EFFECT_TRACKED) n.H = true;
+    }
+    if (!(n.Se & STATUS_PENDING)) n.Se &= ~STATUS_UNINITIALIZED;
+    if (n.L) GlobalQueue.ue(n, false, true);
+  }
+  e.length = 0;
+}
+function finalizePureQueue(e = null, t = false) {
+  const n = !t;
+  if (n) commitPendingNodes();
+  if (!t) checkBoundaryChildren(globalQueue);
+  if (dirtyQueue.R >= dirtyQueue.P) runHeap(dirtyQueue, GlobalQueue.oe);
+  if (n) {
+    commitPendingNodes();
+    resolveOptimisticNodes(e ? e.Y : globalQueue.Y);
+    const t2 = e ? e.Z : globalQueue.Z;
+    if (GlobalQueue.ce && t2.size) {
+      for (const e2 of t2) {
+        GlobalQueue.ce(e2);
+      }
+      t2.clear();
+      schedule();
+    }
+    cleanupCompletedLanes(e);
+  }
+}
+function checkBoundaryChildren(e) {
+  for (const t of e.re) {
+    t.checkSources?.();
+    checkBoundaryChildren(t);
+  }
+}
+function reassignPendingTransition(e) {
+  for (let t = 0; t < e.length; t++) {
+    e[t].K = activeTransition;
+  }
+}
+function flush() {
+  if (globalQueue.ne) {
+    return;
+  }
+  while (scheduled || activeTransition) {
+    globalQueue.flush();
+  }
+}
+function runQueue(e, t) {
+  for (let n = 0; n < e.length; n++) e[n](t);
+}
+function transitionComplete(e) {
+  if (e.$) return true;
+  if (e.j.length) return false;
+  let t = true;
+  for (let n = 0; n < e.B.length; n++) {
+    const i = e.B[n];
+    if (i.Se & STATUS_PENDING && i.le?.source === i) {
+      t = false;
+      break;
+    }
+  }
+  if (t) {
+    for (let n = 0; n < e.Y.length; n++) {
+      const i = e.Y[n];
+      if (hasActiveOverride(i) && "Se" in i && i.Se & STATUS_PENDING && i.le instanceof NotReadyError && i.le.source !== i) {
+        t = false;
+        break;
+      }
+    }
+  }
+  t && (e.$ = true);
+  return t;
+}
+function currentTransition(e) {
+  while (e.$ && typeof e.$ === "object") e = e.$;
+  return e;
+}
+function runInTransition(e, t) {
+  const n = activeTransition;
+  try {
+    activeTransition = currentTransition(e);
+    return t();
+  } finally {
+    activeTransition = n;
+  }
+}
+function getOrCreateLane(e) {
+  let t = signalLanes.get(e);
+  if (t) {
+    return findLane(t);
+  }
+  const n = e.Re;
+  const i = n?.q ? findLane(n.q) : null;
+  t = { te: e, k: /* @__PURE__ */ new Set(), G: [[], []], U: null, K: activeTransition, Oe: i };
+  signalLanes.set(e, t);
+  activeLanes.add(t);
+  e._e = false;
+  return t;
+}
+function findLane(e) {
+  while (e.U) e = e.U;
+  return e;
+}
+function mergeLanes(e, t) {
+  e = findLane(e);
+  t = findLane(t);
+  if (e === t) return e;
+  t.U = e;
+  for (const n of t.k) e.k.add(n);
+  e.G[0].push(...t.G[0]);
+  e.G[1].push(...t.G[1]);
+  return e;
+}
+function resolveLane(e) {
+  const t = e.q;
+  if (!t) return void 0;
+  const n = findLane(t);
+  if (activeLanes.has(n)) return n;
+  e.q = void 0;
+  return void 0;
+}
+function resolveTransition(e) {
+  return resolveLane(e)?.K ?? e.K;
+}
+function hasActiveOverride(e) {
+  return !!(e.ee !== void 0 && e.ee !== NOT_PENDING);
+}
+function assignOrMergeLane(e, t) {
+  const n = findLane(t);
+  const i = e.q;
+  if (i) {
+    if (i.U) {
+      e.q = t;
+      return;
+    }
+    const r = findLane(i);
+    if (activeLanes.has(r)) {
+      if (r !== n && !hasActiveOverride(e)) {
+        if (n.Oe && findLane(n.Oe) === r) {
+          e.q = t;
+        } else if (r.Oe && findLane(r.Oe) === n) ;
+        else mergeLanes(n, r);
+      }
+      return;
+    }
+  }
+  e.q = t;
+}
+function addPendingSource(e, t) {
+  if (e.Ie === t || e.pe?.has(t)) return false;
+  if (!e.Ie) {
+    e.Ie = t;
+    return true;
+  }
+  if (!e.pe) {
+    e.pe = /* @__PURE__ */ new Set([e.Ie, t]);
+  } else {
+    e.pe.add(t);
+  }
+  e.Ie = void 0;
+  return true;
+}
+function removePendingSource(e, t) {
+  if (e.Ie) {
+    if (e.Ie !== t) return false;
+    e.Ie = void 0;
+    return true;
+  }
+  if (!e.pe?.delete(t)) return false;
+  if (e.pe.size === 1) {
+    e.Ie = e.pe.values().next().value;
+    e.pe = void 0;
+  } else if (e.pe.size === 0) {
+    e.pe = void 0;
+  }
+  return true;
+}
+function clearPendingSources(e) {
+  e.Ie = void 0;
+  e.pe?.clear();
+  e.pe = void 0;
+}
+function setPendingError(e, t, n) {
+  if (!t) {
+    e.le = null;
+    return;
+  }
+  if (n instanceof NotReadyError && n.source === t) {
+    e.le = n;
+    return;
+  }
+  const i = e.le;
+  if (!(i instanceof NotReadyError) || i.source !== t) {
+    e.le = new NotReadyError(t);
+  }
+}
+function forEachDependent(e, t) {
+  for (let n = e.I; n !== null; n = n.p) t(n.h);
+  for (let n = e.A; n !== null; n = n.N) {
+    for (let e2 = n.I; e2 !== null; e2 = e2.p) t(e2.h);
+  }
+}
+function settlePendingSource(e) {
+  let t = false;
+  const n = /* @__PURE__ */ new Set();
+  const settle = (i) => {
+    if (n.has(i) || !removePendingSource(i, e)) return;
+    n.add(i);
+    i.Ee = clock;
+    const r = i.Ie ?? i.pe?.values().next().value;
+    if (r) {
+      setPendingError(i, r);
+      updatePendingSignal(i);
+    } else {
+      i.Se &= ~STATUS_PENDING;
+      setPendingError(i);
+      updatePendingSignal(i);
+      if (i.he) {
+        if (i.W === EFFECT_TRACKED) {
+          const e2 = i;
+          if (!e2.H) {
+            e2.H = true;
+            e2.F.enqueue(EFFECT_USER, e2.M);
+          }
+        } else {
+          const e2 = i.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+          if (e2.P > i.o) e2.P = i.o;
+          insertIntoHeap(i, e2);
+        }
+        t = true;
+      }
+      i.he = false;
+    }
+    forEachDependent(i, settle);
+  };
+  forEachDependent(e, settle);
+  if (t) schedule();
+}
+function handleAsync(e, t, n) {
+  const i = typeof t === "object" && t !== null;
+  const r = i && untrack(() => t[Symbol.asyncIterator]);
+  const s = !r && i && untrack(() => typeof t.then === "function");
+  if (!s && !r) {
+    e.Ae = null;
+    return t;
+  }
+  e.Ae = t;
+  let o;
+  const handleError = (n2) => {
+    if (e.Ae !== t) return;
+    globalQueue.initTransition(resolveTransition(e));
+    notifyStatus(e, n2 instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n2);
+    e.Ee = clock;
+  };
+  const asyncWrite = (i2, r2) => {
+    if (e.Ae !== t) return;
+    if (e.O & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+    globalQueue.initTransition(resolveTransition(e));
+    clearStatus(e);
+    const s2 = resolveLane(e);
+    if (s2) s2.k.delete(e);
+    if (e.ee !== void 0) {
+      if (e.ee !== void 0 && e.ee !== NOT_PENDING) e.X = i2;
+      else {
+        e.J = i2;
+        insertSubs(e);
+      }
+      e.Ee = clock;
+    } else if (s2) {
+      const t2 = e.J;
+      const n2 = e.Ne;
+      if (!n2 || !n2(i2, t2)) {
+        e.J = i2;
+        e.Ee = clock;
+        if (e.Pe) {
+          setSignal(e.Pe, i2);
+        }
+        insertSubs(e, true);
+      }
+    } else {
+      setSignal(e, () => i2);
+    }
+    settlePendingSource(e);
+    schedule();
+    flush();
+    r2?.();
+  };
+  if (s) {
+    let n2 = false, i2 = true;
+    t.then(
+      (e2) => {
+        if (i2) {
+          o = e2;
+          n2 = true;
+        } else asyncWrite(e2);
+      },
+      (e2) => {
+        if (!i2) handleError(e2);
+      }
+    );
+    i2 = false;
+    if (!n2) {
+      globalQueue.initTransition(resolveTransition(e));
+      throw new NotReadyError(context);
+    }
+  }
+  if (r) {
+    const n2 = t[Symbol.asyncIterator]();
+    let i2 = false;
+    const iterate = () => {
+      let e2, t2 = false, r3 = true;
+      n2.next().then(
+        (n3) => {
+          if (r3) {
+            e2 = n3;
+            t2 = true;
+          } else if (!n3.done) asyncWrite(n3.value, iterate);
+          else {
+            schedule();
+            flush();
+          }
+        },
+        (e3) => {
+          if (!r3) handleError(e3);
+        }
+      );
+      r3 = false;
+      if (t2 && !e2.done) {
+        o = e2.value;
+        i2 = true;
+        return iterate();
+      }
+      return t2 && e2.done;
+    };
+    const r2 = iterate();
+    if (!i2 && !r2) {
+      globalQueue.initTransition(resolveTransition(e));
+      throw new NotReadyError(context);
+    }
+  }
+  return o;
+}
+function clearStatus(e, t = false) {
+  clearPendingSources(e);
+  e.he = false;
+  e.Se = t ? 0 : e.Se & STATUS_UNINITIALIZED;
+  setPendingError(e);
+  updatePendingSignal(e);
+  e.ge?.();
+}
+function notifyStatus(e, t, n, i, r) {
+  if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError))
+    n = new StatusError(e, n);
+  const s = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : void 0;
+  const o = s === e;
+  const u = t === STATUS_PENDING && e.ee !== void 0 && !o;
+  const c = u && hasActiveOverride(e);
+  if (!i) {
+    if (t === STATUS_PENDING && s) {
+      addPendingSource(e, s);
+      e.Se = STATUS_PENDING | e.Se & STATUS_UNINITIALIZED;
+      setPendingError(e, s, n);
+    } else {
+      clearPendingSources(e);
+      e.Se = t | (t !== STATUS_ERROR ? e.Se & STATUS_UNINITIALIZED : 0);
+      e.le = n;
+    }
+    updatePendingSignal(e);
+  }
+  if (r && !i) {
+    assignOrMergeLane(e, r);
+  }
+  const a = i || c;
+  const f = i || u ? void 0 : r;
+  if (e.ge) {
+    if (i && t === STATUS_PENDING) {
+      return;
+    }
+    if (a) {
+      e.ge(t, n);
+    } else {
+      e.ge();
+    }
+    return;
+  }
+  forEachDependent(e, (e2) => {
+    e2.Ee = clock;
+    if (t === STATUS_PENDING && s && e2.Ie !== s && !e2.pe?.has(s) || t !== STATUS_PENDING && (e2.le !== n || e2.Ie || e2.pe)) {
+      if (!a && !e2.K) globalQueue.se.push(e2);
+      notifyStatus(e2, t, n, a, f);
+    }
+  });
+}
+function markDisposal(e) {
+  let t = e.Ce;
+  while (t) {
+    t.O |= REACTIVE_ZOMBIE;
+    if (t.O & REACTIVE_IN_HEAP) {
+      deleteFromHeap(t, dirtyQueue);
+      insertIntoHeap(t, zombieQueue);
+    }
+    markDisposal(t);
+    t = t.De;
+  }
+}
+function disposeChildren(e, t = false, n) {
+  if (e.O & REACTIVE_DISPOSED) return;
+  if (t) e.O = REACTIVE_DISPOSED;
+  let i = n ? e.me : e.Ce;
+  while (i) {
+    const e2 = i.De;
+    if (i.C) {
+      const e3 = i;
+      deleteFromHeap(e3, e3.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      let t2 = e3.C;
+      do {
+        t2 = unlinkSubs(t2);
+      } while (t2 !== null);
+      e3.C = null;
+      e3.ye = null;
+    }
+    disposeChildren(i, true);
+    i = e2;
+  }
+  if (n) {
+    e.me = null;
+  } else {
+    e.Ce = null;
+    e.ve = 0;
+  }
+  runDisposal(e, n);
+}
+function runDisposal(e, t) {
+  let n = t ? e.we : e.be;
+  if (!n) return;
+  if (Array.isArray(n)) {
+    for (let e2 = 0; e2 < n.length; e2++) {
+      const t2 = n[e2];
+      t2.call(t2);
+    }
+  } else {
+    n.call(n);
+  }
+  t ? e.we = null : e.be = null;
+}
+function unlinkSubs(e) {
+  const t = e.m;
+  const n = e.D;
+  const i = e.p;
+  const r = e.Ue;
+  if (i !== null) i.Ue = r;
+  else t.ke = r;
+  if (r !== null) r.p = i;
+  else {
+    t.I = i;
+    if (i === null) {
+      t.Ge?.();
+      t.L && !t.xe && !(t.O & REACTIVE_ZOMBIE) && unobserved(t);
+    }
+  }
+  return n;
+}
+function unobserved(e) {
+  deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+  let t = e.C;
+  while (t !== null) {
+    t = unlinkSubs(t);
+  }
+  e.C = null;
+  disposeChildren(e, true);
+}
+function recompute(e, t = false) {
+  const n = e.W;
+  if (!t) {
+    if (e.K && (!n || activeTransition) && activeTransition !== e.K)
+      globalQueue.initTransition(e.K);
+    deleteFromHeap(e, e.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+    if (e.K || n === EFFECT_TRACKED) disposeChildren(e);
+    else {
+      markDisposal(e);
+      e.we = e.be;
+      e.me = e.Ce;
+      e.be = null;
+      e.Ce = null;
+      e.ve = 0;
+    }
+  }
+  const i = !!(e.O & REACTIVE_OPTIMISTIC_DIRTY);
+  const r = e.ee !== void 0 && e.ee !== NOT_PENDING;
+  const s = !!(e.Se & STATUS_PENDING);
+  const o = context;
+  context = e;
+  e.ye = null;
+  e.O = REACTIVE_RECOMPUTING_DEPS;
+  e.Ee = clock;
+  let u = e.X === NOT_PENDING ? e.J : e.X;
+  let c = e.o;
+  let a = tracking;
+  let f = currentOptimisticLane;
+  tracking = true;
+  if (i) {
+    const t2 = resolveLane(e);
+    if (t2) currentOptimisticLane = t2;
+  }
+  try {
+    u = handleAsync(e, e.L(u));
+    clearStatus(e, t);
+    const n2 = resolveLane(e);
+    if (n2) {
+      n2.k.delete(e);
+      updatePendingSignal(n2.te);
+    }
+  } catch (t2) {
+    if (t2 instanceof NotReadyError && currentOptimisticLane) {
+      const t3 = findLane(currentOptimisticLane);
+      if (t3.te !== e) {
+        t3.k.add(e);
+        e.q = t3;
+        updatePendingSignal(t3.te);
+      }
+    }
+    if (t2 instanceof NotReadyError) e.he = true;
+    notifyStatus(
+      e,
+      t2 instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR,
+      t2,
+      void 0,
+      t2 instanceof NotReadyError ? e.q : void 0
+    );
+  } finally {
+    tracking = a;
+    e.O = REACTIVE_NONE | (t ? e.O & REACTIVE_SNAPSHOT_STALE : 0);
+    context = o;
+  }
+  if (!e.le) {
+    const o2 = e.ye;
+    let a2 = o2 !== null ? o2.D : e.C;
+    if (a2 !== null) {
+      do {
+        a2 = unlinkSubs(a2);
+      } while (a2 !== null);
+      if (o2 !== null) o2.D = null;
+      else e.C = null;
+    }
+    const f2 = r ? e.ee : e.X === NOT_PENDING ? e.J : e.X;
+    const l = !e.Ne || !e.Ne(f2, u);
+    if (l) {
+      const o3 = r ? e.ee : void 0;
+      if (t || n && activeTransition !== e.K || i) {
+        e.J = u;
+        if (r && i) {
+          e.ee = u;
+          e.X = u;
+        }
+      } else e.X = u;
+      if (r && !i && s && !e._e) e.ee = u;
+      if (!r || i || e.ee !== o3) insertSubs(e, i || r);
+    } else if (r) {
+      e.X = u;
+    } else if (e.o != c) {
+      for (let t2 = e.I; t2 !== null; t2 = t2.p) {
+        insertIntoHeapHeight(t2.h, t2.h.O & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue);
+      }
+    }
+  }
+  currentOptimisticLane = f;
+  (!t || e.Se & STATUS_PENDING) && !e.K && !(activeTransition && r) && globalQueue.se.push(e);
+  e.K && n && activeTransition !== e.K && runInTransition(e.K, () => recompute(e));
+}
+function untrack(e, t) {
+  if (!externalSourceConfig && !tracking && true) return e();
+  const n = tracking;
+  tracking = false;
+  try {
+    if (externalSourceConfig) return externalSourceConfig.untrack(e);
+    return e();
+  } finally {
+    tracking = n;
+  }
+}
+function setSignal(e, t) {
+  if (e.K && activeTransition !== e.K) globalQueue.initTransition(e.K);
+  const n = e.ee !== void 0 && !projectionWriteActive;
+  const i = e.ee !== void 0 && e.ee !== NOT_PENDING;
+  const r = n ? i ? e.ee : e.J : e.X === NOT_PENDING ? e.J : e.X;
+  if (typeof t === "function") t = t(r);
+  const s = !e.Ne || !e.Ne(r, t) || !!(e.Se & STATUS_UNINITIALIZED);
+  if (!s) {
+    if (n && i && e.L) {
+      insertSubs(e, true);
+      schedule();
+    }
+    return t;
+  }
+  if (n) {
+    const n2 = e.ee === NOT_PENDING;
+    if (!n2) globalQueue.initTransition(resolveTransition(e));
+    if (n2) {
+      e.X = e.J;
+      globalQueue.Y.push(e);
+    }
+    e._e = true;
+    const i2 = getOrCreateLane(e);
+    e.q = i2;
+    e.ee = t;
+  } else {
+    if (e.X === NOT_PENDING) globalQueue.se.push(e);
+    e.X = t;
+  }
+  updatePendingSignal(e);
+  if (e.Pe) {
+    setSignal(e.Pe, t);
+  }
+  e.Ee = clock;
+  insertSubs(e, n);
+  schedule();
+  return t;
+}
+function computePendingState(e) {
+  const t = e;
+  const n = e.V;
+  if (n && e.X !== NOT_PENDING) {
+    return !n.Ae && !(n.Se & STATUS_PENDING);
+  }
+  if (e.ee !== void 0 && e.ee !== NOT_PENDING) {
+    if (t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
+    if (e.Re) {
+      const t2 = e.q ? findLane(e.q) : null;
+      return !!(t2 && t2.k.size > 0);
+    }
+    return true;
+  }
+  if (e.ee !== void 0 && e.ee === NOT_PENDING && !e.Re) {
+    return false;
+  }
+  if (e.X !== NOT_PENDING && !(t.Se & STATUS_UNINITIALIZED)) return true;
+  return !!(t.Se & STATUS_PENDING && !(t.Se & STATUS_UNINITIALIZED));
+}
+function updatePendingSignal(e) {
+  if (e.Qe) {
+    const t = computePendingState(e);
+    const n = e.Qe;
+    setSignal(n, t);
+    if (!t && n.q) {
+      const t2 = resolveLane(e);
+      if (t2 && t2.k.size > 0) {
+        const e2 = findLane(n.q);
+        if (e2 !== t2) {
+          mergeLanes(t2, e2);
+        }
+      }
+      signalLanes.delete(n);
+      n.q = void 0;
+    }
+  }
+}
+function isWrappable(e) {
+  return e != null && typeof e === "object" && !Object.isFrozen(e);
+}
+function updatePath(e, t, n = 0) {
+  let i, r = e;
+  if (n < t.length - 1) {
+    i = t[n];
+    const s2 = typeof i;
+    const o = Array.isArray(e);
+    if (Array.isArray(i)) {
+      for (let r2 = 0; r2 < i.length; r2++) {
+        t[n] = i[r2];
+        updatePath(e, t, n);
+      }
+      t[n] = i;
+      return;
+    } else if (o && s2 === "function") {
+      for (let r2 = 0; r2 < e.length; r2++) {
+        if (i(e[r2], r2)) {
+          t[n] = r2;
+          updatePath(e, t, n);
+        }
+      }
+      t[n] = i;
+      return;
+    } else if (o && s2 === "object") {
+      const { from: r2 = 0, to: s3 = e.length - 1, by: o2 = 1 } = i;
+      for (let i2 = r2; i2 <= s3; i2 += o2) {
+        t[n] = i2;
+        updatePath(e, t, n);
+      }
+      t[n] = i;
+      return;
+    } else if (n < t.length - 2) {
+      updatePath(e[i], t, n + 1);
+      return;
+    }
+    r = e[i];
+  }
+  let s = t[t.length - 1];
+  if (typeof s === "function") {
+    s = s(r);
+    if (s === r) return;
+  }
+  if (i === void 0 && s == void 0) return;
+  if (s === DELETE) {
+    delete e[i];
+  } else if (i === void 0 || isWrappable(r) && isWrappable(s) && !Array.isArray(s)) {
+    const t2 = i !== void 0 ? e[i] : e;
+    const n2 = Object.keys(s);
+    for (let e2 = 0; e2 < n2.length; e2++) t2[n2[e2]] = s[n2[e2]];
+  } else {
+    e[i] = s;
+  }
+}
+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, stashedOptimisticReads, Queue, GlobalQueue, globalQueue, signalLanes, activeLanes, externalSourceConfig, tracking, context, currentOptimisticLane, DELETE;
+var init_prod = __esm({
+  "../../node_modules/.pnpm/@solidjs+signals@0.13.6/node_modules/@solidjs/signals/dist/prod.js"() {
+    NotReadyError = class extends Error {
+      source;
+      constructor(e) {
+        super();
+        this.source = e;
+      }
+    };
+    StatusError = class extends Error {
+      source;
+      constructor(e, t) {
+        super(t instanceof Error ? t.message : String(t), { cause: t });
+        this.source = e;
+      }
+    };
+    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 = { l: new Array(2e3).fill(void 0), _: false, P: 0, R: 0 };
+    zombieQueue = { l: new Array(2e3).fill(void 0), _: false, P: 0, R: 0 };
+    clock = 0;
+    activeTransition = null;
+    scheduled = false;
+    projectionWriteActive = false;
+    stashedOptimisticReads = null;
+    Queue = class {
+      i = null;
+      ie = [[], []];
+      re = [];
+      created = clock;
+      addChild(e) {
+        this.re.push(e);
+        e.i = this;
+      }
+      removeChild(e) {
+        const t = this.re.indexOf(e);
+        if (t >= 0) {
+          this.re.splice(t, 1);
+          e.i = null;
+        }
+      }
+      notify(e, t, n, i) {
+        if (this.i) return this.i.notify(e, t, n, i);
+        return false;
+      }
+      run(e) {
+        if (this.ie[e - 1].length) {
+          const t = this.ie[e - 1];
+          this.ie[e - 1] = [];
+          runQueue(t, e);
+        }
+        for (let t = 0; t < this.re.length; t++) this.re[t].run?.(e);
+      }
+      enqueue(e, t) {
+        if (e) {
+          if (currentOptimisticLane) {
+            const n = findLane(currentOptimisticLane);
+            n.G[e - 1].push(t);
+          } else {
+            this.ie[e - 1].push(t);
+          }
+        }
+        schedule();
+      }
+      stashQueues(e) {
+        e.ie[0].push(...this.ie[0]);
+        e.ie[1].push(...this.ie[1]);
+        this.ie = [[], []];
+        for (let t = 0; t < this.re.length; t++) {
+          let n = this.re[t];
+          let i = e.re[t];
+          if (!i) {
+            i = { ie: [[], []], re: [] };
+            e.re[t] = i;
+          }
+          n.stashQueues(i);
+        }
+      }
+      restoreQueues(e) {
+        this.ie[0].push(...e.ie[0]);
+        this.ie[1].push(...e.ie[1]);
+        for (let t = 0; t < e.re.length; t++) {
+          const n = e.re[t];
+          let i = this.re[t];
+          if (i) i.restoreQueues(n);
+        }
+      }
+    };
+    GlobalQueue = class _GlobalQueue extends Queue {
+      ne = false;
+      se = [];
+      Y = [];
+      Z = /* @__PURE__ */ new Set();
+      static oe;
+      static ue;
+      static ce = null;
+      flush() {
+        if (this.ne) return;
+        this.ne = true;
+        try {
+          runHeap(dirtyQueue, _GlobalQueue.oe);
+          if (activeTransition) {
+            const e = transitionComplete(activeTransition);
+            if (!e) {
+              const e2 = activeTransition;
+              runHeap(zombieQueue, _GlobalQueue.oe);
+              this.se = [];
+              this.Y = [];
+              this.Z = /* @__PURE__ */ new Set();
+              runLaneEffects(EFFECT_RENDER);
+              runLaneEffects(EFFECT_USER);
+              this.stashQueues(e2.ae);
+              clock++;
+              scheduled = dirtyQueue.R >= dirtyQueue.P;
+              reassignPendingTransition(e2.se);
+              activeTransition = null;
+              if (!e2.j.length && e2.Y.length) {
+                stashedOptimisticReads = /* @__PURE__ */ new Set();
+                for (let t2 = 0; t2 < e2.Y.length; t2++) {
+                  const n = e2.Y[t2];
+                  if (n.L || n.fe) continue;
+                  stashedOptimisticReads.add(n);
+                  queueStashedOptimisticEffects(n);
+                }
+              }
+              try {
+                finalizePureQueue(null, true);
+              } finally {
+                stashedOptimisticReads = null;
+              }
+              return;
+            }
+            this.se !== activeTransition.se && this.se.push(...activeTransition.se);
+            this.restoreQueues(activeTransition.ae);
+            transitions.delete(activeTransition);
+            const t = activeTransition;
+            activeTransition = null;
+            reassignPendingTransition(this.se);
+            finalizePureQueue(t);
+          } else {
+            if (transitions.size) runHeap(zombieQueue, _GlobalQueue.oe);
+            finalizePureQueue();
+          }
+          clock++;
+          scheduled = dirtyQueue.R >= dirtyQueue.P;
+          runLaneEffects(EFFECT_RENDER);
+          this.run(EFFECT_RENDER);
+          runLaneEffects(EFFECT_USER);
+          this.run(EFFECT_USER);
+        } finally {
+          this.ne = false;
+        }
+      }
+      notify(e, t, n, i) {
+        if (t & STATUS_PENDING) {
+          if (n & STATUS_PENDING) {
+            const t2 = i !== void 0 ? i : e.le;
+            if (activeTransition && t2) {
+              const e2 = t2.source;
+              if (!activeTransition.B.includes(e2)) {
+                activeTransition.B.push(e2);
+                schedule();
+              }
+            }
+          }
+          return true;
+        }
+        return false;
+      }
+      initTransition(e) {
+        if (e) e = currentTransition(e);
+        if (e && e === activeTransition) return;
+        if (!e && activeTransition && activeTransition.Ee === clock) return;
+        if (!activeTransition) {
+          activeTransition = e ?? {
+            Ee: clock,
+            se: [],
+            B: [],
+            Y: [],
+            Z: /* @__PURE__ */ new Set(),
+            j: [],
+            ae: { ie: [[], []], re: [] },
+            $: false
+          };
+        } else if (e) {
+          const t = activeTransition;
+          mergeTransitionState(e, t);
+          transitions.delete(t);
+          activeTransition = e;
+        }
+        transitions.add(activeTransition);
+        activeTransition.Ee = clock;
+        if (this.se !== activeTransition.se) {
+          for (let e2 = 0; e2 < this.se.length; e2++) {
+            const t = this.se[e2];
+            t.K = activeTransition;
+            activeTransition.se.push(t);
+          }
+          this.se = activeTransition.se;
+        }
+        if (this.Y !== activeTransition.Y) {
+          for (let e2 = 0; e2 < this.Y.length; e2++) {
+            const t = this.Y[e2];
+            t.K = activeTransition;
+            activeTransition.Y.push(t);
+          }
+          this.Y = activeTransition.Y;
+        }
+        for (const e2 of activeLanes) {
+          if (!e2.K) e2.K = activeTransition;
+        }
+        if (this.Z !== activeTransition.Z) {
+          for (const e2 of this.Z) activeTransition.Z.add(e2);
+          this.Z = activeTransition.Z;
+        }
+      }
+    };
+    globalQueue = new GlobalQueue();
+    signalLanes = /* @__PURE__ */ new WeakMap();
+    activeLanes = /* @__PURE__ */ new Set();
+    externalSourceConfig = null;
+    GlobalQueue.oe = recompute;
+    GlobalQueue.ue = disposeChildren;
+    tracking = false;
+    context = null;
+    currentOptimisticLane = null;
+    DELETE = /* @__PURE__ */ Symbol(0);
+    Object.assign(
+      function storePath2(...e) {
+        return (t) => {
+          updatePath(t, e);
+        };
+      },
+      { DELETE }
+    );
+  }
+});
+function template(html, isImportNode, isSVG, isMathML) {
+  let node;
+  const create = (bypassGuard) => {
+    const t = document.createElement("template");
+    t.innerHTML = html;
+    return t.content.firstChild;
+  };
+  const fn = isImportNode ? (bypassGuard) => solidJs.untrack(() => document.importNode(node || (node = create()), true)) : (bypassGuard) => (node || (node = create())).cloneNode(true);
+  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_web = __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/web.js"() {
+    init_prod();
+    effect = (fn, effectFn, initial) => solidJs.createRenderEffect(fn, effectFn, initial, {
+      transparent: true
+    });
+    isServer = false;
+    isDev = false;
+  }
+});
+
 // src/devtools.tsx
 var devtools_exports = {};
 __export(devtools_exports, {
@@ -23,7 +1221,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 +1236,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_web();
+    init_web();
+    _tmpl$ = /* @__PURE__ */ template(`<div class=tsqd-parent-container>`);
   }
 });
 
@@ -88,7 +1295,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 +1317,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_web();
+    init_web();
+    init_web();
+    init_web();
+    _tmpl$2 = /* @__PURE__ */ template(`<div class=tsqd-parent-container style=height:500px>`);
   }
 });
+
+// src/index.tsx
+init_web();
+
+// src/clientOnly.tsx
+init_web();
 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;
 };