@buoy-gg/react-query 7.0.41 → 7.0.42

package/lib/module/react-query/sync/snapshotProvider.js

@@ -1,284 +1 @@
-"use strict";
-
-/**
- * Time Machine snapshot provider for React Query.
- *
- * Unlike the other providers this one can't register at module init — the
- * QueryClient only exists in React context — so useReactQuerySyncAdapter
- * (mounted app-lifetime by FloatingDevTools' auto external sync) registers
- * it per-client via an effect.
- *
- * Restore is a device-safe DIFF against the live cache, NOT the desktop
- * Hydrate: that one detaches live observers and mocks queryFns, which is
- * fine on a mirror client and destructive in a running app. Here existing
- * queries get `setState` (observers stay attached and are notified, keeping
- * their real queryFns), missing ones are built into the cache, and extras
- * are removed. Mutations aren't restorable (mutationFns can't be captured);
- * the mutation cache is cleared instead.
- */
-
-import { classifyPreviewItem, createRestoreScope, emptyRestoreResult, failedRestore, registerStateSnapshotProvider, superJsonSerialize } from "@buoy-gg/shared-ui";
-import { isWireDataMarker } from "./dehydrate";
-/** A restored query must never claim an in-flight fetch it doesn't have. */
-function normalizeState(state) {
-  return {
-    ...state,
-    fetchStatus: "idle",
-    fetchMeta: null
-  };
-}
-
-/**
- * The comparable projection of a query for previews: status/error/data ONLY.
- * Timestamps (dataUpdatedAt etc.) are excluded — including them makes every
- * query read as "changed" the moment anything refetches.
- */
-function comparableQuery(q) {
-  return {
-    status: q.state.status,
-    error: q.state.error ?? null,
-    data: q.state.data
-  };
-}
-function queryLabel(queryKey, queryHash) {
-  try {
-    const s = JSON.stringify(queryKey);
-    return s.length > 60 ? `${s.slice(0, 57)}…` : s;
-  } catch {
-    return queryHash;
-  }
-}
-
-/**
- * A query `error` (and `fetchFailureReason`) usually holds the live
- * Axios/fetch error: `request` points at the XHR, which is cyclic and would
- * fail the whole snapshot's serialization. Only name + message survive —
- * that's all a restored error state needs.
- */
-function toStoredError(value) {
-  if (value == null) return value ?? null;
-  if (typeof value === "object") {
-    const err = value;
-    const name = typeof err.name === "string" ? err.name : undefined;
-    const message = typeof err.message === "string" ? err.message : undefined;
-    if (name !== undefined || message !== undefined) {
-      return {
-        ...(name !== undefined ? {
-          name
-        } : {}),
-        ...(message !== undefined ? {
-          message
-        } : {})
-      };
-    }
-  }
-  return value;
-}
-
-/** Would the Time Machine vault be able to store this value? */
-function isStorable(value) {
-  if (value === undefined) return true;
-  try {
-    superJsonSerialize(value);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * The queries as a SNAPSHOT sees them — raw.
- *
- * Deliberately NOT `dehydrateQueryClient()`: that is the WIRE form, which
- * swaps any payload over 16KB for a `DATA_ON_DEVICE` marker so the dashboard
- * stays inside its emit budget. Snapshots live on-device in persistentStorage
- * with no such budget, and restoring a marker would write the placeholder
- * object into the live cache — the app then renders `{__buoyDataOnDevice}` as
- * if it were its data and crashes on the first field it reads.
- */
-function captureQueries(client) {
-  const warnings = [];
-  const queries = [];
-  for (const query of client.getQueryCache().getAll()) {
-    const label = queryLabel(query.queryKey, query.queryHash);
-    if (!isStorable(query.state.data)) {
-      warnings.push(`query ${label}: data can't be serialized (circular reference?) — not captured`);
-      continue;
-    }
-    queries.push({
-      queryKey: query.queryKey,
-      queryHash: query.queryHash,
-      ...(query.meta && isStorable(query.meta) ? {
-        meta: query.meta
-      } : {}),
-      state: normalizeState({
-        ...query.state,
-        error: toStoredError(query.state.error),
-        fetchFailureReason: toStoredError(query.state.fetchFailureReason)
-      })
-    });
-  }
-  return {
-    queries,
-    warnings
-  };
-}
-export function createQuerySnapshotProvider(queryClient) {
-  return {
-    id: "query",
-    label: "React Query",
-    status: () => ({
-      canCapture: true,
-      canRestore: true
-    }),
-    async capture() {
-      const {
-        queries,
-        warnings
-      } = captureQueries(queryClient);
-      const mutationCount = queryClient.getMutationCache().getAll().length;
-      if (mutationCount > 0) {
-        warnings.push(`${mutationCount} mutation(s) not captured (mutation functions cannot be restored)`);
-      }
-      return {
-        data: {
-          queries
-        },
-        warnings
-      };
-    },
-    async restore(data, options) {
-      const snapshot = data;
-      const scope = createRestoreScope(options);
-      const result = emptyRestoreResult();
-      if (!snapshot?.queries) {
-        return failedRestore("empty query snapshot");
-      }
-      const cache = queryClient.getQueryCache();
-      const snapHashes = new Set(snapshot.queries.map(q => q.queryHash));
-      for (const snap of snapshot.queries) {
-        if (!scope.allows(snap.queryHash)) continue;
-        // Snapshots taken before the raw-capture fix hold a wire placeholder
-        // instead of the data. Writing that into the cache hands the app an
-        // object with none of its fields — leave the live query alone and say
-        // why, rather than "restoring" a value that crashes the screen.
-        if (isWireDataMarker(snap.state.data)) {
-          result.skipped.push({
-            id: snap.queryHash,
-            reason: "captured as an on-device placeholder by an older Buoy — re-capture this restore point"
-          });
-          continue;
-        }
-        try {
-          const state = normalizeState(snap.state);
-          const existing = cache.get(snap.queryHash);
-          if (existing) {
-            // Observers stay attached (with their real queryFns) and get
-            // notified — the safe on-device path, same as triggerError's.
-            existing.setState(state);
-          } else {
-            cache.build(queryClient, {
-              queryKey: snap.queryKey,
-              queryHash: snap.queryHash,
-              ...(snap.meta && {
-                meta: snap.meta
-              })
-            }, state);
-          }
-          result.applied += 1;
-        } catch (e) {
-          result.skipped.push({
-            id: snap.queryHash,
-            reason: String(e)
-          });
-          result.ok = false;
-        }
-      }
-
-      // Cache entries the snapshot doesn't know about get removed; a mounted
-      // observer will rebuild + refetch its query on next interaction.
-      for (const query of cache.getAll().slice()) {
-        if (!scope.allows(query.queryHash)) continue;
-        if (!snapHashes.has(query.queryHash)) {
-          try {
-            cache.remove(query);
-            result.applied += 1;
-          } catch (e) {
-            result.skipped.push({
-              id: query.queryHash,
-              reason: String(e)
-            });
-          }
-        }
-      }
-      const mutationCount = queryClient.getMutationCache().getAll().length;
-      if (mutationCount > 0) {
-        queryClient.getMutationCache().clear();
-        result.warnings.push(`mutation cache cleared (${mutationCount} mutation(s))`);
-      }
-      const excludedWarning = scope.excludedWarning("quer(y/ies)");
-      if (excludedWarning) result.warnings.push(excludedWarning);
-      return result;
-    },
-    /** Per-query restore preview. `base` omitted = compare against live cache. */
-    async previewItems(target, base) {
-      const targetQueries = target?.queries ?? [];
-      const liveMode = base === undefined;
-      // Live side goes through the same raw capture as a snapshot would, so a
-      // big query diffs as its real value instead of a wire placeholder.
-      const baseQueries = liveMode ? captureQueries(queryClient).queries : base?.queries ?? [];
-      const baseByHash = new Map(baseQueries.map(q => [q.queryHash, q]));
-      const targetByHash = new Map(targetQueries.map(q => [q.queryHash, q]));
-      const items = [];
-      const notes = [];
-      for (const q of targetQueries) {
-        const label = queryLabel(q.queryKey, q.queryHash);
-        if (isWireDataMarker(q.state.data)) {
-          items.push({
-            key: q.queryHash,
-            label,
-            verdict: "wont-apply",
-            reason: "data stayed on the device when this was captured (older Buoy) — re-capture this restore point"
-          });
-          continue;
-        }
-        const baseQ = baseByHash.get(q.queryHash);
-        items.push(classifyPreviewItem({
-          key: q.queryHash,
-          label,
-          oldValue: baseQ ? comparableQuery(baseQ) : undefined,
-          newValue: comparableQuery(q),
-          inOld: baseQ !== undefined,
-          inNew: true
-        }, {
-          tooLargeReason: "query data too large to render a diff — restore still applies it"
-        }));
-      }
-      for (const q of baseQueries) {
-        if (!targetByHash.has(q.queryHash)) {
-          items.push({
-            key: q.queryHash,
-            label: queryLabel(q.queryKey, q.queryHash),
-            verdict: "removed",
-            oldValue: comparableQuery(q)
-          });
-        }
-      }
-      if (liveMode) {
-        const mutationCount = queryClient.getMutationCache().getAll().length;
-        if (mutationCount > 0) {
-          notes.push(`${mutationCount} in-memory mutation record(s) will be cleared`);
-        }
-      }
-      return {
-        items,
-        notes
-      };
-    }
-  };
-}
-
-/** Register for one client; returns the unregister fn. Last client wins. */
-export function registerQuerySnapshotProvider(queryClient) {
-  return registerStateSnapshotProvider(createQuerySnapshotProvider(queryClient));
-}
+"use strict";import{classifyPreviewItem as w,createRestoreScope as b,emptyRestoreResult as S,failedRestore as Q,registerStateSnapshotProvider as M,superJsonSerialize as R}from"@buoy-gg/shared-ui";import{isWireDataMarker as p}from"./dehydrate";function m(t){return{...t,fetchStatus:"idle",fetchMeta:null}}function l(t){return{status:t.state.status,error:t.state.error??null,data:t.state.data}}function f(t,a){try{const s=JSON.stringify(t);return s.length>60?`${s.slice(0,57)}\u2026`:s}catch{return a}}function g(t){if(t==null)return t??null;if(typeof t==="object"){const a=t;const s=typeof a.name==="string"?a.name:void 0;const r=typeof a.message==="string"?a.message:void 0;if(s!==void 0||r!==void 0){return{...s!==void 0?{name:s}:{},...r!==void 0?{message:r}:{}}}}return t}function q(t){if(t===void 0)return true;try{R(t);return true}catch{return false}}function H(t){const a=[];const s=[];for(const r of t.getQueryCache().getAll()){const u=f(r.queryKey,r.queryHash);if(!q(r.state.data)){a.push(`query ${u}: data can't be serialized (circular reference?) \u2014 not captured`);continue}s.push({queryKey:r.queryKey,queryHash:r.queryHash,...r.meta&&q(r.meta)?{meta:r.meta}:{},state:m({...r.state,error:g(r.state.error),fetchFailureReason:g(r.state.fetchFailureReason)})})}return{queries:s,warnings:a}}export function createQuerySnapshotProvider(t){return{id:"query",label:"React Query",status:()=>({canCapture:true,canRestore:true}),async capture(){const{queries:a,warnings:s}=H(t);const r=t.getMutationCache().getAll().length;if(r>0){s.push(`${r} mutation(s) not captured (mutation functions cannot be restored)`)}return{data:{queries:a},warnings:s}},async restore(a,s){const r=a;const u=b(s);const n=S();if(!r?.queries){return Q("empty query snapshot")}const c=t.getQueryCache();const y=new Set(r.queries.map(e=>e.queryHash));for(const e of r.queries){if(!u.allows(e.queryHash))continue;if(p(e.state.data)){n.skipped.push({id:e.queryHash,reason:"captured as an on-device placeholder by an older Buoy \u2014 re-capture this restore point"});continue}try{const o=m(e.state);const d=c.get(e.queryHash);if(d){d.setState(o)}else{c.build(t,{queryKey:e.queryKey,queryHash:e.queryHash,...e.meta&&{meta:e.meta}},o)}n.applied+=1}catch(o){n.skipped.push({id:e.queryHash,reason:String(o)});n.ok=false}}for(const e of c.getAll().slice()){if(!u.allows(e.queryHash))continue;if(!y.has(e.queryHash)){try{c.remove(e);n.applied+=1}catch(o){n.skipped.push({id:e.queryHash,reason:String(o)})}}}const i=t.getMutationCache().getAll().length;if(i>0){t.getMutationCache().clear();n.warnings.push(`mutation cache cleared (${i} mutation(s))`)}const h=u.excludedWarning("quer(y/ies)");if(h)n.warnings.push(h);return n},async previewItems(a,s){const r=a?.queries??[];const u=s===void 0;const n=u?H(t).queries:s?.queries??[];const c=new Map(n.map(e=>[e.queryHash,e]));const y=new Map(r.map(e=>[e.queryHash,e]));const i=[];const h=[];for(const e of r){const o=f(e.queryKey,e.queryHash);if(p(e.state.data)){i.push({key:e.queryHash,label:o,verdict:"wont-apply",reason:"data stayed on the device when this was captured (older Buoy) \u2014 re-capture this restore point"});continue}const d=c.get(e.queryHash);i.push(w({key:e.queryHash,label:o,oldValue:d?l(d):void 0,newValue:l(e),inOld:d!==void 0,inNew:true},{tooLargeReason:"query data too large to render a diff \u2014 restore still applies it"}))}for(const e of n){if(!y.has(e.queryHash)){i.push({key:e.queryHash,label:f(e.queryKey,e.queryHash),verdict:"removed",oldValue:l(e)})}}if(u){const e=t.getMutationCache().getAll().length;if(e>0){h.push(`${e} in-memory mutation record(s) will be cleared`)}}return{items:i,notes:h}}}}export function registerQuerySnapshotProvider(t){return M(createQuerySnapshotProvider(t))}

package/lib/module/react-query/sync/useReactQuerySyncAdapter.js

@@ -1,31 +1 @@
-"use strict";
-
-import { useEffect, useMemo } from "react";
-import { useQueryClient } from "@tanstack/react-query";
-import { createReactQuerySyncAdapter } from "./reactQuerySyncAdapter";
-import { registerQuerySnapshotProvider } from "./snapshotProvider";
-
-/**
- * Context-based variant of createReactQuerySyncAdapter for zero-config
- * wiring (FloatingDevTools' auto external sync): reads the QueryClient from
- * the surrounding QueryClientProvider. Returns null when rendered outside a
- * provider so callers can skip registering the query tool.
- */
-export function useReactQuerySyncAdapter() {
-  let queryClient;
-  try {
-    // Just a context read — throws only when there is no provider above us,
-    // which never changes for a mounted tree, so hook order stays stable.
-    queryClient = useQueryClient();
-  } catch {
-    queryClient = null;
-  }
-
-  // Register the Time Machine snapshot provider for this client — this hook
-  // is the one app-lifetime spot that actually holds the QueryClient.
-  useEffect(() => {
-    if (!queryClient) return;
-    return registerQuerySnapshotProvider(queryClient);
-  }, [queryClient]);
-  return useMemo(() => queryClient ? createReactQuerySyncAdapter(queryClient) : null, [queryClient]);
-}
+"use strict";import{useEffect as e,useMemo as t}from"react";import{useQueryClient as u}from"@tanstack/react-query";import{createReactQuerySyncAdapter as o}from"./reactQuerySyncAdapter";import{registerQuerySnapshotProvider as n}from"./snapshotProvider";export function useReactQuerySyncAdapter(){let r;try{r=u()}catch{r=null}e(()=>{if(!r)return;return n(r)},[r]);return t(()=>r?o(r):null,[r])}

package/lib/module/react-query/types/types.js

@@ -1,10 +1 @@
-"use strict";
-
-// Shared type definitions for the dev tools
-
-/**
- * Type guard that narrows a value to a plain object (excluding arrays, Dates, Maps, etc.).
- */
-export function isPlainObject(value) {
-  return value !== null && value !== undefined && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof Error) && !(value instanceof Map) && !(value instanceof Set) && !(value instanceof RegExp) && typeof value !== "function";
-}
+"use strict";export function isPlainObject(n){return n!==null&&n!==void 0&&typeof n==="object"&&!Array.isArray(n)&&!(n instanceof Date)&&!(n instanceof Error)&&!(n instanceof Map)&&!(n instanceof Set)&&!(n instanceof RegExp)&&typeof n!=="function"}

package/lib/module/react-query/utils/actions/deleteItem.js

@@ -1,19 +1 @@
-"use strict";
-
-import { deleteNestedDataByPath } from "../deleteNestedDataByPath";
-export default function deleteItem({
-  activeQuery,
-  dataPath,
-  queryClient
-}) {
-  if (!dataPath) {
-    // Early return if path is missing
-    return;
-  }
-  const oldData = activeQuery.state.data;
-  const newData = deleteNestedDataByPath(oldData, dataPath);
-
-  // Force a new object reference to ensure React detects the change
-  const forceNewReference = JSON.parse(JSON.stringify(newData));
-  queryClient.setQueryData(activeQuery.queryKey, forceNewReference);
-}
+"use strict";import{deleteNestedDataByPath as o}from"../deleteNestedDataByPath";export default function f({activeQuery:e,dataPath:t,queryClient:r}){if(!t){return}const a=e.state.data;const s=o(a,t);const n=JSON.parse(JSON.stringify(s));r.setQueryData(e.queryKey,n)}

package/lib/module/react-query/utils/actions/emitDevToolsEvent.js

@@ -1,36 +1 @@
-"use strict";
-
-const DEV_TOOLS_EVENT = "@tanstack/query-devtools-event";
-
-/**
- * Announce a devtool action as the same DOM CustomEvent the official TanStack
- * devtools panel emits. On the device this is a no-op (React Native has no
- * CustomEvent), so actions stay purely local. In Buoy Desktop these components
- * render against a mirror QueryClient hydrated from the device, and the
- * dashboard listens for this event to forward the action over the sync
- * protocol — without it, actions only touch the mirror and are wiped by the
- * next device snapshot.
- *
- * Call BEFORE mutating the local cache: the desktop handler resolves the
- * query by hash, so for REMOVE the query must still exist in the mirror.
- */
-export function emitDevToolsEvent(type, queryHash) {
-  try {
-    // globalThis === window in browsers; React Native lacks CustomEvent, so
-    // this bails out there. No DOM lib in this package's tsconfig — cast.
-    const g = globalThis;
-    if (typeof g.dispatchEvent !== "function" || typeof g.CustomEvent !== "function") {
-      return;
-    }
-    g.dispatchEvent(new g.CustomEvent(DEV_TOOLS_EVENT, {
-      detail: {
-        type,
-        queryHash
-      },
-      bubbles: true,
-      cancelable: true
-    }));
-  } catch {
-    // Never let event plumbing break the action itself.
-  }
-}
+"use strict";const o="@tanstack/query-devtools-event";export function emitDevToolsEvent(e,n){try{const t=globalThis;if(typeof t.dispatchEvent!=="function"||typeof t.CustomEvent!=="function"){return}t.dispatchEvent(new t.CustomEvent(o,{detail:{type:e,queryHash:n},bubbles:true,cancelable:true}))}catch{}}

package/lib/module/react-query/utils/actions/invalidate.js

@@ -1,11 +1 @@
-"use strict";
-
-import { emitDevToolsEvent } from "./emitDevToolsEvent";
-export default function invalidate({
-  query,
-  queryClient
-}) {
-  emitDevToolsEvent("INVALIDATE", query.queryHash);
-  // This matches the ACTION-INVALIDATE case from the external sync system
-  queryClient.invalidateQueries(query);
-}
+"use strict";import{emitDevToolsEvent as i}from"./emitDevToolsEvent";export default function a({query:e,queryClient:t}){i("INVALIDATE",e.queryHash);t.invalidateQueries(e)}

package/lib/module/react-query/utils/actions/refetch.js

@@ -1,13 +1 @@
-"use strict";
-
-import { emitDevToolsEvent } from "./emitDevToolsEvent";
-export default function refetch({
-  query
-}) {
-  emitDevToolsEvent("REFETCH", query.queryHash);
-  // This matches the ACTION-REFETCH case from the external sync system
-  const promise = query.fetch();
-  promise.catch(() => {
-    // Silently handle fetch errors
-  });
-}
+"use strict";import{emitDevToolsEvent as o}from"./emitDevToolsEvent";export default function c({query:t}){o("REFETCH",t.queryHash);const e=t.fetch();e.catch(()=>{})}

package/lib/module/react-query/utils/actions/remove.js

@@ -1,11 +1 @@
-"use strict";
-
-import { emitDevToolsEvent } from "./emitDevToolsEvent";
-export default function remove({
-  query,
-  queryClient
-}) {
-  // Emit first — the desktop bridge still needs to find this hash in the cache.
-  emitDevToolsEvent("REMOVE", query.queryHash);
-  queryClient.removeQueries(query);
-}
+"use strict";import{emitDevToolsEvent as t}from"./emitDevToolsEvent";export default function r({query:e,queryClient:o}){t("REMOVE",e.queryHash);o.removeQueries(e)}

package/lib/module/react-query/utils/actions/reset.js

@@ -1,13 +1 @@
-"use strict";
-
-import { emitDevToolsEvent } from "./emitDevToolsEvent";
-export default function reset({
-  query,
-  queryClient
-}) {
-  emitDevToolsEvent("RESET", query.queryHash);
-  queryClient.resetQueries({
-    queryKey: query.queryKey,
-    exact: true
-  });
-}
+"use strict";import{emitDevToolsEvent as r}from"./emitDevToolsEvent";export default function s({query:e,queryClient:t}){r("RESET",e.queryHash);t.resetQueries({queryKey:e.queryKey,exact:true})}

package/lib/module/react-query/utils/actions/triggerError.js

@@ -1,29 +1 @@
-"use strict";
-
-import { emitDevToolsEvent } from "./emitDevToolsEvent";
-export default function triggerError({
-  query,
-  queryClient
-}) {
-  if (query.state.status !== "error") {
-    emitDevToolsEvent("TRIGGER_ERROR", query.queryHash);
-    // --ACTION-TRIGGER-ERROR logic--
-    // This matches the ACTION-TRIGGER-ERROR case from the external sync system
-    const error = new Error("Unknown error from devtools");
-    const __previousQueryOptions = query.options;
-    query.setState({
-      status: "error",
-      error,
-      fetchMeta: {
-        ...query.state.fetchMeta,
-        // @ts-expect-error This does exist
-        __previousQueryOptions
-      }
-    });
-  } else {
-    emitDevToolsEvent("RESTORE_ERROR", query.queryHash);
-    // --ACTION-RESTORE-ERROR logic--
-    // This matches the ACTION-RESTORE-ERROR case from the external sync system
-    queryClient.resetQueries(query);
-  }
-}
+"use strict";import{emitDevToolsEvent as e}from"./emitDevToolsEvent";export default function n({query:t,queryClient:r}){if(t.state.status!=="error"){e("TRIGGER_ERROR",t.queryHash);const o=new Error("Unknown error from devtools");const s=t.options;t.setState({status:"error",error:o,fetchMeta:{...t.state.fetchMeta,__previousQueryOptions:s}})}else{e("RESTORE_ERROR",t.queryHash);r.resetQueries(t)}}

package/lib/module/react-query/utils/actions/triggerLoading.js

@@ -1,50 +1 @@
-"use strict";
-
-import { emitDevToolsEvent } from "./emitDevToolsEvent";
-export default function triggerLoading({
-  query
-}) {
-  if (query.state.data === undefined) {
-    emitDevToolsEvent("RESTORE_LOADING", query.queryHash);
-    // --ACTION-RESTORE-LOADING logic--
-    // This matches the ACTION-RESTORE-LOADING case from the external sync system
-    const previousState = query.state;
-    const previousOptions = query.state.fetchMeta ? query.state.fetchMeta.__previousQueryOptions : null;
-    query.cancel({
-      silent: true
-    });
-    query.setState({
-      ...previousState,
-      fetchStatus: "idle",
-      fetchMeta: null
-    });
-    if (previousOptions) {
-      query.fetch(previousOptions);
-    }
-  } else {
-    emitDevToolsEvent("TRIGGER_LOADING", query.queryHash);
-    // --ACTION-TRIGGER-LOADING logic--
-    // This matches the ACTION-TRIGGER-LOADING case from the external sync system
-    const __previousQueryOptions = query.options;
-
-    // Trigger a fetch in order to trigger suspense as well.
-    query.fetch({
-      ...__previousQueryOptions,
-      queryFn: () => {
-        return new Promise(() => {
-          // Never resolve - simulates perpetual loading
-        });
-      },
-      gcTime: -1
-    });
-    query.setState({
-      data: undefined,
-      status: "pending",
-      fetchMeta: {
-        ...query.state.fetchMeta,
-        // @ts-expect-error This does exist
-        __previousQueryOptions
-      }
-    });
-  }
-}
+"use strict";import{emitDevToolsEvent as a}from"./emitDevToolsEvent";export default function n({query:t}){if(t.state.data===void 0){a("RESTORE_LOADING",t.queryHash);const e=t.state;const s=t.state.fetchMeta?t.state.fetchMeta.__previousQueryOptions:null;t.cancel({silent:true});t.setState({...e,fetchStatus:"idle",fetchMeta:null});if(s){t.fetch(s)}}else{a("TRIGGER_LOADING",t.queryHash);const e=t.options;t.fetch({...e,queryFn:()=>{return new Promise(()=>{})},gcTime:-1});t.setState({data:void 0,status:"pending",fetchMeta:{...t.state.fetchMeta,__previousQueryOptions:e}})}}

package/lib/module/react-query/utils/deleteNestedDataByPath.js

@@ -1,51 +1 @@
-"use strict";
-
-/**
- * Deletes nested data by path
- *
- * @param {unknown} oldData Data to be updated
- * @param {Array<string>} deletePath Path to the data to be deleted
- * @returns newData without the deleted items by path
- */
-export const deleteNestedDataByPath = (oldData, deletePath) => {
-  if (oldData instanceof Map) {
-    const newData = new Map(oldData);
-    if (deletePath.length === 1) {
-      newData.delete(deletePath[0]);
-      return newData;
-    }
-    const [head, ...tail] = deletePath;
-    newData.set(head, deleteNestedDataByPath(newData.get(head), tail));
-    return newData;
-  }
-  if (oldData instanceof Set) {
-    const setAsArray = deleteNestedDataByPath(Array.from(oldData), deletePath);
-    return new Set(setAsArray);
-  }
-  if (Array.isArray(oldData)) {
-    const newData = [...oldData];
-    if (deletePath.length === 1) {
-      return newData.filter((_, idx) => idx.toString() !== deletePath[0]);
-    }
-    const [head, ...tail] = deletePath;
-
-    // @ts-expect-error NAS
-    newData[head] = deleteNestedDataByPath(newData[head], tail);
-    return newData;
-  }
-  if (oldData instanceof Object) {
-    const newData = {
-      ...oldData
-    };
-    if (deletePath.length === 1) {
-      // @ts-expect-error NAS
-      delete newData[deletePath[0]];
-      return newData;
-    }
-    const [head, ...tail] = deletePath;
-    // @ts-expect-error NAS
-    newData[head] = deleteNestedDataByPath(newData[head], tail);
-    return newData;
-  }
-  return oldData;
-};
+"use strict";export const deleteNestedDataByPath=(t,r)=>{if(t instanceof Map){const n=new Map(t);if(r.length===1){n.delete(r[0]);return n}const[s,...i]=r;n.set(s,deleteNestedDataByPath(n.get(s),i));return n}if(t instanceof Set){const n=deleteNestedDataByPath(Array.from(t),r);return new Set(n)}if(Array.isArray(t)){const n=[...t];if(r.length===1){return n.filter((c,e)=>e.toString()!==r[0])}const[s,...i]=r;n[s]=deleteNestedDataByPath(n[s],i);return n}if(t instanceof Object){const n={...t};if(r.length===1){delete n[r[0]];return n}const[s,...i]=r;n[s]=deleteNestedDataByPath(n[s],i);return n}return t};

package/lib/module/react-query/utils/getQueryStatusColor.js

@@ -1,12 +1 @@
-"use strict";
-
-/**
- * Maps a query’s runtime state to one of the predefined status color tokens used in the UI.
- */
-export function getQueryStatusColor({
-  queryState,
-  observerCount,
-  isStale
-}) {
-  return queryState.fetchStatus === "fetching" ? "blue" : queryState.status === "error" ? "red" : !observerCount ? "gray" : queryState.fetchStatus === "paused" ? "purple" : isStale ? "yellow" : "green";
-}
+"use strict";export function getQueryStatusColor({queryState:t,observerCount:e,isStale:r}){return t.fetchStatus==="fetching"?"blue":t.status==="error"?"red":!e?"gray":t.fetchStatus==="paused"?"purple":r?"yellow":"green"}

package/lib/module/react-query/utils/getQueryStatusLabel.js

@@ -1,19 +1 @@
-"use strict";
-
-/**
- * Converts a query object into a human-friendly status string for badge rendering.
- * Priority order: disabled > fetching > error > inactive > paused > stale > fresh
- *
- * "error" sits just below "fetching" so a hard-failed query (status === "error",
- * i.e. failed with no cached data) surfaces as an error instead of hiding under
- * "inactive"/"stale", while an in-flight retry still reads as "fetching". This
- * is the single source of truth every consumer (cards, dots, counts, the Error
- * filter) reads, and it matches the dashboard sidebar's error dot exactly.
- */
-export function getQueryStatusLabel(query) {
-  // Check disabled first - disabled queries won't automatically fetch
-  if (query.isDisabled()) {
-    return "disabled";
-  }
-  return query.state.fetchStatus === "fetching" ? "fetching" : query.state.status === "error" ? "error" : !query.getObserversCount() ? "inactive" : query.state.fetchStatus === "paused" ? "paused" : query.isStale() ? "stale" : "fresh";
-}
+"use strict";export function getQueryStatusLabel(t){if(t.isDisabled()){return"disabled"}return t.state.fetchStatus==="fetching"?"fetching":t.state.status==="error"?"error":!t.getObserversCount()?"inactive":t.state.fetchStatus==="paused"?"paused":t.isStale()?"stale":"fresh"}

package/lib/module/react-query/utils/getStorageQueryCounts.js

@@ -1,31 +1 @@
-"use strict";
-
-import { isStorageQuery, getStorageType, getCleanStorageKey } from "./storageQueryUtils";
-import { isDevToolsStorageKey } from "@buoy-gg/shared-ui";
-/**
- * Calculate counts for each storage type from storage queries
- * Following performance principles: no unnecessary memoization [[memory:4875074]]
- */
-export function getStorageQueryCounts(queries) {
-  const counts = {
-    mmkv: 0,
-    async: 0,
-    secure: 0,
-    total: 0
-  };
-
-  // Filter to storage queries only, then count by type
-  const storageQueries = queries.filter(query => isStorageQuery(query.queryKey));
-  storageQueries.forEach(query => {
-    const storageType = getStorageType(query.queryKey);
-    if (storageType) {
-      // Filter out dev tool keys from the counts
-      const cleanKey = getCleanStorageKey(query.queryKey);
-      if (!isDevToolsStorageKey(cleanKey)) {
-        counts[storageType]++;
-        counts.total++;
-      }
-    }
-  });
-  return counts;
-}
+"use strict";import{isStorageQuery as y,getStorageType as n,getCleanStorageKey as c}from"./storageQueryUtils";import{isDevToolsStorageKey as u}from"@buoy-gg/shared-ui";export function getStorageQueryCounts(r){const t={mmkv:0,async:0,secure:0,total:0};const s=r.filter(e=>y(e.queryKey));s.forEach(e=>{const o=n(e.queryKey);if(o){const a=c(e.queryKey);if(!u(a)){t[o]++;t.total++}}});return t}