dynamodb-reactive 0.2.3 → 0.3.0

package/dist/cluster.cjs

@@ -0,0 +1,1166 @@
+'use strict';
+
+var jsonpatch = require('fast-json-patch');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var jsonpatch__default = /*#__PURE__*/_interopDefault(jsonpatch);
+
+// ../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(document, patches) {
+  if (patches.length === 0) {
+    return document;
+  }
+  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(document),
+      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 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;
+  lastConnectionError;
+  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`, {
+            cause: this.lastConnectionError
+          })
+        ),
+        timeoutMs
+      );
+    });
+  }
+  getState() {
+    return this.state;
+  }
+  async connect() {
+    if (this.state === "connected") return;
+    if (this.state === "connecting") {
+      await this.waitForConnectionId();
+      return;
+    }
+    if (this.state !== "reconnecting") this.lastConnectionError = void 0;
+    this.intentionalDisconnect = false;
+    const generation = ++this.socketGeneration;
+    this.setState("connecting");
+    let socket;
+    let retryable = true;
+    try {
+      if (!this.config.webSocketFactory && typeof globalThis.WebSocket !== "function") {
+        retryable = false;
+        throw new Error(
+          "WebSocket is unavailable in this runtime. Enable the native WebSocket API (Node 20: --experimental-websocket), use Node 22 or newer, or configure webSocketFactory."
+        );
+      }
+      const url = await this.buildUrl();
+      if (generation !== this.socketGeneration || this.intentionalDisconnect) {
+        return;
+      }
+      let nextSocket;
+      try {
+        nextSocket = this.config.webSocketFactory ? this.config.webSocketFactory(url) : new globalThis.WebSocket(url);
+      } catch (cause) {
+        retryable = false;
+        throw cause;
+      }
+      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;
+        const failure = new Error("WebSocket error");
+        this.lastConnectionError = failure;
+        this.invokeLifecycleCallback("onError", this.config.onError, failure);
+      };
+      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.lastConnectionError = failure;
+      this.clearConnectionTimers();
+      if (!retryable) {
+        this.clearTimers();
+        this.reconnectAttempts = 0;
+      }
+      if (socket && this.ws === socket) socket.close();
+      this.ws = null;
+      this._connectionId = null;
+      this.setState("disconnected");
+      this.invokeLifecycleCallback("onError", this.config.onError, failure);
+      if (retryable && 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.lastConnectionError = void 0;
+        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.lastConnectionError = failure;
+      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 !== socket.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", {
+        cause: this.lastConnectionError
+      });
+      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);
+    }
+  }
+};
+
+// ../client/src/cluster.ts
+var DEFAULT_CLUSTER_TICKET_PATH = "/api/cluster/token";
+var DEFAULT_CLUSTER_HTTP_PATH = "/api/reactive";
+var DEFAULT_RETRY_DELAY_MS = 1e4;
+var DEFAULT_REQUEST_TIMEOUT_MS = 1e4;
+var DEFAULT_TICKET_LIFETIME_SECONDS = 60;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseClusterTicket(value) {
+  if (!isRecord(value) || typeof value.token !== "string" || value.token.length === 0 || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt) || typeof value.url !== "string") {
+    throw new Error("Cluster ticket response is invalid");
+  }
+  const url = new URL(value.url);
+  if (url.protocol !== "wss:") throw new Error("Cluster ticket URL must use WSS");
+  return { token: value.token, expiresAt: value.expiresAt, url: url.toString() };
+}
+function toError(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+function abortError(signal) {
+  return toError(signal.reason ?? new Error("Cluster worker connection aborted"));
+}
+function wait(milliseconds, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError(signal));
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError(signal));
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, milliseconds);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+async function fetchClusterTicket(config) {
+  const runnerToken = typeof config.runnerToken === "function" ? await config.runnerToken() : config.runnerToken;
+  const endpoint = new URL(
+    config.ticketPath ?? DEFAULT_CLUSTER_TICKET_PATH,
+    config.baseUrl
+  );
+  const response = await (config.fetch ?? fetch)(endpoint, {
+    method: "POST",
+    headers: { authorization: `Bearer ${runnerToken}` },
+    signal: AbortSignal.timeout(config.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`Cluster ticket request failed: HTTP ${response.status}`);
+  }
+  return parseClusterTicket(await response.json());
+}
+async function connectClusterWorker(config) {
+  const retryDelay = config.retryDelay ?? DEFAULT_RETRY_DELAY_MS;
+  const httpUrl = new URL(
+    config.httpPath ?? DEFAULT_CLUSTER_HTTP_PATH,
+    config.baseUrl
+  ).toString();
+  for (; ; ) {
+    if (config.signal?.aborted) throw abortError(config.signal);
+    let client;
+    try {
+      const ticket = await fetchClusterTicket(config);
+      client = new ReactiveClient({
+        reconnectDelay: retryDelay,
+        maxReconnectAttempts: Number.MAX_SAFE_INTEGER,
+        ...config.client,
+        url: ticket.url,
+        httpUrl,
+        auth: async () => (await fetchClusterTicket(config)).token
+      });
+      await client.connect();
+      return client;
+    } catch (cause) {
+      client?.disconnect();
+      if (config.signal?.aborted) throw abortError(config.signal);
+      config.onRetry?.(toError(cause));
+      await wait(retryDelay, config.signal);
+    }
+  }
+}
+var encoder = new TextEncoder();
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+}
+function base64UrlDecode(value) {
+  const padded = value.replaceAll("-", "+").replaceAll("_", "/");
+  const binary = atob(padded + "=".repeat((4 - padded.length % 4) % 4));
+  const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function hmacKey(secret, usage) {
+  return crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    [usage]
+  );
+}
+async function createSignedClusterTicket(options) {
+  const expiresAt = Math.floor((options.now ?? Date.now()) / 1e3) + (options.lifetimeSeconds ?? DEFAULT_TICKET_LIFETIME_SECONDS);
+  const payload = base64UrlEncode(
+    encoder.encode(JSON.stringify({ p: options.principal, exp: expiresAt }))
+  );
+  const signature = new Uint8Array(
+    await crypto.subtle.sign("HMAC", await hmacKey(options.secret, "sign"), encoder.encode(payload))
+  );
+  return parseClusterTicket({
+    token: `${payload}.${base64UrlEncode(signature)}`,
+    expiresAt,
+    url: options.url
+  });
+}
+async function verifySignedClusterTicket(token, secret, now = Date.now()) {
+  const [payload, signature, extra] = token.split(".");
+  if (!payload || !signature || extra !== void 0) return void 0;
+  try {
+    const valid = await crypto.subtle.verify(
+      "HMAC",
+      await hmacKey(secret, "verify"),
+      base64UrlDecode(signature),
+      encoder.encode(payload)
+    );
+    if (!valid) return void 0;
+    const claims = JSON.parse(new TextDecoder().decode(base64UrlDecode(payload)));
+    if (!isRecord(claims) || typeof claims.p !== "string" || typeof claims.exp !== "number" || claims.exp <= Math.floor(now / 1e3)) {
+      return void 0;
+    }
+    return claims.p;
+  } catch {
+    return void 0;
+  }
+}
+
+exports.DEFAULT_CLUSTER_HTTP_PATH = DEFAULT_CLUSTER_HTTP_PATH;
+exports.DEFAULT_CLUSTER_TICKET_PATH = DEFAULT_CLUSTER_TICKET_PATH;
+exports.connectClusterWorker = connectClusterWorker;
+exports.createSignedClusterTicket = createSignedClusterTicket;
+exports.fetchClusterTicket = fetchClusterTicket;
+exports.parseClusterTicket = parseClusterTicket;
+exports.verifySignedClusterTicket = verifySignedClusterTicket;
+//# sourceMappingURL=cluster.cjs.map
+//# sourceMappingURL=cluster.cjs.map