@pyreon/query 0.5.0 → 0.7.0

package/lib/types/index.d.ts

@@ -1,628 +1,356 @@
-import { CancelledError, InfiniteQueryObserver, MutationCache, MutationObserver, QueriesObserver, QueryCache, QueryClient, QueryObserver, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hashKey, hydrate, isCancelledError, keepPreviousData } from "@tanstack/query-core";
-import { createContext, onMount, onUnmount, popContext, pushContext, useContext } from "@pyreon/core";
-import { batch, effect, signal } from "@pyreon/reactivity";
+import { CancelledError, DefaultError, DehydratedState, FetchQueryOptions, InfiniteData, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, InvalidateOptions, InvalidateQueryFilters, MutateFunction, MutationCache, MutationFilters, MutationFilters as MutationFilters$1, MutationObserverOptions, MutationObserverResult, QueryCache, QueryClient, QueryClient as QueryClient$1, QueryClientConfig, QueryFilters, QueryFilters as QueryFilters$1, QueryKey, QueryKey as QueryKey$1, QueryObserverOptions, QueryObserverResult, RefetchOptions, RefetchQueryFilters, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hashKey, hydrate, isCancelledError, keepPreviousData } from "@tanstack/query-core";
+import * as _pyreon_core0 from "@pyreon/core";
+import { Props, VNode, VNodeChild } from "@pyreon/core";
+import { Signal } from "@pyreon/reactivity";
 
