@ereo/rpc 0.1.6

package/dist/client.js

@@ -0,0 +1,433 @@
+// @bun
+// src/client.ts
+function createClient(optionsOrEndpoint) {
+  const options = typeof optionsOrEndpoint === "string" ? { httpEndpoint: optionsOrEndpoint } : optionsOrEndpoint;
+  const fetchFn = options.fetch ?? fetch;
+  const reconnectOpts = {
+    enabled: true,
+    maxAttempts: 10,
+    delayMs: 1000,
+    maxDelayMs: 30000,
+    ...options.reconnect
+  };
+  const heartbeatOpts = {
+    enabled: options.heartbeatEnabled !== false,
+    interval: options.heartbeatInterval ?? 30000
+  };
+  let ws = null;
+  let wsConnecting = false;
+  let wsConnected = false;
+  let reconnectAttempts = 0;
+  let reconnectTimeout = null;
+  let heartbeatInterval = null;
+  let missedPongs = 0;
+  const subscriptions = new Map;
+  const pendingSubscriptions = [];
+  const connectionQueue = [];
+  function getHeaders() {
+    const base = { "Content-Type": "application/json" };
+    const custom = typeof options.headers === "function" ? options.headers() : options.headers;
+    return { ...base, ...custom };
+  }
+  function generateId() {
+    return Math.random().toString(36).slice(2) + Date.now().toString(36);
+  }
+  function connectWebSocket() {
+    return new Promise((resolve, reject) => {
+      if (!options.wsEndpoint) {
+        reject(new Error("WebSocket endpoint not configured"));
+        return;
+      }
+      if (wsConnected) {
+        resolve();
+        return;
+      }
+      if (wsConnecting) {
+        connectionQueue.push({ resolve, reject });
+        return;
+      }
+      wsConnecting = true;
+      startConnection(resolve, reject);
+    });
+  }
+  function startConnection(initialResolve, initialReject) {
+    connectionQueue.push({ resolve: initialResolve, reject: initialReject });
+    try {
+      ws = new WebSocket(options.wsEndpoint);
+      ws.onopen = () => {
+        wsConnecting = false;
+        wsConnected = true;
+        reconnectAttempts = 0;
+        missedPongs = 0;
+        startHeartbeat();
+        while (connectionQueue.length > 0) {
+          const { resolve } = connectionQueue.shift();
+          resolve();
+        }
+        for (const [id, sub] of subscriptions) {
+          sendSubscribe(id, sub.path, sub.input);
+        }
+        while (pendingSubscriptions.length > 0) {
+          const pending = pendingSubscriptions.shift();
+          subscriptions.set(pending.id, pending.sub);
+          sendSubscribe(pending.id, pending.sub.path, pending.sub.input);
+        }
+      };
+      ws.onmessage = (event) => {
+        try {
+          const msg = JSON.parse(event.data);
+          if (msg.type === "pong") {
+            missedPongs = 0;
+            return;
+          }
+          handleServerMessage(msg);
+        } catch (error) {
+          console.error("Failed to parse WebSocket message:", error);
+        }
+      };
+      ws.onerror = (error) => {
+        console.error("WebSocket error:", error);
+      };
+      ws.onclose = () => {
+        stopHeartbeat();
+        wsConnecting = false;
+        wsConnected = false;
+        ws = null;
+        while (connectionQueue.length > 0) {
+          const { reject } = connectionQueue.shift();
+          reject(new Error("WebSocket connection closed"));
+        }
+        if (reconnectOpts.enabled && subscriptions.size > 0) {
+          scheduleReconnect();
+        }
+      };
+    } catch (error) {
+      wsConnecting = false;
+      while (connectionQueue.length > 0) {
+        const { reject } = connectionQueue.shift();
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+  }
+  function startHeartbeat() {
+    if (!heartbeatOpts.enabled)
+      return;
+    heartbeatInterval = setInterval(() => {
+      if (!ws || ws.readyState !== WebSocket.OPEN) {
+        stopHeartbeat();
+        return;
+      }
+      if (missedPongs >= 2) {
+        console.warn("WebSocket heartbeat failed, closing connection");
+        ws.close();
+        return;
+      }
+      missedPongs++;
+      ws.send(JSON.stringify({ type: "ping" }));
+    }, heartbeatOpts.interval);
+  }
+  function stopHeartbeat() {
+    if (heartbeatInterval) {
+      clearInterval(heartbeatInterval);
+      heartbeatInterval = null;
+    }
+    missedPongs = 0;
+  }
+  function scheduleReconnect() {
+    if (reconnectTimeout)
+      return;
+    stopHeartbeat();
+    if (reconnectAttempts >= reconnectOpts.maxAttempts) {
+      console.error("Max reconnection attempts reached");
+      for (const [, sub] of subscriptions) {
+        sub.callbacks.onError?.(new Error("Connection lost"));
+      }
+      return;
+    }
+    const delay = Math.min(reconnectOpts.delayMs * Math.pow(2, reconnectAttempts), reconnectOpts.maxDelayMs);
+    reconnectAttempts++;
+    console.log(`Reconnecting in ${delay}ms (attempt ${reconnectAttempts})`);
+    reconnectTimeout = setTimeout(() => {
+      reconnectTimeout = null;
+      connectWebSocket().catch(() => {});
+    }, delay);
+  }
+  function handleServerMessage(msg) {
+    if (msg.type === "pong") {
+      return;
+    }
+    const sub = subscriptions.get(msg.id);
+    if (!sub)
+      return;
+    switch (msg.type) {
+      case "data":
+        sub.callbacks.onData(msg.data);
+        break;
+      case "error":
+        sub.callbacks.onError?.(new Error(msg.error.message));
+        break;
+      case "complete":
+        subscriptions.delete(msg.id);
+        sub.callbacks.onComplete?.();
+        break;
+    }
+  }
+  function sendSubscribe(id, path, input) {
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+      return;
+    const msg = { type: "subscribe", id, path, input };
+    ws.send(JSON.stringify(msg));
+  }
+  function sendUnsubscribe(id) {
+    if (!ws || ws.readyState !== WebSocket.OPEN)
+      return;
+    const msg = { type: "unsubscribe", id };
+    ws.send(JSON.stringify(msg));
+  }
+  function createProxy(path) {
+    return new Proxy(() => {}, {
+      get(_target, prop) {
+        if (prop === "query") {
+          return async (input) => {
+            const usePost = options.usePostForQueries ?? false;
+            if (usePost) {
+              const response = await fetchFn(options.httpEndpoint, {
+                method: "POST",
+                headers: getHeaders(),
+                body: JSON.stringify({ path, type: "query", input })
+              });
+              return handleHttpResponse(response, path);
+            } else {
+              const url = new URL(options.httpEndpoint, window.location.origin);
+              url.searchParams.set("path", path.join("."));
+              if (input !== undefined) {
+                const inputStr = JSON.stringify(input);
+                if (inputStr.length > 1500) {
+                  console.warn("RPC query input is large. Consider using usePostForQueries option to avoid URL length limits.");
+                }
+                url.searchParams.set("input", inputStr);
+              }
+              const response = await fetchFn(url.toString(), {
+                method: "GET",
+                headers: getHeaders()
+              });
+              return handleHttpResponse(response, path);
+            }
+          };
+        }
+        if (prop === "mutate") {
+          return async (input) => {
+            const response = await fetchFn(options.httpEndpoint, {
+              method: "POST",
+              headers: getHeaders(),
+              body: JSON.stringify({ path, type: "mutation", input })
+            });
+            return handleHttpResponse(response, path);
+          };
+        }
+        if (prop === "subscribe") {
+          return (inputOrCallbacks, maybeCallbacks) => {
+            const hasInput = maybeCallbacks !== undefined;
+            const input = hasInput ? inputOrCallbacks : undefined;
+            const callbacks = hasInput ? maybeCallbacks : inputOrCallbacks;
+            const id = generateId();
+            const sub = { path, input, callbacks };
+            if (!wsConnected && !wsConnecting) {
+              pendingSubscriptions.push({ id, sub });
+              connectWebSocket().catch((error) => {
+                callbacks.onError?.(error instanceof Error ? error : new Error(String(error)));
+              });
+            } else if (wsConnected) {
+              subscriptions.set(id, sub);
+              sendSubscribe(id, path, input);
+            } else {
+              pendingSubscriptions.push({ id, sub });
+            }
+            return () => {
+              subscriptions.delete(id);
+              sendUnsubscribe(id);
+              if (subscriptions.size === 0 && pendingSubscriptions.length === 0) {
+                if (reconnectTimeout) {
+                  clearTimeout(reconnectTimeout);
+                  reconnectTimeout = null;
+                }
+                ws?.close();
+                ws = null;
+                wsConnected = false;
+              }
+            };
+          };
+        }
+        return createProxy([...path, prop]);
+      }
+    });
+  }
+  return createProxy([]);
+}
+async function handleHttpResponse(response, path) {
+  const result = await response.json();
+  if (!result.ok) {
+    const error = new Error(result.error.message);
+    error.name = "RPCClientError";
+    error.code = result.error.code;
+    error.path = path.join(".");
+    error.details = result.error.details;
+    throw error;
+  }
+  return result.data;
+}
+// src/hooks.ts
+import { useState, useEffect, useCallback, useRef } from "react";
+function useQuery(procedure, options = {}) {
+  const { input, enabled = true, refetchInterval } = options;
+  const [data, setData] = useState(undefined);
+  const [error, setError] = useState(undefined);
+  const [isLoading, setIsLoading] = useState(enabled);
+  const inputRef = useRef(input);
+  inputRef.current = input;
+  const fetchData = useCallback(async () => {
+    if (!enabled)
+      return;
+    setIsLoading(true);
+    setError(undefined);
+    try {
+      const result = await procedure.query(inputRef.current);
+      setData(result);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error(String(err)));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [procedure, enabled]);
+  useEffect(() => {
+    fetchData();
+  }, [fetchData]);
+  useEffect(() => {
+    if (!refetchInterval || !enabled)
+      return;
+    const interval = setInterval(fetchData, refetchInterval);
+    return () => clearInterval(interval);
+  }, [refetchInterval, fetchData, enabled]);
+  return {
+    data,
+    error,
+    isLoading,
+    isError: error !== undefined,
+    isSuccess: data !== undefined && error === undefined,
+    refetch: fetchData
+  };
+}
+function useMutation(procedure, options = {}) {
+  const { onSuccess, onError, onSettled } = options;
+  const [data, setData] = useState(undefined);
+  const [error, setError] = useState(undefined);
+  const [isPending, setIsPending] = useState(false);
+  const [isSuccess, setIsSuccess] = useState(false);
+  const mutateAsync = useCallback(async (input) => {
+    setIsPending(true);
+    setError(undefined);
+    setIsSuccess(false);
+    try {
+      const result = await procedure.mutate(input);
+      setData(result);
+      setIsSuccess(true);
+      onSuccess?.(result);
+      return result;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      onError?.(error2);
+      throw error2;
+    } finally {
+      setIsPending(false);
+      onSettled?.();
+    }
+  }, [procedure, onSuccess, onError, onSettled]);
+  const mutate = useCallback((input) => {
+    mutateAsync(input).catch(() => {});
+  }, [mutateAsync]);
+  const reset = useCallback(() => {
+    setData(undefined);
+    setError(undefined);
+    setIsPending(false);
+    setIsSuccess(false);
+  }, []);
+  return {
+    mutate,
+    mutateAsync,
+    data,
+    error,
+    isPending,
+    isError: error !== undefined,
+    isSuccess,
+    reset
+  };
+}
+function useSubscription(procedure, options = {}) {
+  const { input, enabled = true, onData, onError } = options;
+  const [data, setData] = useState(undefined);
+  const [history, setHistory] = useState([]);
+  const [error, setError] = useState(undefined);
+  const [status, setStatus] = useState("idle");
+  const unsubscribeRef = useRef(null);
+  const inputRef = useRef(input);
+  inputRef.current = input;
+  const subscribe = useCallback(() => {
+    if (!enabled)
+      return;
+    setStatus("connecting");
+    setError(undefined);
+    const callbacks = {
+      onData: (value) => {
+        setStatus("connected");
+        setData(value);
+        setHistory((prev) => [...prev, value]);
+        onData?.(value);
+      },
+      onError: (err) => {
+        setStatus("error");
+        setError(err);
+        onError?.(err);
+      },
+      onComplete: () => {
+        setStatus("closed");
+      }
+    };
+    if (inputRef.current !== undefined) {
+      unsubscribeRef.current = procedure.subscribe(inputRef.current, callbacks);
+    } else {
+      unsubscribeRef.current = procedure.subscribe(callbacks);
+    }
+  }, [procedure, enabled, onData, onError]);
+  const unsubscribe = useCallback(() => {
+    unsubscribeRef.current?.();
+    unsubscribeRef.current = null;
+    setStatus("closed");
+  }, []);
+  const resubscribe = useCallback(() => {
+    unsubscribe();
+    setHistory([]);
+    subscribe();
+  }, [subscribe, unsubscribe]);
+  useEffect(() => {
+    subscribe();
+    return () => {
+      unsubscribeRef.current?.();
+    };
+  }, [subscribe]);
+  return {
+    data,
+    history,
+    error,
+    status,
+    isActive: status === "connecting" || status === "connected",
+    unsubscribe,
+    resubscribe
+  };
+}
+export {
+  useSubscription,
+  useQuery,
+  useMutation,
+  createClient
+};

package/dist/src/client.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Client - typed proxy for calling RPC procedures with WebSocket subscriptions
+ *
+ * Usage:
+ *   import { createClient } from '@ereo/rpc/client';
+ *   import type { Api } from './api/router';
+ *
+ *   const rpc = createClient<Api>({
+ *     httpEndpoint: '/api/rpc',
+ *     wsEndpoint: 'ws://localhost:3000/api/rpc',
+ *   });
+ *
+ *   // Queries and mutations
+ *   const user = await rpc.users.me.query();
+ *   const post = await rpc.posts.create.mutate({ title: 'Hello' });
+ *
+ *   // Subscriptions with auto-reconnect
+ *   const unsub = rpc.posts.onCreate.subscribe({
+ *     onData: (post) => console.log('New post:', post),
+ *     onError: (err) => console.error(err),
+ *   });
+ */
+import type { Router, RouterDef, InferClient } from './types';
+export interface RPCClientOptions {
+    /** HTTP endpoint for queries/mutations (e.g., '/api/rpc') */
+    httpEndpoint: string;
+    /** WebSocket endpoint for subscriptions (e.g., 'ws://localhost:3000/api/rpc') */
+    wsEndpoint?: string;
+    /** Custom fetch function */
+    fetch?: typeof fetch;
+    /** Custom headers */
+    headers?: Record<string, string> | (() => Record<string, string>);
+    /** WebSocket reconnect options */
+    reconnect?: {
+        enabled?: boolean;
+        maxAttempts?: number;
+        delayMs?: number;
+        maxDelayMs?: number;
+    };
+    /** Use POST for all requests (queries and mutations) instead of GET for queries */
+    usePostForQueries?: boolean;
+    /** WebSocket heartbeat interval in milliseconds (default: 30000) */
+    heartbeatInterval?: number;
+    /** Enable WebSocket heartbeat (default: true) */
+    heartbeatEnabled?: boolean;
+}
+/**
+ * Create a typed client from a router type
+ */
+export declare function createClient<T extends Router<RouterDef>>(optionsOrEndpoint: string | RPCClientOptions): InferClient<T['_def']>;
+export interface RPCClientError extends Error {
+    code: string;
+    path: string;
+    details?: unknown;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/src/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EACV,MAAM,EACN,SAAS,EACT,WAAW,EAMZ,MAAM,SAAS,CAAC;AAEjB,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAC;IACrB,iFAAiF;IACjF,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,4BAA4B;IAC5B,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC;IACrB,qBAAqB;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClE,kCAAkC;IAClC,SAAS,CAAC,EAAE;QACV,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,UAAU,CAAC,EAAE,MAAM,CAAC;KACrB,CAAC;IACF,mFAAmF;IACnF,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,oEAAoE;IACpE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,iDAAiD;IACjD,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAQD;;GAEG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,CAAC,SAAS,CAAC,EACtD,iBAAiB,EAAE,MAAM,GAAG,gBAAgB,GAC3C,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAkWxB;AAiBD,MAAM,WAAW,cAAe,SAAQ,KAAK;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB"}

package/dist/src/context-bridge.d.ts

@@ -0,0 +1,79 @@
+/**
+ * @ereo/rpc - Context Bridge for RPC and Loaders/Actions
+ *
+ * Provides shared context between RPC procedures and route loaders/actions.
+ * This allows auth state, database connections, and other context to be
+ * shared seamlessly between the two patterns.
+ */
+import type { BaseContext } from './types';
+/**
+ * Context provider function - creates shared context from a request
+ * This is used by both RPC handlers and route loaders/actions
+ */
+export type ContextProvider<TContext = any> = (request: Request) => TContext | Promise<TContext>;
+/**
+ * Set the global context provider that will be used by both RPC and loaders
+ *
+ * Usage in your app setup:
+ *   import { setContextProvider } from '@ereo/rpc';
+ *
+ *   setContextProvider(async (request) => {
+ *     const session = await getSession(request);
+ *     const db = createDbConnection();
+ *     return { session, db, user: session?.user };
+ *   });
+ */
+export declare function setContextProvider<TContext>(provider: ContextProvider<TContext>): void;
+/**
+ * Get the current global context provider
+ */
+export declare function getContextProvider(): ContextProvider | null;
+/**
+ * Clear the global context provider (useful for testing)
+ */
+export declare function clearContextProvider(): void;
+/**
+ * Create context from a request using the global provider
+ * Falls back to an empty object if no provider is set
+ */
+export declare function createSharedContext(request: Request): Promise<any>;
+/**
+ * RPC Router options with context bridge support
+ */
+export interface RouterWithContextOptions<TContext> {
+    /** Context provider for this router */
+    context?: ContextProvider<TContext>;
+}
+/**
+ * Enhanced router creation that supports context bridge
+ * This is an alternative to createRouter that provides better integration
+ */
+export interface ContextBridgeConfig<TContext> {
+    /** Context provider - called for each request */
+    context: ContextProvider<TContext>;
+}
+/**
+ * Helper to create a typed context provider
+ * Provides better type inference for TypeScript users
+ */
+export declare function createContextProvider<TContext>(provider: ContextProvider<TContext>): ContextProvider<TContext>;
+/**
+ * Middleware that injects shared context into the procedure context
+ * Usage: procedure.use(withSharedContext())
+ */
+export declare function withSharedContext(): (opts: {
+    ctx: BaseContext;
+    next: <T>(ctx: T) => {
+        ok: true;
+        ctx: T;
+    } | {
+        ok: false;
+        error: any;
+    };
+}) => Promise<any>;
+/**
+ * Hook for React components to access shared context
+ * This bridges server context to the client
+ */
+export declare function useSharedContext<T>(): T | null;
+//# sourceMappingURL=context-bridge.d.ts.map

package/dist/src/context-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-bridge.d.ts","sourceRoot":"","sources":["../../src/context-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C;;;GAGG;AACH,MAAM,MAAM,eAAe,CAAC,QAAQ,GAAG,GAAG,IAAI,CAAC,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;AAOjG;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,CAAC,QAAQ,CAAC,GAAG,IAAI,CAEtF;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,IAAI,CAE3D;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAKxE;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB,CAAC,QAAQ;IAChD,uCAAuC;IACvC,OAAO,CAAC,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;CACrC;AAED;;;GAGG;AACH,MAAM,WAAW,mBAAmB,CAAC,QAAQ;IAC3C,iDAAiD;IACjD,OAAO,EAAE,eAAe,CAAC,QAAQ,CAAC,CAAC;CACpC;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAC5C,QAAQ,EAAE,eAAe,CAAC,QAAQ,CAAC,GAClC,eAAe,CAAC,QAAQ,CAAC,CAE3B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,IAAI,CAAC,IAAI,EAAE;IAC1C,GAAG,EAAE,WAAW,CAAC;IACjB,IAAI,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK;QAAE,EAAE,EAAE,IAAI,CAAC;QAAC,GAAG,EAAE,CAAC,CAAA;KAAE,GAAG;QAAE,EAAE,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC;CACvE,KAAK,OAAO,CAAC,GAAG,CAAC,CAMjB;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,KAAK,CAAC,GAAG,IAAI,CAQ9C"}

package/dist/src/hooks.d.ts

@@ -0,0 +1,80 @@
+/**
+ * React hooks for RPC calls including subscriptions
+ *
+ * Usage:
+ *   const { data, isLoading } = useQuery(rpc.users.me);
+ *   const { mutate, isPending } = useMutation(rpc.posts.create);
+ *   const { data, status } = useSubscription(rpc.posts.onCreate);
+ */
+import type { SubscriptionCallbacks, Unsubscribe } from './types';
+type QueryFn<TInput, TOutput> = TInput extends void ? {
+    query: () => Promise<TOutput>;
+} : {
+    query: (input: TInput) => Promise<TOutput>;
+};
+export interface UseQueryOptions<TInput> {
+    input?: TInput;
+    enabled?: boolean;
+    refetchInterval?: number;
+}
+export interface UseQueryResult<TOutput> {
+    data: TOutput | undefined;
+    error: Error | undefined;
+    isLoading: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    refetch: () => Promise<void>;
+}
+export declare function useQuery<TInput, TOutput>(procedure: QueryFn<TInput, TOutput>, options?: UseQueryOptions<TInput>): UseQueryResult<TOutput>;
+type MutationFn<TInput, TOutput> = TInput extends void ? {
+    mutate: () => Promise<TOutput>;
+} : {
+    mutate: (input: TInput) => Promise<TOutput>;
+};
+export interface UseMutationOptions<TOutput> {
+    onSuccess?: (data: TOutput) => void;
+    onError?: (error: Error) => void;
+    onSettled?: () => void;
+}
+export interface UseMutationResult<TInput, TOutput> {
+    mutate: TInput extends void ? () => void : (input: TInput) => void;
+    mutateAsync: TInput extends void ? () => Promise<TOutput> : (input: TInput) => Promise<TOutput>;
+    data: TOutput | undefined;
+    error: Error | undefined;
+    isPending: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    reset: () => void;
+}
+export declare function useMutation<TInput, TOutput>(procedure: MutationFn<TInput, TOutput>, options?: UseMutationOptions<TOutput>): UseMutationResult<TInput, TOutput>;
+type SubscribeFn<TInput, TOutput> = TInput extends void ? {
+    subscribe: (callbacks: SubscriptionCallbacks<TOutput>) => Unsubscribe;
+} : {
+    subscribe: (input: TInput, callbacks: SubscriptionCallbacks<TOutput>) => Unsubscribe;
+};
+export type SubscriptionStatus = 'idle' | 'connecting' | 'connected' | 'error' | 'closed';
+export interface UseSubscriptionOptions<TInput> {
+    input?: TInput;
+    enabled?: boolean;
+    onData?: (data: unknown) => void;
+    onError?: (error: Error) => void;
+}
+export interface UseSubscriptionResult<TOutput> {
+    /** Most recent data received */
+    data: TOutput | undefined;
+    /** All data received (for accumulating results) */
+    history: TOutput[];
+    /** Current error if any */
+    error: Error | undefined;
+    /** Connection status */
+    status: SubscriptionStatus;
+    /** Whether currently receiving data */
+    isActive: boolean;
+    /** Manually unsubscribe */
+    unsubscribe: () => void;
+    /** Resubscribe after unsubscribing */
+    resubscribe: () => void;
+}
+export declare function useSubscription<TInput, TOutput>(procedure: SubscribeFn<TInput, TOutput>, options?: UseSubscriptionOptions<TInput>): UseSubscriptionResult<TOutput>;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/src/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/hooks.ts"],"names":[],"mappings":"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"}

package/dist/src/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @ereo/rpc - Typed RPC layer for EreoJS
+ *
+ * Server-side exports for defining routers and procedures
+ */
+export { procedure } from './procedure';
+export type { ProcedureBuilder } from './procedure';
+export { query, mutation, subscription } from './procedure';
+export { createRouter, RPCError, errors } from './router';
+export type { Router, BunWebSocketHandler } from './router';
+export { rpcPlugin } from './plugin';
+export type { RPCPluginOptions, RPCPluginResult, BunWebSocketConfig, RPCPlugin } from './plugin';
+export { setContextProvider, getContextProvider, clearContextProvider, createSharedContext, createContextProvider, withSharedContext, useSharedContext, } from './context-bridge';
+export type { ContextProvider, RouterWithContextOptions, ContextBridgeConfig, } from './context-bridge';
+export { logging, rateLimit, clearRateLimitStore, createAuthMiddleware, requireRoles, validate, extend, timing, catchErrors, } from './middleware';
+export type { LoggingOptions, RateLimitOptions, TimingContext } from './middleware';
+export type { Schema, BaseContext, ExtendedContext, MiddlewareFn, MiddlewareDef, MiddlewareResult, ProcedureType, ProcedureDef, QueryProcedure, MutationProcedure, SubscriptionProcedure, SubscriptionYield, AnyProcedure, RouterDef, InferClient, SubscriptionCallbacks, Unsubscribe, RPCRequest, RPCResponse, RPCErrorShape, WSClientMessage, WSServerMessage, WSConnectionData, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACxC,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAGpD,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG5D,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAC1D,YAAY,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAG5D,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AACrC,YAAY,EAAE,gBAAgB,EAAE,eAAe,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAEjG,OAAO,EACL,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,qBAAqB,EACrB,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EACV,eAAe,EACf,wBAAwB,EACxB,mBAAmB,GACpB,MAAM,kBAAkB,CAAC;AAG1B,OAAO,EACL,OAAO,EACP,SAAS,EACT,mBAAmB,EACnB,oBAAoB,EACpB,YAAY,EACZ,QAAQ,EACR,MAAM,EACN,MAAM,EACN,WAAW,GACZ,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAGpF,YAAY,EAEV,MAAM,EAGN,WAAW,EACX,eAAe,EAGf,YAAY,EACZ,aAAa,EACb,gBAAgB,EAGhB,aAAa,EACb,YAAY,EACZ,cAAc,EACd,iBAAiB,EACjB,qBAAqB,EACrB,iBAAiB,EACjB,YAAY,EAGZ,SAAS,EAGT,WAAW,EACX,qBAAqB,EACrB,WAAW,EAGX,UAAU,EACV,WAAW,EACX,aAAa,EACb,eAAe,EACf,eAAe,EACf,gBAAgB,GACjB,MAAM,SAAS,CAAC"}