dynamodb-reactive 0.1.21 → 0.2.1

package/dist/react.cjs

@@ -0,0 +1,1250 @@
+'use strict';
+
+var react = require('react');
+var jsonpatch = require('fast-json-patch');
+var jsxRuntime = require('react/jsx-runtime');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var jsonpatch__default = /*#__PURE__*/_interopDefault(jsonpatch);
+
+// ../client/src/react.tsx
+
+// ../client/src/canonical.ts
+function canonicalize(value, seen, key, arrayItem = false, applyToJSON = true) {
+  if (value === null) return "null";
+  switch (typeof value) {
+    case "string":
+    case "boolean":
+      return JSON.stringify(value);
+    case "number":
+      return Number.isFinite(value) ? JSON.stringify(value) : "null";
+    case "undefined":
+      return arrayItem ? "null" : void 0;
+    case "object": {
+      if (applyToJSON && "toJSON" in value && typeof value.toJSON === "function") {
+        return canonicalize(value.toJSON(key), seen, key, arrayItem, false);
+      }
+      if (seen.has(value)) {
+        throw new TypeError("Query input must not contain circular references");
+      }
+      seen.add(value);
+      try {
+        if (Array.isArray(value)) {
+          const items = [];
+          for (let index = 0; index < value.length; index++) {
+            items.push(
+              canonicalize(value[index], seen, String(index), true) ?? "null"
+            );
+          }
+          return `[${items.join(",")}]`;
+        }
+        const object = value;
+        const entries = [];
+        for (const key2 of Object.keys(object).sort()) {
+          const item = canonicalize(object[key2], seen, key2);
+          if (item !== void 0) {
+            entries.push(`${JSON.stringify(key2)}:${item}`);
+          }
+        }
+        return `{${entries.join(",")}}`;
+      } finally {
+        seen.delete(value);
+      }
+    }
+    default:
+      throw new TypeError(`Unsupported query input value: ${typeof value}`);
+  }
+}
+function getQueryKey(path, input) {
+  return `${JSON.stringify(path)}:${canonicalize(input, /* @__PURE__ */ new Set(), "") ?? "undefined"}`;
+}
+var { applyPatch } = jsonpatch__default.default;
+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 });
+  }
+}
+
+// ../client/src/log.ts
+function debug(...values) {
+  if (globalThis.__DYNAMODB_REACTIVE_DEBUG__) {
+    console.debug(...values);
+  }
+}
+function warn(...values) {
+  console.warn(...values);
+}
+function error(...values) {
+  console.error(...values);
+}
+
+// ../client/src/websocket.ts
+var HEARTBEAT_INTERVAL_MS = 5 * 60 * 1e3;
+function withDefaults(config) {
+  return {
+    autoReconnect: true,
+    connectionTimeout: 1e4,
+    handshakeTimeout: 1e4,
+    maxReconnectAttempts: 10,
+    reconnectDelay: 1e3,
+    ...config
+  };
+}
+var WebSocketManager = class {
+  config;
+  ws = null;
+  state = "disconnected";
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  handshakeTimer = null;
+  heartbeatTimer = null;
+  messageHandlers = /* @__PURE__ */ new Set();
+  stateHandlers = /* @__PURE__ */ new Set();
+  handshakeHandlers = /* @__PURE__ */ new Set();
+  _connectionId = null;
+  connectionWaiters = /* @__PURE__ */ new Set();
+  socketGeneration = 0;
+  intentionalDisconnect = false;
+  constructor(config) {
+    this.config = withDefaults(config);
+  }
+  /** Apply settings used by future requests/events without replacing the socket. */
+  configure(config) {
+    this.config = withDefaults(config);
+  }
+  get connectionId() {
+    return this._connectionId;
+  }
+  get generation() {
+    return this.socketGeneration;
+  }
+  waitForConnectionId(options = {}) {
+    if (this._connectionId && this.state === "connected") {
+      return Promise.resolve(this._connectionId);
+    }
+    if (options.signal?.aborted) {
+      return Promise.reject(new Error("Connection wait aborted"));
+    }
+    const timeoutMs = options.timeoutMs ?? this.config.connectionTimeout;
+    return new Promise((resolve, reject) => {
+      let timeout;
+      const abort = () => finish(new Error("Connection wait aborted"));
+      const waiter = {
+        resolve,
+        reject,
+        cleanup: () => {
+          if (timeout) clearTimeout(timeout);
+          options.signal?.removeEventListener("abort", abort);
+        }
+      };
+      const finish = (failure) => {
+        if (!this.connectionWaiters.delete(waiter)) return;
+        waiter.cleanup();
+        reject(failure);
+      };
+      this.connectionWaiters.add(waiter);
+      options.signal?.addEventListener("abort", abort, { once: true });
+      timeout = setTimeout(
+        () => finish(new Error(`Connection timed out after ${timeoutMs}ms`)),
+        timeoutMs
+      );
+    });
+  }
+  getState() {
+    return this.state;
+  }
+  async connect() {
+    if (this.state === "connected") return;
+    if (this.state === "connecting") {
+      await this.waitForConnectionId();
+      return;
+    }
+    this.intentionalDisconnect = false;
+    const generation = ++this.socketGeneration;
+    this.setState("connecting");
+    let socket;
+    try {
+      const url = await this.buildUrl();
+      if (generation !== this.socketGeneration || this.intentionalDisconnect) {
+        return;
+      }
+      const nextSocket = new WebSocket(url);
+      socket = nextSocket;
+      this.ws = nextSocket;
+      this.startHandshakeTimer(nextSocket, generation);
+      nextSocket.onopen = () => {
+        if (!this.isCurrent(nextSocket, generation)) return;
+        nextSocket.send(JSON.stringify({ type: "init" }));
+      };
+      nextSocket.onclose = () => {
+        if (!this.isCurrent(nextSocket, generation)) return;
+        this.clearConnectionTimers();
+        this.ws = null;
+        this._connectionId = null;
+        this.setState("disconnected");
+        this.invokeLifecycleCallback(
+          "onDisconnect",
+          this.config.onDisconnect
+        );
+        if (this.config.autoReconnect && !this.intentionalDisconnect) {
+          this.scheduleReconnect();
+        } else {
+          this.rejectWaiters(new Error("WebSocket disconnected"));
+        }
+      };
+      nextSocket.onerror = () => {
+        if (!this.isCurrent(nextSocket, generation)) return;
+        this.invokeLifecycleCallback(
+          "onError",
+          this.config.onError,
+          new Error("WebSocket error")
+        );
+      };
+      nextSocket.onmessage = (event) => {
+        if (!this.isCurrent(nextSocket, generation)) return;
+        this.receiveMessage(nextSocket, generation, event.data);
+      };
+    } catch (cause) {
+      if (generation !== this.socketGeneration) return;
+      const failure = cause instanceof Error ? cause : new Error(String(cause));
+      this.clearConnectionTimers();
+      if (socket && this.ws === socket) socket.close();
+      this.ws = null;
+      this._connectionId = null;
+      this.setState("disconnected");
+      this.invokeLifecycleCallback("onError", this.config.onError, failure);
+      if (this.config.autoReconnect && !this.intentionalDisconnect) {
+        this.scheduleReconnect();
+        await this.waitForConnectionId();
+        return;
+      }
+      this.rejectWaiters(failure);
+      throw failure;
+    }
+    await this.waitForConnectionId();
+  }
+  disconnect() {
+    this.intentionalDisconnect = true;
+    ++this.socketGeneration;
+    this.clearTimers();
+    const socket = this.ws;
+    this.ws = null;
+    socket?.close(1e3, "Client disconnect");
+    this._connectionId = null;
+    this.setState("disconnected");
+    this.rejectWaiters(new Error("WebSocket disconnected"));
+  }
+  forceReconnect() {
+    this.intentionalDisconnect = false;
+    ++this.socketGeneration;
+    this.clearTimers();
+    const socket = this.ws;
+    this.ws = null;
+    socket?.close(1e3, "Force reconnect");
+    this._connectionId = null;
+    this.reconnectAttempts = 0;
+    this.setState("disconnected");
+    void this.connect().catch(() => void 0);
+  }
+  onMessage(handler) {
+    this.messageHandlers.add(handler);
+    return () => this.messageHandlers.delete(handler);
+  }
+  onStateChange(handler) {
+    this.stateHandlers.add(handler);
+    return () => this.stateHandlers.delete(handler);
+  }
+  onHandshake(handler) {
+    this.handshakeHandlers.add(handler);
+    return () => this.handshakeHandlers.delete(handler);
+  }
+  async buildUrl() {
+    let url = this.config.url;
+    if (!this.config.auth) return url;
+    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;
+  }
+  receiveMessage(socket, generation, rawData) {
+    try {
+      const message = JSON.parse(String(rawData));
+      if (message.type === "connected") {
+        if (this._connectionId) return;
+        this._connectionId = message.connectionId;
+        socket.send(JSON.stringify({ type: "ping" }));
+        return;
+      }
+      if (message.type === "pong") {
+        if (!this._connectionId || this.state === "connected") return;
+        this.clearHandshakeTimer();
+        this.reconnectAttempts = 0;
+        this.setState("connected");
+        this.startHeartbeat(socket, generation);
+        this.invokeLifecycleCallback("onConnect", this.config.onConnect);
+        this.resolveWaiters(this._connectionId);
+        for (const handler of this.handshakeHandlers) handler(generation);
+        return;
+      }
+      for (const handler of this.messageHandlers) handler(message);
+    } catch (cause) {
+      error("Failed to parse WebSocket message:", cause);
+    }
+  }
+  startHandshakeTimer(socket, generation) {
+    this.clearHandshakeTimer();
+    this.handshakeTimer = setTimeout(() => {
+      if (!this.isCurrent(socket, generation) || this.state === "connected") {
+        return;
+      }
+      const failure = new Error("WebSocket handshake timed out");
+      this.invokeLifecycleCallback("onError", this.config.onError, failure);
+      socket.close(4e3, "Handshake timeout");
+    }, this.config.handshakeTimeout);
+  }
+  startHeartbeat(socket, generation) {
+    this.clearHeartbeatTimer();
+    this.heartbeatTimer = setInterval(() => {
+      if (!this.isCurrent(socket, generation) || this.state !== "connected" || socket.readyState !== WebSocket.OPEN) {
+        return;
+      }
+      socket.send(JSON.stringify({ type: "ping" }));
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  isCurrent(socket, generation) {
+    return this.ws === socket && this.socketGeneration === generation;
+  }
+  setState(state) {
+    if (this.state === state) return;
+    this.state = state;
+    for (const handler of this.stateHandlers) handler(state);
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer || this.intentionalDisconnect) return;
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      const failure = new Error("Max reconnection attempts reached");
+      error(failure.message);
+      this.setState("disconnected");
+      this.rejectWaiters(failure);
+      this.invokeLifecycleCallback("onError", this.config.onError, failure);
+      return;
+    }
+    this.setState("reconnecting");
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.config.reconnectDelay * 2 ** (this.reconnectAttempts - 1),
+      3e4
+    ) * (0.5 + Math.random() * 0.5);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connect().catch(() => void 0);
+    }, delay);
+  }
+  resolveWaiters(connectionId) {
+    const waiters = [...this.connectionWaiters];
+    this.connectionWaiters.clear();
+    for (const waiter of waiters) {
+      waiter.cleanup();
+      waiter.resolve(connectionId);
+    }
+  }
+  invokeLifecycleCallback(name, callback, ...args) {
+    if (!callback) return;
+    try {
+      callback(...args);
+    } catch (cause) {
+      try {
+        error(`[dynamodb-reactive] ${name} callback failed:`, cause);
+      } catch {
+      }
+    }
+  }
+  rejectWaiters(failure) {
+    const waiters = [...this.connectionWaiters];
+    this.connectionWaiters.clear();
+    for (const waiter of waiters) {
+      waiter.cleanup();
+      waiter.reject(failure);
+    }
+  }
+  clearHandshakeTimer() {
+    if (!this.handshakeTimer) return;
+    clearTimeout(this.handshakeTimer);
+    this.handshakeTimer = null;
+  }
+  clearHeartbeatTimer() {
+    if (!this.heartbeatTimer) return;
+    clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = null;
+  }
+  clearConnectionTimers() {
+    this.clearHandshakeTimer();
+    this.clearHeartbeatTimer();
+  }
+  clearTimers() {
+    this.clearConnectionTimers();
+    if (!this.reconnectTimer) return;
+    clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+  }
+};
+
+// ../client/src/client.ts
+var DEFAULT_HTTP_URL = "/api/reactive";
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 11)}`;
+}
+var ReactiveClient = class {
+  wsManager;
+  httpUrl;
+  authGetter;
+  headersGetter;
+  subscriptionsById = /* @__PURE__ */ new Map();
+  subscriptionsByKey = /* @__PURE__ */ new Map();
+  connectionState = "disconnected";
+  stateListeners = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.wsManager = new WebSocketManager(config);
+    this.httpUrl = config.httpUrl ?? DEFAULT_HTTP_URL;
+    this.setAuth(config.auth);
+    this.setInitialHeaders(config.headers);
+    this.wsManager.onMessage((message) => this.handleMessage(message));
+    this.wsManager.onStateChange((state) => {
+      this.connectionState = state;
+      this.notifyStateListeners();
+      if (state === "disconnected" || state === "reconnecting") {
+        this.markSubscriptionsStale();
+      }
+    });
+    this.wsManager.onHandshake((socketGeneration) => {
+      this.registerActiveSubscriptions(socketGeneration);
+    });
+  }
+  /** Apply live configuration without replacing subscription caches or the socket. */
+  configure(config) {
+    this.httpUrl = config.httpUrl ?? DEFAULT_HTTP_URL;
+    this.authGetter = this.toAuthGetter(config.auth);
+    this.headersGetter = this.toHeadersGetter(config.headers);
+    this.wsManager.configure(config);
+  }
+  async connect() {
+    await this.wsManager.connect();
+  }
+  disconnect() {
+    this.wsManager.disconnect();
+  }
+  forceReconnect() {
+    this.wsManager.forceReconnect();
+  }
+  getConnectionState() {
+    return this.connectionState;
+  }
+  onConnectionStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => this.stateListeners.delete(listener);
+  }
+  subscribe(path, options = {}) {
+    const key = getQueryKey(path, options.input);
+    let shared = this.subscriptionsByKey.get(key);
+    if (!shared) {
+      shared = {
+        id: generateId(),
+        key,
+        path,
+        input: options.input,
+        authoritativeData: void 0,
+        data: void 0,
+        loading: true,
+        stale: true,
+        error: void 0,
+        listeners: /* @__PURE__ */ new Set(),
+        observers: /* @__PURE__ */ new Map(),
+        active: true,
+        hasRegistered: false,
+        generation: 0,
+        registrationId: void 0,
+        registrationConnectionId: void 0,
+        registrationSocketGeneration: void 0,
+        registrationPromise: void 0,
+        version: void 0,
+        patchBuffer: /* @__PURE__ */ new Map(),
+        appliedMessageIds: /* @__PURE__ */ new Set(),
+        resyncPromise: void 0,
+        resyncGeneration: void 0,
+        optimisticLayers: /* @__PURE__ */ new Map(),
+        settlementRevision: 0,
+        registrationSettlementRevision: 0,
+        revision: 0
+      };
+      this.subscriptionsByKey.set(key, shared);
+      this.subscriptionsById.set(shared.id, shared);
+      if (this.connectionState === "connected") {
+        void this.ensureRegistered(
+          shared,
+          this.wsManager.generation
+        ).catch(() => void 0);
+      }
+    }
+    const leaseId = generateId();
+    shared.observers.set(leaseId, {
+      onData: options.onData ? (data) => options.onData?.(data) : void 0,
+      onError: options.onError
+    });
+    if (this.connectionState === "connected" && (!shared.hasRegistered || shared.stale) && !shared.registrationPromise) {
+      void this.ensureRegistered(shared, this.wsManager.generation).catch(
+        () => void 0
+      );
+    }
+    const state = shared;
+    let released = false;
+    return {
+      id: state.id,
+      key: state.key,
+      get data() {
+        return state.data;
+      },
+      get loading() {
+        return state.loading;
+      },
+      get stale() {
+        return state.stale;
+      },
+      get error() {
+        return state.error;
+      },
+      unsubscribe: () => {
+        if (released) return;
+        released = true;
+        this.releaseSubscription(state, leaseId);
+      },
+      refetch: () => this.refetch(state)
+    };
+  }
+  async call(path, input, options) {
+    const mutationId = generateId();
+    const layers = [];
+    try {
+      this.createMutationLayers(mutationId, input, options, layers);
+      const connectionId = await this.wsManager.waitForConnectionId();
+      const headers = await this.buildHeaders();
+      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;
+      this.settleMutationLayers(mutationId, input, data, options, layers);
+      return data;
+    } catch (cause) {
+      this.removeMutationLayers(mutationId, layers);
+      throw cause;
+    }
+  }
+  addSubscriptionListener(id, listener) {
+    const state = this.subscriptionsById.get(id);
+    if (!state) return () => void 0;
+    state.listeners.add(listener);
+    return () => state.listeners.delete(listener);
+  }
+  getSubscriptionRevision(id) {
+    return this.subscriptionsById.get(id)?.revision ?? -1;
+  }
+  applyOptimisticUpdate(subscriptionId, updater) {
+    const state = this.subscriptionsById.get(subscriptionId);
+    if (!state || state.data === void 0) return;
+    state.optimisticLayers.set(`local-${generateId()}`, {
+      updater
+    });
+    this.recomputeData(state);
+    this.notifySubscription(state, true);
+  }
+  setAuth(auth) {
+    this.authGetter = this.toAuthGetter(auth);
+  }
+  setInitialHeaders(headers) {
+    this.headersGetter = this.toHeadersGetter(headers);
+  }
+  toAuthGetter(auth) {
+    if (!auth) return void 0;
+    return typeof auth === "function" ? auth : () => auth;
+  }
+  toHeadersGetter(headers) {
+    if (!headers) return void 0;
+    return typeof headers === "function" ? headers : () => headers;
+  }
+  registerActiveSubscriptions(socketGeneration) {
+    for (const state of this.subscriptionsByKey.values()) {
+      if (state.active) {
+        void this.ensureRegistered(state, socketGeneration).catch(
+          () => void 0
+        );
+      }
+    }
+  }
+  ensureRegistered(state, socketGeneration, force = false) {
+    if (!force && state.registrationSocketGeneration === socketGeneration && state.registrationPromise) {
+      return state.registrationPromise;
+    }
+    state.generation++;
+    state.registrationSettlementRevision = state.settlementRevision;
+    state.registrationId = generateId();
+    state.registrationSocketGeneration = socketGeneration;
+    state.registrationConnectionId = void 0;
+    state.registrationPromise = void 0;
+    state.resyncPromise = void 0;
+    state.resyncGeneration = void 0;
+    state.hasRegistered = false;
+    state.version = void 0;
+    state.patchBuffer.clear();
+    state.appliedMessageIds.clear();
+    state.loading = true;
+    state.stale = true;
+    state.error = void 0;
+    this.notifySubscription(state);
+    const generation = state.generation;
+    const registrationId = state.registrationId;
+    const isCurrent = () => state.active && state.generation === generation && state.registrationId === registrationId && state.registrationSocketGeneration === socketGeneration && this.wsManager.generation === socketGeneration;
+    let requestIssued = false;
+    let registrationConnectionId;
+    let request;
+    request = (async () => {
+      try {
+        const connectionId = await this.wsManager.waitForConnectionId();
+        if (!isCurrent()) return;
+        registrationConnectionId = connectionId;
+        state.registrationConnectionId = connectionId;
+        const headers = await this.buildHeaders();
+        if (!isCurrent()) return;
+        requestIssued = true;
+        const response = await fetch(this.httpUrl, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            type: "subscribe",
+            connectionId,
+            subscriptionId: state.id,
+            generation,
+            registrationId,
+            path: state.path,
+            input: state.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);
+        }
+        if (!isCurrent()) return;
+        this.handleSnapshot(result);
+        if (isCurrent()) state.hasRegistered = true;
+      } catch (cause) {
+        if (isCurrent()) {
+          const failure = cause instanceof Error ? cause : new Error(String(cause));
+          state.error = failure;
+          state.loading = this.hasSettledLayers(state);
+          this.notifySubscription(state, false, failure);
+        }
+        throw cause;
+      } finally {
+        if ((!state.active || !isCurrent()) && requestIssued) {
+          void this.sendUnsubscribe(
+            registrationConnectionId,
+            state.id,
+            generation,
+            registrationId
+          );
+        }
+        if (state.registrationPromise === request) {
+          state.registrationPromise = void 0;
+        }
+      }
+    })();
+    state.registrationPromise = request;
+    return request;
+  }
+  releaseSubscription(state, leaseId) {
+    state.observers.delete(leaseId);
+    if (state.observers.size > 0) return;
+    state.active = false;
+    this.subscriptionsById.delete(state.id);
+    this.subscriptionsByKey.delete(state.key);
+    if (state.registrationId && state.registrationConnectionId && state.hasRegistered) {
+      void this.sendUnsubscribe(
+        state.registrationConnectionId,
+        state.id,
+        state.generation,
+        state.registrationId
+      );
+    }
+  }
+  async sendUnsubscribe(connectionId, subscriptionId, generation, registrationId) {
+    if (!connectionId) return;
+    try {
+      const headers = await this.buildHeaders();
+      await fetch(this.httpUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          type: "unsubscribe",
+          connectionId,
+          subscriptionId,
+          generation,
+          registrationId
+        })
+      });
+    } catch {
+    }
+  }
+  async refetch(state) {
+    if (!state.active) return;
+    if (!state.registrationId) {
+      await this.ensureRegistered(state, this.wsManager.generation);
+      return;
+    }
+    await this.requestResync(state);
+  }
+  handleMessage(message) {
+    switch (message.type) {
+      case "patch":
+        this.handlePatch(message);
+        break;
+      case "resync": {
+        const state = this.subscriptionsById.get(message.subscriptionId);
+        if (state?.generation === message.generation) {
+          void this.requestResync(state).catch(() => void 0);
+        }
+        break;
+      }
+    }
+  }
+  handleSnapshot(message) {
+    const state = this.subscriptionsById.get(message.subscriptionId);
+    if (!state || message.generation !== state.generation) return;
+    if (state.version !== void 0 && message.version <= state.version) return;
+    state.authoritativeData = message.data;
+    state.version = message.version;
+    state.error = void 0;
+    const coveredRevision = state.registrationSettlementRevision;
+    for (const [layerId, layer] of state.optimisticLayers) {
+      if (layer.settledRevision !== void 0 && layer.settledRevision <= coveredRevision) {
+        state.optimisticLayers.delete(layerId);
+      }
+    }
+    const awaitingReconciliation = this.hasSettledLayers(state);
+    state.loading = awaitingReconciliation;
+    state.stale = awaitingReconciliation;
+    this.recomputeData(state);
+    this.discardStalePatches(state);
+    this.notifySubscription(state, true);
+    this.drainPatchBuffer(state);
+  }
+  handlePatch(message) {
+    const state = this.subscriptionsById.get(message.subscriptionId);
+    if (!state || message.generation !== state.generation) return;
+    if (state.appliedMessageIds.has(message.messageId) || state.patchBuffer.has(message.messageId)) {
+      return;
+    }
+    if (state.version !== void 0 && message.toVersion <= state.version) {
+      state.appliedMessageIds.add(message.messageId);
+      return;
+    }
+    state.patchBuffer.set(message.messageId, message);
+    if (state.version === void 0) return;
+    this.drainPatchBuffer(state);
+  }
+  drainPatchBuffer(state) {
+    if (state.version === void 0 || state.authoritativeData === void 0) {
+      return;
+    }
+    this.discardStalePatches(state);
+    while (true) {
+      const next = [...state.patchBuffer.values()].filter((patch) => patch.fromVersion === state.version).sort((left, right) => left.toVersion - right.toVersion)[0];
+      if (!next) break;
+      state.patchBuffer.delete(next.messageId);
+      try {
+        state.authoritativeData = applyPatches(
+          state.authoritativeData,
+          next.patches
+        );
+        state.version = next.toVersion;
+        state.appliedMessageIds.add(next.messageId);
+        const awaitingReconciliation = this.hasSettledLayers(state);
+        state.loading = awaitingReconciliation;
+        state.stale = awaitingReconciliation;
+        state.error = void 0;
+        this.recomputeData(state);
+        this.notifySubscription(state, true);
+        this.discardStalePatches(state);
+      } catch {
+        void this.requestResync(state).catch(() => void 0);
+        return;
+      }
+    }
+    if ([...state.patchBuffer.values()].some(
+      (patch) => patch.toVersion > state.version && patch.fromVersion !== state.version
+    )) {
+      void this.requestResync(state).catch(() => void 0);
+    }
+  }
+  discardStalePatches(state) {
+    if (state.version === void 0) return;
+    for (const [messageId, patch] of state.patchBuffer) {
+      if (patch.toVersion <= state.version) {
+        state.patchBuffer.delete(messageId);
+        state.appliedMessageIds.add(messageId);
+      }
+    }
+  }
+  requestResync(state) {
+    if (state.resyncPromise && state.resyncGeneration === state.generation) {
+      return state.resyncPromise;
+    }
+    if (!state.active || !state.registrationId) return Promise.resolve();
+    state.stale = true;
+    state.loading = true;
+    this.notifySubscription(state);
+    let request;
+    request = this.ensureRegistered(
+      state,
+      this.wsManager.generation,
+      true
+    ).finally(() => {
+      if (state.resyncPromise === request) {
+        state.resyncPromise = void 0;
+        state.resyncGeneration = void 0;
+      }
+    }).then(() => {
+      if (state.active && this.hasSettledLayers(state)) {
+        return this.requestResync(state);
+      }
+      return void 0;
+    });
+    state.resyncPromise = request;
+    state.resyncGeneration = state.generation;
+    return request;
+  }
+  createMutationLayers(mutationId, input, options, layered) {
+    const targets = this.findMutationTargets(options);
+    for (const state of targets) {
+      const updater = this.createOptimisticUpdater(input, options);
+      if (!updater || state.authoritativeData === void 0) continue;
+      state.optimisticLayers.set(mutationId, {
+        updater
+      });
+      layered.push(state);
+      this.recomputeData(state);
+      this.notifySubscription(state, true);
+    }
+  }
+  findMutationTargets(options) {
+    if (options?.queryKey) {
+      const exact = this.subscriptionsByKey.get(options.queryKey);
+      return exact ? [exact] : [];
+    }
+    if (typeof options?.invalidates === "object") {
+      const exact = this.subscriptionsByKey.get(
+        getQueryKey(options.invalidates.path, options.invalidates.input)
+      );
+      return exact ? [exact] : [];
+    }
+    if (typeof options?.invalidates === "string") {
+      return [...this.subscriptionsByKey.values()].filter(
+        (state) => state.path === options.invalidates
+      );
+    }
+    return [];
+  }
+  createOptimisticUpdater(input, options, result, settled = false) {
+    const update = options?.optimisticUpdate;
+    if (typeof update === "function") {
+      return (data) => Array.isArray(data) ? update(data, input, result) : data;
+    }
+    const itemId = typeof input === "object" && input !== null ? input.id : void 0;
+    if (update === "remove" && itemId !== void 0) {
+      return (data) => Array.isArray(data) ? data.filter((item) => item.id !== itemId) : data;
+    }
+    if (update !== "merge") return void 0;
+    if (itemId !== void 0) {
+      const resultFields = settled && typeof result === "object" && result !== null ? result : {};
+      return (data) => {
+        if (!Array.isArray(data)) return data;
+        return data.map(
+          (item) => item.id === itemId ? { ...item, ...input, ...resultFields } : item
+        );
+      };
+    }
+    if (options?.optimisticData === void 0) return void 0;
+    return (data) => {
+      if (!Array.isArray(data)) return data;
+      const optimistic = settled ? result === void 0 ? typeof options.optimisticData === "function" ? options.optimisticData(input, data) : options.optimisticData : result : typeof options.optimisticData === "function" ? options.optimisticData(input, data) : options.optimisticData;
+      if (settled && optimistic !== null && typeof optimistic === "object") {
+        const optimisticId = optimistic.id;
+        if (optimisticId !== void 0 && data.some(
+          (item) => typeof item === "object" && item !== null && item.id === optimisticId
+        )) {
+          return data;
+        }
+      }
+      return optimistic === void 0 ? data : [optimistic, ...data];
+    };
+  }
+  settleMutationLayers(mutationId, input, result, options, states) {
+    for (const state of states) {
+      const layer = state.optimisticLayers.get(mutationId);
+      const updater = this.createOptimisticUpdater(
+        input,
+        options,
+        result,
+        true
+      );
+      if (!layer || !updater) continue;
+      layer.updater = updater;
+      layer.settledRevision = ++state.settlementRevision;
+      state.loading = true;
+      state.stale = true;
+      this.recomputeData(state);
+      this.notifySubscription(state, true);
+      void this.requestResync(state).catch(() => void 0);
+    }
+  }
+  removeMutationLayers(mutationId, states) {
+    for (const state of states) {
+      if (!state.optimisticLayers.delete(mutationId)) continue;
+      this.recomputeData(state);
+      this.notifySubscription(state, true);
+    }
+  }
+  recomputeData(state) {
+    let data = state.authoritativeData;
+    for (const layer of state.optimisticLayers.values()) {
+      data = layer.updater(data);
+    }
+    state.data = data;
+  }
+  hasSettledLayers(state) {
+    for (const layer of state.optimisticLayers.values()) {
+      if (layer.settledRevision !== void 0) return true;
+    }
+    return false;
+  }
+  async buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.headersGetter) Object.assign(headers, await this.headersGetter());
+    if (this.authGetter) {
+      headers["Authorization"] = `Bearer ${await this.authGetter()}`;
+    }
+    return headers;
+  }
+  markSubscriptionsStale() {
+    for (const state of this.subscriptionsByKey.values()) {
+      if (!state.active) continue;
+      state.stale = true;
+      state.loading = true;
+      this.notifySubscription(state);
+    }
+  }
+  notifySubscription(state, dataChanged = false, failure) {
+    if (!state.active) return;
+    state.revision++;
+    for (const listener of state.listeners) listener();
+    if (dataChanged) {
+      for (const observer of state.observers.values()) {
+        observer.onData?.(state.data);
+      }
+    }
+    if (failure) {
+      for (const observer of state.observers.values()) {
+        observer.onError?.(failure);
+      }
+    }
+  }
+  notifyStateListeners() {
+    for (const listener of this.stateListeners) {
+      listener(this.connectionState);
+    }
+  }
+};
+var ReactiveClientContext = react.createContext(null);
+function createManagedClient(externalClient, config) {
+  if (externalClient) return { client: externalClient, owned: false };
+  if (!config?.url) return null;
+  return {
+    client: new ReactiveClient(config),
+    owned: true,
+    scope: getClientScope(config)
+  };
+}
+function sameRecord(left, right) {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  const keys = Object.keys(left);
+  return keys.length === Object.keys(right).length && keys.every((key) => left[key] === right[key]);
+}
+function getClientScope(config) {
+  return {
+    url: config.url,
+    httpUrl: config.httpUrl ?? "/api/reactive",
+    auth: typeof config.auth === "string" ? config.auth : void 0,
+    dynamicAuth: typeof config.auth === "function",
+    headers: typeof config.headers === "object" ? { ...config.headers } : void 0,
+    dynamicHeaders: typeof config.headers === "function"
+  };
+}
+function sameScope(left, right) {
+  if (!left) return false;
+  return left.url === right.url && left.httpUrl === right.httpUrl && left.auth === right.auth && left.dynamicAuth === right.dynamicAuth && left.dynamicHeaders === right.dynamicHeaders && sameRecord(left.headers, right.headers);
+}
+function ReactiveClientProvider({
+  children,
+  config,
+  client: externalClient
+}) {
+  const [managed, setManaged] = react.useState(
+    () => createManagedClient(externalClient, config)
+  );
+  let renderedManaged = managed;
+  if (externalClient) {
+    if (managed?.owned || managed?.client !== externalClient) {
+      renderedManaged = { client: externalClient, owned: false };
+    }
+  } else if (!config?.url) {
+    renderedManaged = null;
+  } else {
+    const scope = getClientScope(config);
+    if (!managed?.owned || !sameScope(managed.scope, scope)) {
+      renderedManaged = {
+        client: new ReactiveClient(config),
+        owned: true,
+        scope
+      };
+    }
+  }
+  if (renderedManaged !== managed) setManaged(renderedManaged);
+  react.useEffect(() => {
+    if (renderedManaged?.owned && config) {
+      renderedManaged.client.configure(config);
+    }
+  }, [config, renderedManaged]);
+  react.useEffect(() => {
+    if (!renderedManaged?.owned) return;
+    void renderedManaged.client.connect().catch(() => void 0);
+    return () => {
+      renderedManaged.client.disconnect();
+    };
+  }, [renderedManaged]);
+  react.useEffect(() => {
+    if (typeof window === "undefined" || typeof document === "undefined" || !renderedManaged?.owned) {
+      return;
+    }
+    const attemptReconnect = () => {
+      const state = renderedManaged.client.getConnectionState();
+      if (state === "connected" || state === "connecting") return;
+      if (state === "reconnecting") {
+        debug(
+          "[dynamodb-reactive] Tab active during reconnect; reconnecting now"
+        );
+        renderedManaged.client.forceReconnect();
+      } else {
+        void renderedManaged.client.connect().catch(() => void 0);
+      }
+    };
+    const handleVisibility = () => {
+      if (document.visibilityState === "visible") attemptReconnect();
+    };
+    document.addEventListener("visibilitychange", handleVisibility);
+    window.addEventListener("focus", attemptReconnect);
+    return () => {
+      document.removeEventListener("visibilitychange", handleVisibility);
+      window.removeEventListener("focus", attemptReconnect);
+    };
+  }, [renderedManaged]);
+  react.useEffect(() => {
+    if (!config?.url && !externalClient) {
+      warn(
+        "[dynamodb-reactive] WebSocket URL not configured; real-time features disabled"
+      );
+    }
+  }, [config?.url, externalClient]);
+  return /* @__PURE__ */ jsxRuntime.jsx(ReactiveClientContext.Provider, { value: renderedManaged?.client ?? null, children });
+}
+function useReactiveClient() {
+  return react.useContext(ReactiveClientContext);
+}
+function useConnectionState() {
+  const client = useReactiveClient();
+  return react.useSyncExternalStore(
+    (listener) => client ? client.onConnectionStateChange(listener) : () => void 0,
+    () => client ? client.getConnectionState() : "disabled",
+    () => "disabled"
+  );
+}
+function useSubscription(path, options = {}) {
+  const client = useReactiveClient();
+  const queryKey = getQueryKey(path, options.input);
+  const [active, setActive] = react.useState(null);
+  const onDataRef = react.useRef(options.onData);
+  const onErrorRef = react.useRef(options.onError);
+  onDataRef.current = options.onData;
+  onErrorRef.current = options.onError;
+  react.useEffect(() => {
+    if (!client) {
+      setActive(null);
+      return;
+    }
+    const next = client.subscribe(path, {
+      input: options.input,
+      onData: (data) => onDataRef.current?.(data),
+      onError: (failure) => onErrorRef.current?.(failure)
+    });
+    setActive({ client, subscription: next });
+    return () => next.unsubscribe();
+  }, [client, path, queryKey]);
+  const subscription = active?.client === client && active.subscription.key === queryKey ? active.subscription : null;
+  react.useSyncExternalStore(
+    (listener) => client && subscription ? client.addSubscriptionListener(subscription.id, listener) : () => void 0,
+    () => client && subscription ? client.getSubscriptionRevision(subscription.id) : -1,
+    () => -1
+  );
+  const refetch = async () => {
+    await subscription?.refetch();
+  };
+  const setData = (updater) => {
+    if (client && subscription) {
+      client.applyOptimisticUpdate(
+        subscription.id,
+        updater
+      );
+    }
+  };
+  return {
+    data: subscription?.data,
+    loading: client ? subscription?.loading ?? true : false,
+    stale: client ? subscription?.stale ?? true : false,
+    error: subscription?.error,
+    disabled: !client,
+    refetch,
+    setData
+  };
+}
+function useMutation(path, options) {
+  const client = useReactiveClient();
+  const [state, setState] = react.useState({ data: void 0, loading: false, error: void 0 });
+  const pendingCountRef = react.useRef(0);
+  const latestCallRef = react.useRef(0);
+  const mutate = async (input) => {
+    if (!client) {
+      throw new Error("WebSocket not configured; mutations are disabled");
+    }
+    const callId = ++latestCallRef.current;
+    pendingCountRef.current++;
+    setState((current) => ({ ...current, loading: true, error: void 0 }));
+    try {
+      const result = await client.call(path, input, options);
+      pendingCountRef.current--;
+      setState(
+        (current) => callId === latestCallRef.current ? {
+          data: result,
+          loading: pendingCountRef.current > 0,
+          error: void 0
+        } : { ...current, loading: pendingCountRef.current > 0 }
+      );
+      return result;
+    } catch (cause) {
+      const failure = cause instanceof Error ? cause : new Error(String(cause));
+      pendingCountRef.current--;
+      setState(
+        (current) => callId === latestCallRef.current ? {
+          ...current,
+          loading: pendingCountRef.current > 0,
+          error: failure
+        } : { ...current, loading: pendingCountRef.current > 0 }
+      );
+      throw failure;
+    }
+  };
+  const reset = () => {
+    latestCallRef.current++;
+    setState({
+      data: void 0,
+      loading: pendingCountRef.current > 0,
+      error: void 0
+    });
+  };
+  return { mutate, ...state, disabled: !client, reset };
+}
+function useClient() {
+  function buildProxy(path) {
+    return new Proxy(
+      {},
+      {
+        get(_target, property) {
+          if (typeof property !== "string") return void 0;
+          if (property === "useQuery") {
+            return function useQueryHook(input, queryOptions) {
+              return useSubscription(path.join("."), {
+                ...queryOptions,
+                input
+              });
+            };
+          }
+          if (property === "useMutation") {
+            return function useMutationHook(mutationOptions) {
+              return useMutation(path.join("."), mutationOptions);
+            };
+          }
+          return buildProxy([...path, property]);
+        }
+      }
+    );
+  }
+  return buildProxy([]);
+}
+
+exports.ReactiveClientProvider = ReactiveClientProvider;
+exports.useClient = useClient;
+exports.useConnectionState = useConnectionState;
+exports.useMutation = useMutation;
+exports.useReactiveClient = useReactiveClient;
+exports.useSubscription = useSubscription;
+//# sourceMappingURL=react.cjs.map
+//# sourceMappingURL=react.cjs.map