-//#region src/query-client.ts
-
-/**
-* Provides a QueryClient to all descendant components via context.
-* Wrap your app root with this to enable useQuery / useMutation throughout the tree.
-*
-* @example
-* const client = new QueryClient()
-* mount(h(QueryClientProvider, { client }, h(App, null)), el)
-*/
-function QueryClientProvider(props) {
-  pushContext(new Map([[QueryClientContext.id, props.client]]));
-  onMount(() => {
-    props.client.mount();
-    return () => props.client.unmount();
-  });
-  onUnmount(() => popContext());
-  const ch = props.children;
-  return typeof ch === "function" ? ch() : ch;
+//#region src/query-client.d.ts
+interface QueryClientProviderProps extends Props {
+  client: QueryClient$1;
+  children?: VNodeChild;
 }
+declare const QueryClientContext: _pyreon_core0.Context<QueryClient$1 | null>;
 /**
-* Returns the nearest QueryClient provided by <QueryClientProvider>.
-* Throws if called outside of one.
-*/
-function useQueryClient() {
-  const client = useContext(QueryClientContext);
-  if (!client) throw new Error("[pyreon/query] No QueryClient found. Wrap your app with <QueryClientProvider client={client}>.");
-  return client;
-}
-
-//#endregion
-//#region src/use-infinite-query.ts
+ * Provides a QueryClient to all descendant components via context.
+ * Wrap your app root with this to enable useQuery / useMutation throughout the tree.
+ *
+ * @example
+ * const client = new QueryClient()
+ * mount(h(QueryClientProvider, { client }, h(App, null)), el)
+ */
+declare function QueryClientProvider(props: QueryClientProviderProps): VNode;
 /**
-* Subscribe to a paginated / infinite-scroll query.
-* Returns fine-grained reactive signals plus `fetchNextPage`, `fetchPreviousPage`,
-* `hasNextPage` and `hasPreviousPage`.
-*
-* @example
-* const query = useInfiniteQuery(() => ({
-*   queryKey: ['posts'],
-*   queryFn: ({ pageParam }) => fetchPosts(pageParam as number),
-*   initialPageParam: 0,
-*   getNextPageParam: (lastPage) => lastPage.nextCursor,
-* }))
-* // query.data()?.pages  — array of pages
-* // h('button', { onClick: () => query.fetchNextPage() }, 'Load more')
-*/
-function useInfiniteQuery(options) {
-  const observer = new InfiniteQueryObserver(useQueryClient(), options());
-  const initial = observer.getCurrentResult();
-  const resultSig = signal(initial);
-  const dataSig = signal(initial.data);
-  const errorSig = signal(initial.error ?? null);
-  const statusSig = signal(initial.status);
-  const isPending = signal(initial.isPending);
-  const isLoading = signal(initial.isLoading);
-  const isFetching = signal(initial.isFetching);
-  const isFetchingNextPage = signal(initial.isFetchingNextPage);
-  const isFetchingPreviousPage = signal(initial.isFetchingPreviousPage);
-  const isError = signal(initial.isError);
-  const isSuccess = signal(initial.isSuccess);
-  const hasNextPage = signal(initial.hasNextPage);
-  const hasPreviousPage = signal(initial.hasPreviousPage);
-  const unsub = observer.subscribe(r => {
-    batch(() => {
-      resultSig.set(r);
-      dataSig.set(r.data);
-      errorSig.set(r.error ?? null);
-      statusSig.set(r.status);
-      isPending.set(r.isPending);
-      isLoading.set(r.isLoading);
-      isFetching.set(r.isFetching);
-      isFetchingNextPage.set(r.isFetchingNextPage);
-      isFetchingPreviousPage.set(r.isFetchingPreviousPage);
-      isError.set(r.isError);
-      isSuccess.set(r.isSuccess);
-      hasNextPage.set(r.hasNextPage);
-      hasPreviousPage.set(r.hasPreviousPage);
-    });
-  });
-  effect(() => {
-    observer.setOptions(options());
-  });
-  onUnmount(() => unsub());
-  return {
-    result: resultSig,
-    data: dataSig,
-    error: errorSig,
-    status: statusSig,
-    isPending,
-    isLoading,
-    isFetching,
-    isFetchingNextPage,
-    isFetchingPreviousPage,
-    isError,
-    isSuccess,
-    hasNextPage,
-    hasPreviousPage,
-    fetchNextPage: () => observer.fetchNextPage(),
-    fetchPreviousPage: () => observer.fetchPreviousPage(),
-    refetch: () => observer.refetch()
-  };
-}
-
+ * Returns the nearest QueryClient provided by <QueryClientProvider>.
+ * Throws if called outside of one.
+ */
+declare function useQueryClient(): QueryClient$1;
 //#endregion
-//#region src/use-is-fetching.ts
-/**
-* Returns a signal that tracks how many queries are currently in-flight.
-* Useful for global loading indicators.
-*
-* @example
-* const fetching = useIsFetching()
-* // h('span', null, () => fetching() > 0 ? 'Loading…' : '')
-*/
-function useIsFetching(filters) {
-  const client = useQueryClient();
-  const count = signal(client.isFetching(filters));
-  const unsub = client.getQueryCache().subscribe(() => {
-    count.set(client.isFetching(filters));
-  });
-  onUnmount(() => unsub());
-  return count;
+//#region src/use-infinite-query.d.ts
+interface UseInfiniteQueryResult<TQueryFnData, TError = DefaultError> {
+  /** Raw signal — full observer result. */
+  result: Signal<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  data: Signal<InfiniteData<TQueryFnData> | undefined>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isPending: Signal<boolean>;
+  isLoading: Signal<boolean>;
+  isFetching: Signal<boolean>;
+  isFetchingNextPage: Signal<boolean>;
+  isFetchingPreviousPage: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  hasNextPage: Signal<boolean>;
+  hasPreviousPage: Signal<boolean>;
+  fetchNextPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  fetchPreviousPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  refetch: () => Promise<QueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
 }
 /**
-* Returns a signal that tracks how many mutations are currently in-flight.
-*
-* @example
-* const mutating = useIsMutating()
-* // h('span', null, () => mutating() > 0 ? 'Saving…' : '')
-*/
-function useIsMutating(filters) {
-  const client = useQueryClient();
-  const count = signal(client.isMutating(filters));
-  const unsub = client.getMutationCache().subscribe(() => {
-    count.set(client.isMutating(filters));
-  });
-  onUnmount(() => unsub());
-  return count;
-}
-
+ * Subscribe to a paginated / infinite-scroll query.
+ * Returns fine-grained reactive signals plus `fetchNextPage`, `fetchPreviousPage`,
+ * `hasNextPage` and `hasPreviousPage`.
+ *
+ * @example
+ * const query = useInfiniteQuery(() => ({
+ *   queryKey: ['posts'],
+ *   queryFn: ({ pageParam }) => fetchPosts(pageParam as number),
+ *   initialPageParam: 0,
+ *   getNextPageParam: (lastPage) => lastPage.nextCursor,
+ * }))
+ * // query.data()?.pages  — array of pages
+ * // h('button', { onClick: () => query.fetchNextPage() }, 'Load more')
+ */
+declare function useInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TQueryKey extends QueryKey$1 = QueryKey$1, TPageParam = unknown>(options: () => InfiniteQueryObserverOptions<TQueryFnData, TError, InfiniteData<TQueryFnData>, TQueryKey, TPageParam>): UseInfiniteQueryResult<TQueryFnData, TError>;
 //#endregion
-//#region src/use-mutation.ts
+//#region src/use-is-fetching.d.ts
 /**
-* Run a mutation (create / update / delete). Returns reactive signals for
-* pending / success / error state plus `mutate` and `mutateAsync` functions.
-*
-* @example
-* const mutation = useMutation({
-*   mutationFn: (data: CreatePostInput) =>
-*     fetch('/api/posts', { method: 'POST', body: JSON.stringify(data) }).then(r => r.json()),
-*   onSuccess: () => client.invalidateQueries({ queryKey: ['posts'] }),
-* })
-* // h('button', { onClick: () => mutation.mutate({ title: 'New' }) }, 'Create')
-*/
-function useMutation(options) {
-  const observer = new MutationObserver(useQueryClient(), options);
-  const initial = observer.getCurrentResult();
-  const resultSig = signal(initial);
-  const dataSig = signal(initial.data);
-  const errorSig = signal(initial.error ?? null);
-  const statusSig = signal(initial.status);
-  const isPending = signal(initial.isPending);
-  const isSuccess = signal(initial.isSuccess);
-  const isError = signal(initial.isError);
-  const isIdle = signal(initial.isIdle);
-  const unsub = observer.subscribe(r => {
-    batch(() => {
-      resultSig.set(r);
-      dataSig.set(r.data);
-      errorSig.set(r.error ?? null);
-      statusSig.set(r.status);
-      isPending.set(r.isPending);
-      isSuccess.set(r.isSuccess);
-      isError.set(r.isError);
-      isIdle.set(r.isIdle);
-    });
-  });
-  onUnmount(() => unsub());
-  return {
-    result: resultSig,
-    data: dataSig,
-    error: errorSig,
-    status: statusSig,
-    isPending,
-    isSuccess,
-    isError,
-    isIdle,
-    mutate: (vars, callbackOptions) => {
-      observer.mutate(vars, callbackOptions).catch(() => {});
-    },
-    mutateAsync: (vars, callbackOptions) => observer.mutate(vars, callbackOptions),
-    reset: () => observer.reset()
-  };
-}
-
-//#endregion
-//#region src/use-queries.ts
+ * Returns a signal that tracks how many queries are currently in-flight.
+ * Useful for global loading indicators.
+ *
+ * @example
+ * const fetching = useIsFetching()
+ * // h('span', null, () => fetching() > 0 ? 'Loading…' : '')
+ */
+declare function useIsFetching(filters?: QueryFilters$1): Signal<number>;
 /**
-* Subscribe to multiple queries in parallel. Returns a single signal containing
-* the array of results — index-aligned with the `queries` array.
-*
-* `queries` is a reactive function so signal-based keys trigger re-evaluation
-* automatically.
-*
-* @example
-* const userIds = signal([1, 2, 3])
-* const results = useQueries(() =>
-*   userIds().map(id => ({
-*     queryKey: ['user', id],
-*     queryFn: () => fetchUser(id),
-*   }))
-* )
-* // results() — QueryObserverResult[]
-* // results()[0].data — first user
-*/
-function useQueries(queries) {
-  const observer = new QueriesObserver(useQueryClient(), queries());
-  const resultSig = signal(observer.getCurrentResult());
-  const unsub = observer.subscribe(results => {
-    resultSig.set(results);
-  });
-  effect(() => {
-    observer.setQueries(queries());
-  });
-  onUnmount(() => {
-    unsub();
-    observer.destroy();
-  });
-  return resultSig;
-}
-
+ * Returns a signal that tracks how many mutations are currently in-flight.
+ *
+ * @example
+ * const mutating = useIsMutating()
+ * // h('span', null, () => mutating() > 0 ? 'Saving…' : '')
+ */
+declare function useIsMutating(filters?: MutationFilters$1): Signal<number>;
 //#endregion
-//#region src/use-query.ts
-/**
-* Subscribe to a query. Returns fine-grained reactive signals for data,
-* error and status — each signal only notifies effects that depend on it.
-*
-* `options` is a function so it can read Pyreon signals — when a signal changes
-* (e.g. a reactive query key), the observer is updated and refetches automatically.
-*
-* @example
-* const userId = signal(1)
-* const query = useQuery(() => ({
-*   queryKey: ['user', userId()],
-*   queryFn: () => fetch(`/api/users/${userId()}`).then(r => r.json()),
-* }))
-* // In template: () => query.data()?.name
-*/
-function useQuery(options) {
-  const observer = new QueryObserver(useQueryClient(), options());
-  const initial = observer.getCurrentResult();
-  const resultSig = signal(initial);
-  const dataSig = signal(initial.data);
-  const errorSig = signal(initial.error ?? null);
-  const statusSig = signal(initial.status);
-  const isPending = signal(initial.isPending);
-  const isLoading = signal(initial.isLoading);
-  const isFetching = signal(initial.isFetching);
-  const isError = signal(initial.isError);
-  const isSuccess = signal(initial.isSuccess);
-  const unsub = observer.subscribe(r => {
-    batch(() => {
-      resultSig.set(r);
-      dataSig.set(r.data);
-      errorSig.set(r.error ?? null);
-      statusSig.set(r.status);
-      isPending.set(r.isPending);
-      isLoading.set(r.isLoading);
-      isFetching.set(r.isFetching);
-      isError.set(r.isError);
-      isSuccess.set(r.isSuccess);
-    });
-  });
-  effect(() => {
-    observer.setOptions(options());
-  });
-  onUnmount(() => unsub());
-  return {
-    result: resultSig,
-    data: dataSig,
-    error: errorSig,
-    status: statusSig,
-    isPending,
-    isLoading,
-    isFetching,
-    isError,
-    isSuccess,
-    refetch: () => observer.refetch()
-  };
+//#region src/use-mutation.d.ts
+interface UseMutationResult<TData, TError = DefaultError, TVariables = void, TContext = unknown> {
+  /** Raw signal — full observer result. Fine-grained accessors below are preferred. */
+  result: Signal<MutationObserverResult<TData, TError, TVariables, TContext>>;
+  data: Signal<TData | undefined>;
+  error: Signal<TError | null>;
+  status: Signal<'idle' | 'pending' | 'success' | 'error'>;
+  isPending: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  isError: Signal<boolean>;
+  isIdle: Signal<boolean>;
+  /** Fire the mutation (fire-and-forget). Errors are captured in the error signal. */
+  mutate: (variables: TVariables, options?: Parameters<MutateFunction<TData, TError, TVariables, TContext>>[1]) => void;
+  /** Like mutate but returns a promise — use for try/catch error handling. */
+  mutateAsync: MutateFunction<TData, TError, TVariables, TContext>;
+  /** Reset the mutation state back to idle. */
+  reset: () => void;
 }
-
+/**
+ * Run a mutation (create / update / delete). Returns reactive signals for
+ * pending / success / error state plus `mutate` and `mutateAsync` functions.
+ *
+ * @example
+ * const mutation = useMutation({
+ *   mutationFn: (data: CreatePostInput) =>
+ *     fetch('/api/posts', { method: 'POST', body: JSON.stringify(data) }).then(r => r.json()),
+ *   onSuccess: () => client.invalidateQueries({ queryKey: ['posts'] }),
+ * })
+ * // h('button', { onClick: () => mutation.mutate({ title: 'New' }) }, 'Create')
+ */
+declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: MutationObserverOptions<TData, TError, TVariables, TContext>): UseMutationResult<TData, TError, TVariables, TContext>;
 //#endregion
-//#region src/use-query-error-reset-boundary.ts
-
+//#region src/use-queries.d.ts
+type UseQueriesOptions<TQueryKey extends QueryKey$1 = QueryKey$1> = QueryObserverOptions<unknown, DefaultError, unknown, unknown, TQueryKey>;
 /**
-* Wraps a subtree so that `useQueryErrorResetBoundary()` descendants can reset
-* all errored queries within this boundary.
-*
-* Pair with Pyreon's `ErrorBoundary` to retry failed queries when the user
-* dismisses the error fallback:
-*
-* @example
-* h(QueryErrorResetBoundary, null,
-*   h(ErrorBoundary, {
-*     fallback: (err, boundaryReset) => {
-*       const { reset } = useQueryErrorResetBoundary()
-*       return h('button', {
-*         onClick: () => { reset(); boundaryReset() },
-*       }, 'Retry')
-*     },
-*   }, h(MyComponent, null)),
-* )
-*/
-function QueryErrorResetBoundary(props) {
-  const client = useQueryClient();
-  pushContext(new Map([[QueryErrorResetBoundaryContext.id, {
-    reset: () => {
-      client.refetchQueries({
-        predicate: query => query.state.status === "error"
-      });
-    }
-  }]]));
-  onUnmount(() => popContext());
-  const ch = props.children;
-  return typeof ch === "function" ? ch() : ch;
+ * Subscribe to multiple queries in parallel. Returns a single signal containing
+ * the array of results — index-aligned with the `queries` array.
+ *
+ * `queries` is a reactive function so signal-based keys trigger re-evaluation
+ * automatically.
+ *
+ * @example
+ * const userIds = signal([1, 2, 3])
+ * const results = useQueries(() =>
+ *   userIds().map(id => ({
+ *     queryKey: ['user', id],
+ *     queryFn: () => fetchUser(id),
+ *   }))
+ * )
+ * // results() — QueryObserverResult[]
+ * // results()[0].data — first user
+ */
+declare function useQueries(queries: () => UseQueriesOptions[]): Signal<QueryObserverResult[]>;
+//#endregion
+//#region src/use-query.d.ts
+interface UseQueryResult<TData, TError = DefaultError> {
+  /** Raw signal — the full observer result. Fine-grained accessors below are preferred. */
+  result: Signal<QueryObserverResult<TData, TError>>;
+  data: Signal<TData | undefined>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isPending: Signal<boolean>;
+  isLoading: Signal<boolean>;
+  isFetching: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  /** Manually trigger a refetch. */
+  refetch: () => Promise<QueryObserverResult<TData, TError>>;
 }
 /**
-* Returns the `reset` function provided by the nearest `QueryErrorResetBoundary`.
-* If called outside a boundary, falls back to resetting all errored queries
-* on the current `QueryClient`.
-*
-* @example
-* // Inside an ErrorBoundary fallback:
-* const { reset } = useQueryErrorResetBoundary()
-* h('button', { onClick: () => { reset(); boundaryReset() } }, 'Retry')
-*/
-function useQueryErrorResetBoundary() {
-  const boundary = useContext(QueryErrorResetBoundaryContext);
-  const client = useQueryClient();
-  if (boundary) return boundary;
-  return {
-    reset: () => {
-      client.refetchQueries({
-        predicate: query => query.state.status === "error"
-      });
-    }
-  };
-}
-
+ * Subscribe to a query. Returns fine-grained reactive signals for data,
+ * error and status — each signal only notifies effects that depend on it.
+ *
+ * `options` is a function so it can read Pyreon signals — when a signal changes
+ * (e.g. a reactive query key), the observer is updated and refetches automatically.
+ *
+ * @example
+ * const userId = signal(1)
+ * const query = useQuery(() => ({
+ *   queryKey: ['user', userId()],
+ *   queryFn: () => fetch(`/api/users/${userId()}`).then(r => r.json()),
+ * }))
+ * // In template: () => query.data()?.name
+ */
+declare function useQuery<TData = unknown, TError = DefaultError, TKey extends QueryKey$1 = QueryKey$1>(options: () => QueryObserverOptions<TData, TError, TData, TData, TKey>): UseQueryResult<TData, TError>;
 //#endregion
-//#region src/use-subscription.ts
+//#region src/use-query-error-reset-boundary.d.ts
+interface ErrorResetBoundaryValue {
+  reset: () => void;
+}
+interface QueryErrorResetBoundaryProps extends Props {
+  children?: VNodeChild;
+}
+/**
+ * Wraps a subtree so that `useQueryErrorResetBoundary()` descendants can reset
+ * all errored queries within this boundary.
+ *
+ * Pair with Pyreon's `ErrorBoundary` to retry failed queries when the user
+ * dismisses the error fallback:
+ *
+ * @example
+ * h(QueryErrorResetBoundary, null,
+ *   h(ErrorBoundary, {
+ *     fallback: (err, boundaryReset) => {
+ *       const { reset } = useQueryErrorResetBoundary()
+ *       return h('button', {
+ *         onClick: () => { reset(); boundaryReset() },
+ *       }, 'Retry')
+ *     },
+ *   }, h(MyComponent, null)),
+ * )
+ */
+declare function QueryErrorResetBoundary(props: QueryErrorResetBoundaryProps): VNode;
 /**
-* Reactive WebSocket subscription that integrates with TanStack Query.
-* Automatically manages connection lifecycle, reconnection, and cleanup.
-*
-* Use the `onMessage` callback to invalidate or update query cache
-* when the server pushes data.
-*
-* @example
-* ```ts
-* const sub = useSubscription({
-*   url: 'wss://api.example.com/ws',
-*   onMessage: (event, queryClient) => {
-*     const data = JSON.parse(event.data)
-*     if (data.type === 'order-updated') {
-*       queryClient.invalidateQueries({ queryKey: ['orders'] })
-*     }
-*   },
-* })
-* // sub.status() — 'connecting' | 'connected' | 'disconnected' | 'error'
-* // sub.send(JSON.stringify({ type: 'subscribe', channel: 'orders' }))
-* ```
-*/
-function useSubscription(options) {
-  const queryClient = useQueryClient();
-  const status = signal("disconnected");
-  let ws = null;
-  let reconnectAttempts = 0;
-  let reconnectTimer = null;
-  let intentionalClose = false;
-  const reconnectEnabled = options.reconnect !== false;
-  const baseDelay = options.reconnectDelay ?? 1e3;
-  const maxAttempts = options.maxReconnectAttempts ?? 10;
-  function getUrl() {
-    return typeof options.url === "function" ? options.url() : options.url;
-  }
-  function isEnabled() {
-    if (options.enabled === void 0) return true;
-    return typeof options.enabled === "function" ? options.enabled() : options.enabled;
-  }
-  function connect() {
-    if (ws) {
-      ws.onopen = null;
-      ws.onmessage = null;
-      ws.onclose = null;
-      ws.onerror = null;
-      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) ws.close();
-    }
-    if (!isEnabled()) {
-      status.set("disconnected");
-      return;
-    }
-    status.set("connecting");
-    try {
-      ws = options.protocols ? new WebSocket(getUrl(), options.protocols) : new WebSocket(getUrl());
-    } catch {
-      status.set("error");
-      scheduleReconnect();
-      return;
-    }
-    ws.onopen = event => {
-      batch(() => {
-        status.set("connected");
-        reconnectAttempts = 0;
-      });
-      options.onOpen?.(event);
-    };
-    ws.onmessage = event => {
-      options.onMessage(event, queryClient);
-    };
-    ws.onclose = event => {
-      status.set("disconnected");
-      options.onClose?.(event);
-      if (!intentionalClose && reconnectEnabled) scheduleReconnect();
-    };
-    ws.onerror = event => {
-      status.set("error");
-      options.onError?.(event);
-    };
-  }
-  function scheduleReconnect() {
-    if (!reconnectEnabled) return;
-    if (maxAttempts > 0 && reconnectAttempts >= maxAttempts) return;
-    const delay = baseDelay * 2 ** reconnectAttempts;
-    reconnectAttempts++;
-    reconnectTimer = setTimeout(() => {
-      reconnectTimer = null;
-      if (!intentionalClose && isEnabled()) connect();
-    }, delay);
-  }
-  function send(data) {
-    if (ws?.readyState === WebSocket.OPEN) ws.send(data);
-  }
-  function close() {
-    intentionalClose = true;
-    if (reconnectTimer !== null) {
-      clearTimeout(reconnectTimer);
-      reconnectTimer = null;
-    }
-    if (ws) {
-      ws.onopen = null;
-      ws.onmessage = null;
-      ws.onclose = null;
-      ws.onerror = null;
-      if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) ws.close();
-      ws = null;
-    }
-    status.set("disconnected");
-  }
-  function manualReconnect() {
-    intentionalClose = false;
-    reconnectAttempts = 0;
-    connect();
-  }
-  effect(() => {
-    if (typeof options.url === "function") options.url();
-    if (typeof options.enabled === "function") options.enabled();
-    intentionalClose = false;
-    reconnectAttempts = 0;
-    connect();
-  });
-  onUnmount(() => close());
-  return {
-    status,
-    send,
-    close,
-    reconnect: manualReconnect
-  };
+ * Returns the `reset` function provided by the nearest `QueryErrorResetBoundary`.
+ * If called outside a boundary, falls back to resetting all errored queries
+ * on the current `QueryClient`.
+ *
+ * @example
+ * // Inside an ErrorBoundary fallback:
+ * const { reset } = useQueryErrorResetBoundary()
+ * h('button', { onClick: () => { reset(); boundaryReset() } }, 'Retry')
+ */
+declare function useQueryErrorResetBoundary(): ErrorResetBoundaryValue;
+//#endregion
+//#region src/use-subscription.d.ts
+type SubscriptionStatus = 'connecting' | 'connected' | 'disconnected' | 'error';
+interface UseSubscriptionOptions {
+  /** WebSocket URL — can be a signal for reactive URLs */
+  url: string | (() => string);
+  /** WebSocket sub-protocols */
+  protocols?: string | string[];
+  /** Called when a message is received — use queryClient to invalidate or update cache */
+  onMessage: (event: MessageEvent, queryClient: QueryClient$1) => void;
+  /** Called when the connection opens */
+  onOpen?: (event: Event) => void;
+  /** Called when the connection closes */
+  onClose?: (event: CloseEvent) => void;
+  /** Called when a connection error occurs */
+  onError?: (event: Event) => void;
+  /** Whether to automatically reconnect — default: true */
+  reconnect?: boolean;
+  /** Initial reconnect delay in ms — doubles on each retry, default: 1000 */
+  reconnectDelay?: number;
+  /** Maximum reconnect attempts — default: 10, 0 = unlimited */
+  maxReconnectAttempts?: number;
+  /** Whether the subscription is enabled — default: true */
+  enabled?: boolean | (() => boolean);
 }
-
+interface UseSubscriptionResult {
+  /** Current connection status */
+  status: Signal<SubscriptionStatus>;
+  /** Send data through the WebSocket */
+  send: (data: string | ArrayBufferLike | Blob | ArrayBufferView) => void;
+  /** Manually close the connection */
+  close: () => void;
+  /** Manually reconnect */
+  reconnect: () => void;
+}
+/**
+ * Reactive WebSocket subscription that integrates with TanStack Query.
+ * Automatically manages connection lifecycle, reconnection, and cleanup.
+ *
+ * Use the `onMessage` callback to invalidate or update query cache
+ * when the server pushes data.
+ *
+ * @example
+ * ```ts
+ * const sub = useSubscription({
+ *   url: 'wss://api.example.com/ws',
+ *   onMessage: (event, queryClient) => {
+ *     const data = JSON.parse(event.data)
+ *     if (data.type === 'order-updated') {
+ *       queryClient.invalidateQueries({ queryKey: ['orders'] })
+ *     }
+ *   },
+ * })
+ * // sub.status() — 'connecting' | 'connected' | 'disconnected' | 'error'
+ * // sub.send(JSON.stringify({ type: 'subscribe', channel: 'orders' }))
+ * ```
+ */
+declare function useSubscription(options: UseSubscriptionOptions): UseSubscriptionResult;
 //#endregion
-//#region src/use-suspense-query.ts
+//#region src/use-suspense-query.d.ts
 /**
-* Pyreon-native Suspense boundary for queries. Shows `fallback` while any query
-* is pending. On error, renders the `error` fallback or re-throws to the
-* nearest Pyreon `ErrorBoundary`.
-*
-* Pair with `useSuspenseQuery` / `useSuspenseInfiniteQuery` to get non-undefined
-* `data` types inside children.
-*
-* @example
-* const userQuery = useSuspenseQuery(() => ({ queryKey: ['user'], queryFn: fetchUser }))
-*
-* h(QuerySuspense, {
-*   query: userQuery,
-*   fallback: h(Spinner, null),
-*   error: (err) => h('p', null, `Failed: ${err}`),
-* }, () => h(UserProfile, { user: userQuery.data() }))
-*/
-function QuerySuspense(props) {
-  return () => {
-    const queries = Array.isArray(props.query) ? props.query : [props.query];
-    for (const q of queries) if (q.isError()) {
-      const err = q.error();
-      if (props.error) return props.error(err);
-      throw err;
-    }
-    if (queries.some(q => q.isPending())) {
-      const fb = props.fallback;
-      return typeof fb === "function" ? fb() : fb ?? null;
-    }
-    const ch = props.children;
-    return typeof ch === "function" ? ch() : ch;
-  };
+ * Like `UseQueryResult` but `data` is `Signal<TData>` (never undefined).
+ * Only use inside a `QuerySuspense` boundary which guarantees the query has
+ * succeeded before children are rendered.
+ */
+interface UseSuspenseQueryResult<TData, TError = DefaultError> {
+  result: Signal<QueryObserverResult<TData, TError>>;
+  /** Always TData — never undefined inside a QuerySuspense boundary. */
+  data: Signal<TData>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isPending: Signal<boolean>;
+  isFetching: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  refetch: () => Promise<QueryObserverResult<TData, TError>>;
 }
-/**
-* Like `useQuery` but `data` is typed as `Signal<TData>` (never undefined).
-* Designed for use inside a `QuerySuspense` boundary, which guarantees
-* children only render after the query succeeds.
-*
-* @example
-* const user = useSuspenseQuery(() => ({ queryKey: ['user', id()], queryFn: fetchUser }))
-*
-* h(QuerySuspense, { query: user, fallback: h(Spinner, null) },
-*   () => h(UserCard, { name: user.data().name }),
-* )
-*/
-function useSuspenseQuery(options) {
-  const observer = new QueryObserver(useQueryClient(), options());
-  const initial = observer.getCurrentResult();
-  const resultSig = signal(initial);
-  const dataSig = signal(initial.data);
-  const errorSig = signal(initial.error ?? null);
-  const statusSig = signal(initial.status);
-  const isPending = signal(initial.isPending);
-  const isFetching = signal(initial.isFetching);
-  const isError = signal(initial.isError);
-  const isSuccess = signal(initial.isSuccess);
-  const unsub = observer.subscribe(r => {
-    batch(() => {
-      resultSig.set(r);
-      if (r.data !== void 0) dataSig.set(r.data);
-      errorSig.set(r.error ?? null);
-      statusSig.set(r.status);
-      isPending.set(r.isPending);
-      isFetching.set(r.isFetching);
-      isError.set(r.isError);
-      isSuccess.set(r.isSuccess);
-    });
-  });
-  effect(() => {
-    observer.setOptions(options());
-  });
-  onUnmount(() => unsub());
-  return {
-    result: resultSig,
-    data: dataSig,
-    error: errorSig,
-    status: statusSig,
-    isPending,
-    isFetching,
-    isError,
-    isSuccess,
-    refetch: () => observer.refetch()
-  };
+interface UseSuspenseInfiniteQueryResult<TQueryFnData, TError = DefaultError> {
+  result: Signal<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  /** Always InfiniteData<TQueryFnData> — never undefined inside a QuerySuspense boundary. */
+  data: Signal<InfiniteData<TQueryFnData>>;
+  error: Signal<TError | null>;
+  status: Signal<'pending' | 'error' | 'success'>;
+  isFetching: Signal<boolean>;
+  isFetchingNextPage: Signal<boolean>;
+  isFetchingPreviousPage: Signal<boolean>;
+  isError: Signal<boolean>;
+  isSuccess: Signal<boolean>;
+  hasNextPage: Signal<boolean>;
+  hasPreviousPage: Signal<boolean>;
+  fetchNextPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  fetchPreviousPage: () => Promise<InfiniteQueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
+  refetch: () => Promise<QueryObserverResult<InfiniteData<TQueryFnData>, TError>>;
 }
-/**
-* Like `useInfiniteQuery` but `data` is typed as `Signal<InfiniteData<TData>>`
-* (never undefined). Use inside a `QuerySuspense` boundary.
-*/
-function useSuspenseInfiniteQuery(options) {
-  const observer = new InfiniteQueryObserver(useQueryClient(), options());
-  const initial = observer.getCurrentResult();
-  const resultSig = signal(initial);
-  const dataSig = signal(initial.data);
-  const errorSig = signal(initial.error ?? null);
-  const statusSig = signal(initial.status);
-  const isFetching = signal(initial.isFetching);
-  const isFetchingNextPage = signal(initial.isFetchingNextPage);
-  const isFetchingPreviousPage = signal(initial.isFetchingPreviousPage);
-  const isError = signal(initial.isError);
-  const isSuccess = signal(initial.isSuccess);
-  const hasNextPage = signal(initial.hasNextPage);
-  const hasPreviousPage = signal(initial.hasPreviousPage);
-  const unsub = observer.subscribe(r => {
-    batch(() => {
-      resultSig.set(r);
-      if (r.data !== void 0) dataSig.set(r.data);
-      errorSig.set(r.error ?? null);
-      statusSig.set(r.status);
-      isFetching.set(r.isFetching);
-      isFetchingNextPage.set(r.isFetchingNextPage);
-      isFetchingPreviousPage.set(r.isFetchingPreviousPage);
-      isError.set(r.isError);
-      isSuccess.set(r.isSuccess);
-      hasNextPage.set(r.hasNextPage);
-      hasPreviousPage.set(r.hasPreviousPage);
-    });
-  });
-  effect(() => {
-    observer.setOptions(options());
-  });
-  onUnmount(() => unsub());
-  return {
-    result: resultSig,
-    data: dataSig,
-    error: errorSig,
-    status: statusSig,
-    isFetching,
-    isFetchingNextPage,
-    isFetchingPreviousPage,
-    isError,
-    isSuccess,
-    hasNextPage,
-    hasPreviousPage,
-    fetchNextPage: () => observer.fetchNextPage(),
-    fetchPreviousPage: () => observer.fetchPreviousPage(),
-    refetch: () => observer.refetch()
-  };
+type AnyQueryLike = {
+  isPending: Signal<boolean>;
+  isError: Signal<boolean>;
+  error: Signal<unknown>;
+};
+interface QuerySuspenseProps {
+  /**
+   * A single query result (or array of them) to gate on.
+   * Children only render when ALL queries have succeeded.
+   */
+  query: AnyQueryLike | AnyQueryLike[];
+  /** Rendered while any query is pending. */
+  fallback?: VNodeChild;
+  /** Rendered when any query has errored. Defaults to re-throwing to nearest ErrorBoundary. */
+  error?: (err: unknown) => VNodeChild;
+  children: VNodeChild;
 }
-
+/**
+ * Pyreon-native Suspense boundary for queries. Shows `fallback` while any query
+ * is pending. On error, renders the `error` fallback or re-throws to the
+ * nearest Pyreon `ErrorBoundary`.
+ *
+ * Pair with `useSuspenseQuery` / `useSuspenseInfiniteQuery` to get non-undefined
+ * `data` types inside children.
+ *
+ * @example
+ * const userQuery = useSuspenseQuery(() => ({ queryKey: ['user'], queryFn: fetchUser }))
+ *
+ * h(QuerySuspense, {
+ *   query: userQuery,
+ *   fallback: h(Spinner, null),
+ *   error: (err) => h('p', null, `Failed: ${err}`),
+ * }, () => h(UserProfile, { user: userQuery.data() }))
+ */
+declare function QuerySuspense(props: QuerySuspenseProps): VNodeChild;
+/**
+ * Like `useQuery` but `data` is typed as `Signal<TData>` (never undefined).
+ * Designed for use inside a `QuerySuspense` boundary, which guarantees
+ * children only render after the query succeeds.
+ *
+ * @example
+ * const user = useSuspenseQuery(() => ({ queryKey: ['user', id()], queryFn: fetchUser }))
+ *
+ * h(QuerySuspense, { query: user, fallback: h(Spinner, null) },
+ *   () => h(UserCard, { name: user.data().name }),
+ * )
+ */
+declare function useSuspenseQuery<TData = unknown, TError = DefaultError, TKey extends QueryKey$1 = QueryKey$1>(options: () => QueryObserverOptions<TData, TError, TData, TData, TKey>): UseSuspenseQueryResult<TData, TError>;
+/**
+ * Like `useInfiniteQuery` but `data` is typed as `Signal<InfiniteData<TData>>`
+ * (never undefined). Use inside a `QuerySuspense` boundary.
+ */
+declare function useSuspenseInfiniteQuery<TQueryFnData = unknown, TError = DefaultError, TQueryKey extends QueryKey$1 = QueryKey$1, TPageParam = unknown>(options: () => InfiniteQueryObserverOptions<TQueryFnData, TError, InfiniteData<TQueryFnData>, TQueryKey, TPageParam>): UseSuspenseInfiniteQueryResult<TQueryFnData, TError>;
 //#endregion
-export { CancelledError, MutationCache, QueryCache, QueryClient, QueryClientContext, QueryClientProvider, QueryErrorResetBoundary, QuerySuspense, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hashKey, hydrate, isCancelledError, keepPreviousData, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSubscription, useSuspenseInfiniteQuery, useSuspenseQuery };
-//# sourceMappingURL=index.d.ts.map
+export { CancelledError, type DehydratedState, type FetchQueryOptions, type InvalidateOptions, type InvalidateQueryFilters, MutationCache, type MutationFilters, QueryCache, QueryClient, type QueryClientConfig, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, QueryErrorResetBoundary, type QueryErrorResetBoundaryProps, type QueryFilters, type QueryKey, QuerySuspense, type QuerySuspenseProps, type RefetchOptions, type RefetchQueryFilters, type SubscriptionStatus, type UseInfiniteQueryResult, type UseMutationResult, type UseQueriesOptions, type UseQueryResult, type UseSubscriptionOptions, type UseSubscriptionResult, type UseSuspenseInfiniteQueryResult, type UseSuspenseQueryResult, defaultShouldDehydrateMutation, defaultShouldDehydrateQuery, dehydrate, hashKey, hydrate, isCancelledError, keepPreviousData, useInfiniteQuery, useIsFetching, useIsMutating, useMutation, useQueries, useQuery, useQueryClient, useQueryErrorResetBoundary, useSubscription, useSuspenseInfiniteQuery, useSuspenseQuery };
+//# sourceMappingURL=index2.d.ts.map