dynamodb-reactive 0.1.22 → 0.2.2

package/dist/chunk-2KC44Q5I.js

@@ -1,1103 +0,0 @@
-import jsonpatch from 'fast-json-patch';
-import { error, debug, warn } from 'ag-common/dist/common/helpers/log.js';
-import { createContext, useState, useEffect, useContext, useSyncExternalStore, useRef, useCallback } from 'react';
-import { jsx } from 'react/jsx-runtime';
-
-// ../client/src/patcher.ts
-var { applyPatch } = jsonpatch;
-function applyPatches(document2, patches) {
-  if (patches.length === 0) {
-    return document2;
-  }
-  const operations = patches.map((patch) => {
-    const op = {
-      op: patch.op,
-      path: patch.path
-    };
-    if ("value" in patch && patch.value !== void 0) {
-      op.value = patch.value;
-    }
-    if ("from" in patch && patch.from !== void 0) {
-      op.from = patch.from;
-    }
-    return op;
-  });
-  try {
-    const result = applyPatch(
-      structuredClone(document2),
-      operations,
-      true,
-      // Validate operations
-      false
-      // Don't mutate the original
-    );
-    return result.newDocument;
-  } catch (error2) {
-    throw new Error("Failed to apply patches", { cause: error2 });
-  }
-}
-var WebSocketManager = class {
-  config;
-  ws = null;
-  state = "disconnected";
-  reconnectAttempts = 0;
-  reconnectTimer = null;
-  messageQueue = [];
-  messageHandlers = /* @__PURE__ */ new Set();
-  stateHandlers = /* @__PURE__ */ new Set();
-  _connectionId = null;
-  connectionIdResolvers = [];
-  /** Flag to indicate intentional disconnect (skip auto-reconnect) */
-  intentionalDisconnect = false;
-  constructor(config) {
-    this.config = {
-      autoReconnect: true,
-      reconnectDelay: 1e3,
-      maxReconnectAttempts: 10,
-      ...config
-    };
-  }
-  /**
-   * Get the current connection ID (null if not connected)
-   */
-  get connectionId() {
-    return this._connectionId;
-  }
-  /**
-   * Wait for the connection ID to be available
-   */
-  waitForConnectionId() {
-    if (this._connectionId) {
-      return Promise.resolve(this._connectionId);
-    }
-    return new Promise((resolve) => {
-      this.connectionIdResolvers.push(resolve);
-    });
-  }
-  /**
-   * Get current connection state
-   */
-  getState() {
-    return this.state;
-  }
-  /**
-   * Connect to the WebSocket server
-   */
-  async connect() {
-    if (this.state === "connected" || this.state === "connecting") {
-      return;
-    }
-    this.setState("connecting");
-    try {
-      const url = await this.buildUrl();
-      this.ws = new WebSocket(url);
-      this.ws.onopen = () => {
-        this.reconnectAttempts = 0;
-        this.ws?.send(JSON.stringify({ type: "init" }));
-      };
-      this.ws.onclose = () => {
-        this.ws = null;
-        this._connectionId = null;
-        this.setState("disconnected");
-        this.config.onDisconnect?.();
-        if (this.config.autoReconnect && !this.intentionalDisconnect) {
-          this.scheduleReconnect();
-        }
-        this.intentionalDisconnect = false;
-      };
-      this.ws.onerror = () => {
-        const error2 = new Error("WebSocket error");
-        this.config.onError?.(error2);
-      };
-      this.ws.onmessage = (event) => {
-        try {
-          const message = JSON.parse(event.data);
-          if (message.type === "connected") {
-            this._connectionId = message.connectionId;
-            this.ws?.send(JSON.stringify({ type: "ping" }));
-            return;
-          }
-          if (message.type === "pong") {
-            this.setState("connected");
-            this.flushMessageQueue();
-            this.config.onConnect?.();
-            for (const resolve of this.connectionIdResolvers) {
-              resolve(this._connectionId);
-            }
-            this.connectionIdResolvers = [];
-            return;
-          }
-          this.handleMessage(message);
-        } catch (e) {
-          error("Failed to parse WebSocket message:", e);
-        }
-      };
-    } catch (e) {
-      this.setState("disconnected");
-      this.config.onError?.(e instanceof Error ? e : new Error(String(e)));
-      if (this.config.autoReconnect) {
-        this.scheduleReconnect();
-      }
-    }
-  }
-  /**
-   * Disconnect from the WebSocket server
-   */
-  disconnect() {
-    this.intentionalDisconnect = true;
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.close(1e3, "Client disconnect");
-      this.ws = null;
-    }
-    this._connectionId = null;
-    this.setState("disconnected");
-  }
-  /**
-   * Force reconnect - closes existing connection and reconnects
-   * Useful for recovering from stale connections
-   */
-  forceReconnect() {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    if (this.ws) {
-      this.ws.close(1e3, "Force reconnect");
-      this.ws = null;
-    }
-    this._connectionId = null;
-    this.reconnectAttempts = 0;
-    this.setState("disconnected");
-    void this.connect();
-  }
-  /**
-   * Send a message to the server
-   */
-  send(message) {
-    if (this.state === "connected" && this.ws?.readyState === WebSocket.OPEN) {
-      this.ws.send(JSON.stringify(message));
-    } else {
-      this.messageQueue.push(message);
-    }
-  }
-  /**
-   * Subscribe to incoming messages
-   */
-  onMessage(handler) {
-    this.messageHandlers.add(handler);
-    return () => this.messageHandlers.delete(handler);
-  }
-  /**
-   * Subscribe to connection state changes
-   */
-  onStateChange(handler) {
-    this.stateHandlers.add(handler);
-    return () => this.stateHandlers.delete(handler);
-  }
-  async buildUrl() {
-    let url = this.config.url;
-    if (this.config.auth) {
-      const token = typeof this.config.auth === "function" ? await this.config.auth() : this.config.auth;
-      const separator = url.includes("?") ? "&" : "?";
-      url = `${url}${separator}token=${encodeURIComponent(token)}`;
-    }
-    return url;
-  }
-  setState(state) {
-    this.state = state;
-    for (const handler of this.stateHandlers) {
-      handler(state);
-    }
-  }
-  handleMessage(message) {
-    for (const handler of this.messageHandlers) {
-      handler(message);
-    }
-  }
-  scheduleReconnect() {
-    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
-      error("Max reconnection attempts reached");
-      return;
-    }
-    this.setState("reconnecting");
-    this.reconnectAttempts++;
-    const delay = Math.min(
-      this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
-      3e4
-      // Max 30 seconds
-    ) * (0.5 + Math.random() * 0.5);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      void this.connect();
-    }, delay);
-  }
-  flushMessageQueue() {
-    const queue = this.messageQueue;
-    this.messageQueue = [];
-    for (const message of queue) {
-      this.send(message);
-    }
-  }
-};
-var DEFAULT_HTTP_URL = "/api/reactive";
-function generateId() {
-  return `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-}
-var ReactiveClient = class {
-  wsManager;
-  httpUrl;
-  authGetter;
-  headersGetter;
-  subscriptions = /* @__PURE__ */ new Map();
-  pendingCalls = /* @__PURE__ */ new Map();
-  connectionState = "disconnected";
-  stateListeners = /* @__PURE__ */ new Set();
-  // Stores original data for rollback when optimistic updates fail
-  optimisticUpdates = /* @__PURE__ */ new Map();
-  constructor(config) {
-    this.wsManager = new WebSocketManager(config);
-    this.httpUrl = config.httpUrl ?? DEFAULT_HTTP_URL;
-    if (typeof config.auth === "function") {
-      this.authGetter = config.auth;
-    } else if (config.auth) {
-      this.authGetter = () => config.auth;
-    }
-    if (typeof config.headers === "function") {
-      this.headersGetter = config.headers;
-    } else if (config.headers) {
-      this.headersGetter = () => config.headers;
-    }
-    this.wsManager.onMessage((message) => this.handleMessage(message));
-    this.wsManager.onStateChange((state) => {
-      this.connectionState = state;
-      this.notifyStateListeners();
-      if (state === "connected") {
-        this.resubscribeAll();
-      }
-    });
-  }
-  /**
-   * Connect to the server
-   */
-  async connect() {
-    await this.wsManager.connect();
-  }
-  /**
-   * Disconnect from the server
-   */
-  disconnect() {
-    this.wsManager.disconnect();
-  }
-  /**
-   * Force reconnect - closes existing connection and reconnects
-   * Useful for recovering from stale connections
-   */
-  forceReconnect() {
-    this.wsManager.forceReconnect();
-  }
-  /**
-   * Update the headers getter for HTTP requests.
-   * Useful for dynamically setting auth or user context headers.
-   */
-  setHeaders(headers) {
-    if (typeof headers === "function") {
-      this.headersGetter = headers;
-    } else {
-      this.headersGetter = () => headers;
-    }
-  }
-  /**
-   * Get current connection state
-   */
-  getConnectionState() {
-    return this.connectionState;
-  }
-  /**
-   * Subscribe to connection state changes
-   */
-  onConnectionStateChange(listener) {
-    this.stateListeners.add(listener);
-    return () => this.stateListeners.delete(listener);
-  }
-  /**
-   * Subscribe to a procedure via HTTP.
-   * Snapshot is returned via HTTP, patches come via WebSocket.
-   */
-  subscribe(path, options = {}) {
-    const id = generateId();
-    const state = {
-      id,
-      path,
-      input: options.input,
-      data: void 0,
-      loading: true,
-      error: void 0,
-      listeners: /* @__PURE__ */ new Set(),
-      options
-    };
-    this.subscriptions.set(id, state);
-    this.sendSubscribeRequest(id, path, options.input).catch((error2) => {
-      state.error = error2 instanceof Error ? error2 : new Error(String(error2));
-      state.loading = false;
-      this.notifySubscriptionListeners(id);
-      options.onError?.(state.error);
-    });
-    const subscription = {
-      id,
-      get data() {
-        return state.data;
-      },
-      get loading() {
-        return state.loading;
-      },
-      get error() {
-        return state.error;
-      },
-      unsubscribe: () => this.unsubscribe(id),
-      refetch: () => this.refetch(id)
-    };
-    return subscription;
-  }
-  /**
-   * Send subscribe request via HTTP
-   */
-  async sendSubscribeRequest(subscriptionId, path, input) {
-    const connectionId = await this.wsManager.waitForConnectionId();
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.headersGetter) {
-      const customHeaders = await this.headersGetter();
-      Object.assign(headers, customHeaders);
-    }
-    if (this.authGetter) {
-      const token = await this.authGetter();
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const response = await fetch(this.httpUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify({
-        type: "subscribe",
-        connectionId,
-        subscriptionId,
-        path,
-        input
-      })
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Subscribe failed: ${response.status} ${response.statusText}`
-      );
-    }
-    const result = await response.json();
-    if (result.type === "error") {
-      throw new Error(result.message ?? "Unknown error");
-    }
-    if (result.type === "snapshot") {
-      this.handleSnapshot(subscriptionId, result.data);
-    }
-  }
-  /**
-   * Call a mutation procedure via HTTP with optimistic update support.
-   * All optimistic updates are applied INSTANTLY (before HTTP request).
-   */
-  async call(path, input, options) {
-    const invalidatesPath = options?.invalidates;
-    const updateType = options?.optimisticUpdate;
-    let targetSubscriptionId;
-    if (invalidatesPath) {
-      targetSubscriptionId = this.findSubscriptionByPath(invalidatesPath);
-      debug(
-        "[optimistic] Looking for subscription:",
-        invalidatesPath,
-        "-> found:",
-        targetSubscriptionId ?? "NONE"
-      );
-    }
-    if (targetSubscriptionId) {
-      debug(
-        "[optimistic] Applying update type:",
-        updateType,
-        "to subscription:",
-        targetSubscriptionId
-      );
-      const state = this.subscriptions.get(targetSubscriptionId);
-      const currentData = state?.data;
-      if (updateType === "remove") {
-        const inputId = input.id;
-        if (inputId) {
-          this.applyOptimisticUpdate(targetSubscriptionId, (data) => {
-            if (!Array.isArray(data)) return data;
-            return data.filter((item) => item.id !== inputId);
-          });
-        }
-      } else if (updateType === "merge") {
-        const inputWithId = input;
-        if (inputWithId.id) {
-          this.applyOptimisticUpdate(targetSubscriptionId, (data) => {
-            if (!Array.isArray(data)) return data;
-            const idx = data.findIndex(
-              (item) => item.id === inputWithId.id
-            );
-            if (idx >= 0) {
-              return [
-                ...data.slice(0, idx),
-                { ...data[idx], ...input },
-                ...data.slice(idx + 1)
-              ];
-            }
-            return data;
-          });
-        } else if (options?.optimisticData) {
-          const optimistic = typeof options.optimisticData === "function" ? options.optimisticData(input, Array.isArray(currentData) ? currentData : []) : options.optimisticData;
-          if (optimistic) {
-            this.applyOptimisticUpdate(targetSubscriptionId, (data) => {
-              if (!Array.isArray(data)) return data;
-              return [optimistic, ...data];
-            });
-          }
-        }
-      } else if (typeof updateType === "function") {
-        this.applyOptimisticUpdate(targetSubscriptionId, (data) => {
-          if (!Array.isArray(data)) return data;
-          return updateType(data, input, void 0);
-        });
-      }
-    }
-    const connectionId = await this.wsManager.waitForConnectionId();
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (this.headersGetter) {
-      const customHeaders = await this.headersGetter();
-      Object.assign(headers, customHeaders);
-    }
-    if (this.authGetter) {
-      const token = await this.authGetter();
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    try {
-      const response = await fetch(this.httpUrl, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          type: "call",
-          connectionId,
-          path,
-          input
-        })
-      });
-      if (!response.ok) {
-        throw new Error(
-          `Call failed: ${response.status} ${response.statusText}`
-        );
-      }
-      const result = await response.json();
-      if (result.type === "error") {
-        throw new Error(result.message ?? "Unknown error");
-      }
-      const data = result.data;
-      if (targetSubscriptionId && updateType === "merge") {
-        const resultWithId = data;
-        if (resultWithId.id) {
-          this.applyOptimisticUpdate(targetSubscriptionId, (currentData) => {
-            if (!Array.isArray(currentData)) return currentData;
-            const idx = currentData.findIndex(
-              (item) => item.id === resultWithId.id
-            );
-            if (idx >= 0) {
-              return [
-                ...currentData.slice(0, idx),
-                data,
-                ...currentData.slice(idx + 1)
-              ];
-            } else {
-              return [
-                data,
-                ...currentData.filter(
-                  (item) => item.id && !item.id.startsWith("temp-")
-                )
-              ];
-            }
-          });
-        }
-      }
-      return data;
-    } catch (error2) {
-      if (targetSubscriptionId) {
-        this.rollbackOptimisticUpdate(targetSubscriptionId);
-      }
-      throw error2;
-    }
-  }
-  /**
-   * Unsubscribe from a subscription
-   */
-  unsubscribe(id) {
-    const state = this.subscriptions.get(id);
-    if (!state) return;
-    this.subscriptions.delete(id);
-    this.wsManager.send({
-      type: "unsubscribe",
-      subscriptionId: id
-    });
-  }
-  /**
-   * Refetch a subscription via HTTP
-   */
-  async refetch(id) {
-    const state = this.subscriptions.get(id);
-    if (!state) return;
-    state.loading = true;
-    this.notifySubscriptionListeners(id);
-    try {
-      await this.sendSubscribeRequest(id, state.path, state.input);
-    } catch (error2) {
-      state.error = error2 instanceof Error ? error2 : new Error(String(error2));
-      state.loading = false;
-      this.notifySubscriptionListeners(id);
-      state.options.onError?.(state.error);
-    }
-  }
-  /**
-   * Handle incoming server messages.
-   * Note: 'connected' messages are handled by WebSocketManager before reaching here.
-   */
-  handleMessage(message) {
-    switch (message.type) {
-      case "connected":
-        break;
-      case "pong":
-        break;
-      case "snapshot":
-        this.handleSnapshot(message.subscriptionId, message.data);
-        break;
-      case "patch":
-        this.handlePatch(message.subscriptionId, message.patches);
-        break;
-      case "result":
-        this.handleResult(message.callId, message.data);
-        break;
-      case "error":
-        this.handleError(message);
-        break;
-    }
-  }
-  /**
-   * Handle a snapshot message
-   */
-  handleSnapshot(subscriptionId, data) {
-    const state = this.subscriptions.get(subscriptionId);
-    if (!state) return;
-    this.clearOptimisticUpdate(subscriptionId);
-    state.data = data;
-    state.loading = false;
-    state.error = void 0;
-    this.notifySubscriptionListeners(subscriptionId);
-    state.options.onData?.(data);
-  }
-  /**
-   * Handle a patch message
-   */
-  handlePatch(subscriptionId, patches) {
-    const state = this.subscriptions.get(subscriptionId);
-    if (!state || state.data === void 0) return;
-    const originalData = this.optimisticUpdates.get(subscriptionId);
-    const baseData = originalData !== void 0 ? originalData : state.data;
-    this.clearOptimisticUpdate(subscriptionId);
-    try {
-      state.data = applyPatches(baseData, patches);
-      this.notifySubscriptionListeners(subscriptionId);
-      state.options.onData?.(state.data);
-    } catch (error2) {
-      state.error = error2 instanceof Error ? error2 : new Error(String(error2));
-      this.notifySubscriptionListeners(subscriptionId);
-      state.options.onError?.(state.error);
-    }
-  }
-  /**
-   * Handle a result message
-   */
-  handleResult(callId, data) {
-    const pending = this.pendingCalls.get(callId);
-    if (!pending) return;
-    this.pendingCalls.delete(callId);
-    pending.resolve(data);
-  }
-  /**
-   * Handle an error message
-   */
-  handleError(message) {
-    const error2 = new Error(message.message);
-    if (message.subscriptionId) {
-      const state = this.subscriptions.get(message.subscriptionId);
-      if (state) {
-        state.error = error2;
-        state.loading = false;
-        this.notifySubscriptionListeners(message.subscriptionId);
-        state.options.onError?.(error2);
-      }
-    }
-    if (message.callId) {
-      const pending = this.pendingCalls.get(message.callId);
-      if (pending) {
-        this.pendingCalls.delete(message.callId);
-        pending.reject(error2);
-      }
-    }
-  }
-  /**
-   * Resubscribe to all subscriptions after reconnect via HTTP
-   */
-  resubscribeAll() {
-    for (const [id, state] of this.subscriptions) {
-      if (state.options.resubscribeOnReconnect !== false) {
-        state.loading = true;
-        this.notifySubscriptionListeners(id);
-        this.sendSubscribeRequest(id, state.path, state.input).catch(
-          (error2) => {
-            state.error = error2 instanceof Error ? error2 : new Error(String(error2));
-            state.loading = false;
-            this.notifySubscriptionListeners(id);
-            state.options.onError?.(state.error);
-          }
-        );
-      }
-    }
-  }
-  /**
-   * Notify subscription listeners of state changes
-   */
-  notifySubscriptionListeners(id) {
-    const state = this.subscriptions.get(id);
-    if (!state) return;
-    for (const listener of state.listeners) {
-      listener();
-    }
-  }
-  /**
-   * Notify connection state listeners
-   */
-  notifyStateListeners() {
-    for (const listener of this.stateListeners) {
-      listener(this.connectionState);
-    }
-  }
-  /**
-   * Add a listener for subscription state changes
-   * Used internally by React hooks
-   */
-  addSubscriptionListener(id, listener) {
-    const state = this.subscriptions.get(id);
-    if (!state) return () => {
-    };
-    state.listeners.add(listener);
-    return () => state.listeners.delete(listener);
-  }
-  /**
-   * Get subscription state
-   * Used internally by React hooks
-   */
-  getSubscriptionState(id) {
-    return this.subscriptions.get(id);
-  }
-  /**
-   * Find subscription by path
-   */
-  findSubscriptionByPath(path) {
-    debug(
-      "[optimistic] Searching for path:",
-      path,
-      "in subscriptions:",
-      Array.from(this.subscriptions.entries()).map(([id, s]) => ({
-        id,
-        path: s.path
-      }))
-    );
-    for (const [id, state] of this.subscriptions) {
-      if (state.path === path) {
-        return id;
-      }
-    }
-    return void 0;
-  }
-  /**
-   * Apply an optimistic update to a subscription's data.
-   * Stores the original data for rollback (on mutation error) or as base for
-   * incoming server patches. Safe to call after external API calls — the next
-   * server snapshot/patch will reconcile automatically.
-   */
-  applyOptimisticUpdate(subscriptionId, updater) {
-    const state = this.subscriptions.get(subscriptionId);
-    if (!state) {
-      debug(
-        "[optimistic] applyOptimisticUpdate: subscription not found:",
-        subscriptionId
-      );
-      return;
-    }
-    if (state.data === void 0) {
-      debug(
-        "[optimistic] applyOptimisticUpdate: subscription data is undefined (still loading?):",
-        subscriptionId
-      );
-      return;
-    }
-    debug(
-      "[optimistic] applyOptimisticUpdate: applying update, current data length:",
-      Array.isArray(state.data) ? state.data.length : "not array"
-    );
-    if (!this.optimisticUpdates.has(subscriptionId)) {
-      this.optimisticUpdates.set(
-        subscriptionId,
-        JSON.parse(JSON.stringify(state.data))
-      );
-    }
-    state.data = updater(state.data);
-    this.notifySubscriptionListeners(subscriptionId);
-  }
-  /**
-   * Rollback an optimistic update
-   */
-  rollbackOptimisticUpdate(subscriptionId) {
-    const original = this.optimisticUpdates.get(subscriptionId);
-    if (original === void 0) return;
-    const state = this.subscriptions.get(subscriptionId);
-    if (state) {
-      state.data = original;
-      this.notifySubscriptionListeners(subscriptionId);
-    }
-    this.optimisticUpdates.delete(subscriptionId);
-  }
-  /**
-   * Clear optimistic state (called when real data arrives)
-   */
-  clearOptimisticUpdate(subscriptionId) {
-    this.optimisticUpdates.delete(subscriptionId);
-  }
-};
-function createReactiveClient(config) {
-  const client = new ReactiveClient(config);
-  return createTypedProxy(client, []);
-}
-function createTypedProxy(client, path) {
-  return new Proxy(
-    {},
-    {
-      get(_target, prop) {
-        if (prop === "_client") return client;
-        if (prop === "connect") return () => client.connect();
-        if (prop === "disconnect") return () => client.disconnect();
-        if (typeof prop !== "string") return void 0;
-        const newPath = [...path, prop];
-        if (prop === "useSubscription") {
-          return (input, options) => {
-            const parentPath = path.join(".");
-            return client.subscribe(parentPath, { ...options, input });
-          };
-        }
-        if (prop === "mutate") {
-          return async (input) => {
-            const parentPath = path.join(".");
-            const invalidatesPath = path.length >= 2 ? `${path.slice(0, -1).join(".")}.list` : void 0;
-            const updateType = parentPath.endsWith(".delete") ? "remove" : "merge";
-            return client.call(parentPath, input, {
-              invalidates: invalidatesPath,
-              optimisticUpdate: updateType
-            });
-          };
-        }
-        return createTypedProxy(client, newPath);
-      }
-    }
-  );
-}
-var ReactiveClientContext = createContext(null);
-function ReactiveClientProvider({
-  children,
-  config,
-  client: externalClient
-}) {
-  const url = config?.url;
-  const hasUrl = Boolean(url);
-  const [client, setClient] = useState(
-    externalClient ?? null
-  );
-  useEffect(() => {
-    if (externalClient || !url) return;
-    if (!client) {
-      const newClient = new ReactiveClient({ ...config, url });
-      setClient(newClient);
-    }
-  }, [url, externalClient]);
-  useEffect(() => {
-    if (!client) return;
-    void client.connect();
-    return () => {
-      client.disconnect();
-    };
-  }, [client]);
-  useEffect(() => {
-    if (typeof window === "undefined" || typeof document === "undefined") {
-      return;
-    }
-    if (!client) return;
-    const attemptReconnect = () => {
-      const state = client.getConnectionState();
-      if (state === "connected") {
-        return;
-      }
-      if (state === "connecting") {
-        return;
-      }
-      if (state === "reconnecting") {
-        debug(
-          "[dynamodb-reactive] Tab became active during reconnect backoff, forcing reconnect..."
-        );
-        client.forceReconnect();
-      } else {
-        debug(
-          "[dynamodb-reactive] Tab became active while disconnected, reconnecting..."
-        );
-        void client.connect();
-      }
-    };
-    const handleVisibilityChange = () => {
-      if (document.visibilityState === "visible") {
-        attemptReconnect();
-      }
-    };
-    const handleFocus = () => {
-      attemptReconnect();
-    };
-    document.addEventListener("visibilitychange", handleVisibilityChange);
-    window.addEventListener("focus", handleFocus);
-    return () => {
-      document.removeEventListener("visibilitychange", handleVisibilityChange);
-      window.removeEventListener("focus", handleFocus);
-    };
-  }, [client]);
-  useEffect(() => {
-    if (!hasUrl && process.env.NODE_ENV === "development") {
-      warn(
-        "[dynamodb-reactive] WebSocket URL not configured, real-time features disabled"
-      );
-    }
-  }, [hasUrl]);
-  return /* @__PURE__ */ jsx(ReactiveClientContext.Provider, { value: client, children });
-}
-function useReactiveClient() {
-  return useContext(ReactiveClientContext);
-}
-function useReactiveClientOrThrow() {
-  const client = useContext(ReactiveClientContext);
-  if (!client) {
-    throw new Error(
-      "useReactiveClientOrThrow must be used within a ReactiveClientProvider with a configured URL"
-    );
-  }
-  return client;
-}
-function useConnectionState() {
-  const client = useReactiveClient();
-  return useSyncExternalStore(
-    (callback) => {
-      if (!client) return () => {
-      };
-      return client.onConnectionStateChange(callback);
-    },
-    () => client ? client.getConnectionState() : "disabled",
-    () => "disabled"
-  );
-}
-function useSubscription(path, options = {}) {
-  const client = useReactiveClient();
-  const subscriptionRef = useRef(null);
-  const [state, setState] = useState({
-    data: void 0,
-    loading: !client ? false : true,
-    error: void 0
-  });
-  const inputKey = JSON.stringify(options.input);
-  const onDataRef = useRef(options.onData);
-  const onErrorRef = useRef(options.onError);
-  onDataRef.current = options.onData;
-  onErrorRef.current = options.onError;
-  useEffect(() => {
-    if (!client) return;
-    const input = inputKey ? JSON.parse(inputKey) : void 0;
-    const subscription = client.subscribe(path, {
-      input,
-      onData: (data) => {
-        setState((prev) => ({
-          ...prev,
-          data,
-          loading: false,
-          error: void 0
-        }));
-        onDataRef.current?.(data);
-      },
-      onError: (error2) => {
-        setState((prev) => ({
-          ...prev,
-          error: error2,
-          loading: false
-        }));
-        onErrorRef.current?.(error2);
-      }
-    });
-    subscriptionRef.current = subscription;
-    const unregisterListener = client.addSubscriptionListener(
-      subscription.id,
-      () => {
-        debug(
-          "[optimistic] useSubscription listener fired for:",
-          path,
-          "data length:",
-          Array.isArray(subscription.data) ? subscription.data.length : "not array"
-        );
-        setState({
-          data: subscription.data,
-          loading: subscription.loading,
-          error: subscription.error
-        });
-      }
-    );
-    setState({
-      data: subscription.data,
-      loading: subscription.loading,
-      error: subscription.error
-    });
-    return () => {
-      unregisterListener();
-      subscription.unsubscribe();
-      subscriptionRef.current = null;
-    };
-  }, [client, path, inputKey]);
-  const refetch = async () => {
-    if (subscriptionRef.current) {
-      setState((prev) => ({ ...prev, loading: true }));
-      await subscriptionRef.current.refetch();
-    }
-  };
-  const setData = useCallback(
-    (updater) => {
-      if (client && subscriptionRef.current) {
-        client.applyOptimisticUpdate(
-          subscriptionRef.current.id,
-          updater
-        );
-      }
-    },
-    [client]
-  );
-  return {
-    ...state,
-    disabled: !client,
-    refetch,
-    setData
-  };
-}
-function useMutation(path, options) {
-  const client = useReactiveClient();
-  const [state, setState] = useState({
-    data: void 0,
-    loading: false,
-    error: void 0
-  });
-  const autoInvalidates = options?.invalidates ?? (() => {
-    const parts = path.split(".");
-    if (parts.length >= 2) {
-      return `${parts.slice(0, -1).join(".")}.list`;
-    }
-    return void 0;
-  })();
-  const autoUpdateType = options?.optimisticUpdate ?? (path.endsWith(".delete") ? "remove" : "merge");
-  const mutate = async (input) => {
-    if (!client) {
-      throw new Error("WebSocket not configured - mutations are disabled");
-    }
-    debug("[optimistic] useMutation.mutate called:", {
-      path,
-      autoInvalidates,
-      autoUpdateType,
-      input
-    });
-    setState((prev) => ({ ...prev, loading: true, error: void 0 }));
-    try {
-      const result = await client.call(path, input, {
-        invalidates: autoInvalidates,
-        optimisticUpdate: autoUpdateType
-      });
-      setState({ data: result, loading: false, error: void 0 });
-      return result;
-    } catch (error2) {
-      const err = error2 instanceof Error ? error2 : new Error(String(error2));
-      setState((prev) => ({ ...prev, loading: false, error: err }));
-      throw err;
-    }
-  };
-  const reset = () => {
-    setState({ data: void 0, loading: false, error: void 0 });
-  };
-  return {
-    mutate,
-    ...state,
-    disabled: !client,
-    reset
-  };
-}
-function useClient() {
-  const client = useReactiveClient();
-  function buildProxy(path) {
-    return new Proxy(
-      {},
-      {
-        get(_target, prop) {
-          if (prop === "useQuery") {
-            return function useQueryHook(input, options) {
-              const pathStr = path.join(".");
-              return useSubscription(pathStr, { ...options, input });
-            };
-          }
-          if (prop === "useMutation") {
-            return function useMutationHook(options) {
-              const pathStr = path.join(".");
-              return useMutation(pathStr, options);
-            };
-          }
-          if (prop === "setHeaders") {
-            return (headers) => {
-              client?.setHeaders(headers);
-            };
-          }
-          return buildProxy([...path, prop]);
-        }
-      }
-    );
-  }
-  return buildProxy([]);
-}
-function createReactiveHooks() {
-  return {
-    useSubscription: (path, options) => useSubscription(path, options),
-    useMutation: (path, options) => useMutation(path, options),
-    useConnectionState,
-    useReactiveClient
-  };
-}
-function createProcedureHooks(path) {
-  return {
-    useSubscription: (input, options) => useSubscription(path, { ...options, input }),
-    useMutation: (options) => useMutation(path, options)
-  };
-}
-
-export { ReactiveClient, ReactiveClientProvider, WebSocketManager, applyPatches, createProcedureHooks, createReactiveClient, createReactiveHooks, useClient, useConnectionState, useMutation, useReactiveClient, useReactiveClientOrThrow, useSubscription };
-//# sourceMappingURL=chunk-2KC44Q5I.js.map
-//# sourceMappingURL=chunk-2KC44Q5I.js.map