@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/client/index.mjs

@@ -32,8 +32,8 @@ var RemoteDatabase = class {
    * )
    * ```
    */
-  async query(sql, params) {
-    const response = await this.transport.query(sql, params);
+  async query(sql, params, options) {
+    const response = await this.transport.query(sql, params, options?.readConcern);
     return response.rows;
   }
   /**
@@ -104,8 +104,8 @@ var HttpTransport = class {
       ...headers
     };
   }
-  async query(sql, params) {
-    return this.post("/query", { sql, params });
+  async query(sql, params, readConcern) {
+    return this.post("/query", { sql, params, readConcern });
   }
   async execute(sql, params) {
     return this.post("/execute", { sql, params });
@@ -165,6 +165,7 @@ var WebSocketTransport = class {
   autoReconnect;
   reconnectInterval;
   requestTimeout;
+  protocols;
   pendingRequests = /* @__PURE__ */ new Map();
   activeSubscriptions = /* @__PURE__ */ new Map();
   idCounter = 0;
@@ -176,6 +177,7 @@ var WebSocketTransport = class {
     this.autoReconnect = options?.autoReconnect ?? true;
     this.reconnectInterval = options?.reconnectInterval ?? 1e3;
     this.requestTimeout = options?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this.protocols = options?.protocols;
   }
   async query(sql, params) {
     await this.ensureConnected();
@@ -249,7 +251,7 @@ var WebSocketTransport = class {
   connect() {
     return new Promise((resolve, reject) => {
       let settled = false;
-      const ws = new WebSocket(this.url);
+      const ws = this.protocols === void 0 ? new WebSocket(this.url) : new WebSocket(this.url, this.protocols);
       const onOpen = () => {
         settled = true;
         this.ws = ws;
@@ -413,30 +415,192 @@ var WebSocketTransport = class {
 };
 
 // src/client/client.ts
+var CLUSTER_DISCOVERY_FETCH_TIMEOUT_MS = 2e3;
+function clusterRoutingFingerprint(state) {
+  const readEndpoints = state.readEndpoints.map((endpoint) => ({
+    url: endpoint.url,
+    readConcerns: [...endpoint.readConcerns].sort()
+  })).sort((left, right) => left.url.localeCompare(right.url));
+  return JSON.stringify({
+    currentPrimary: state.currentPrimary,
+    primaryTerm: state.primaryTerm,
+    readEndpoints
+  });
+}
+function clusterRoutingChanged(previous, next) {
+  return previous === void 0 || clusterRoutingFingerprint(previous) !== clusterRoutingFingerprint(next);
+}
+function isTopologyConfig(urlOrOpts) {
+  if (typeof urlOrOpts !== "object") {
+    return false;
+  }
+  return "primary" in urlOrOpts || "replicas" in urlOrOpts && Array.isArray(urlOrOpts.replicas) && urlOrOpts.replicas.length > 0 || "endpoints" in urlOrOpts && Array.isArray(urlOrOpts.endpoints) && urlOrOpts.endpoints.length > 0 || urlOrOpts.discovery === "coordinator";
+}
+function toBaseUrl(url) {
+  return normaliseEndpointUrl(url);
+}
+function toServerBaseUrl(url, databaseId) {
+  const base = toBaseUrl(url);
+  if (!databaseId) return base.replace(/\/db\/[^/]+$/i, "");
+  return base.replace(new RegExp(`/db/${escapeRegExp(encodeURIComponent(databaseId))}$`, "i"), "");
+}
+function toWsUrl(baseUrl) {
+  return baseUrl.replace(/^http:\/\//i, "ws://").replace(/^https:\/\//i, "wss://");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normaliseEndpointUrl(rawUrl) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    throw new TypeError(`Endpoint URL '${rawUrl}' is invalid`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new TypeError(`Endpoint URL '${rawUrl}' must use http or https`);
+  }
+  if (parsed.username || parsed.password) {
+    throw new TypeError(`Endpoint URL '${rawUrl}' must not contain credentials`);
+  }
+  if (parsed.hash) {
+    throw new TypeError(`Endpoint URL '${rawUrl}' must not contain a fragment`);
+  }
+  if (parsed.search) {
+    throw new TypeError(`Endpoint URL '${rawUrl}' must not contain a query string`);
+  }
+  parsed.pathname = parsed.pathname.replace(/\/+$/, "");
+  return parsed.toString().replace(/\/$/, "");
+}
+function isReadConcernLevel(value) {
+  return value === "local" || value === "majority" || value === "linearizable";
+}
+function parseDiscoveredReadConcerns(value) {
+  if (!Array.isArray(value)) {
+    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata readConcerns must be an array");
+  }
+  const concerns = [];
+  for (const concern of value) {
+    if (!isReadConcernLevel(concern)) {
+      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata contains an invalid read concern");
+    }
+    if (!concerns.includes(concern)) {
+      concerns.push(concern);
+    }
+  }
+  return concerns;
+}
+function toDiscoveredServerBaseUrl(endpoint, databaseId) {
+  try {
+    return toServerBaseUrl(endpoint, databaseId);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new RemoteError("INVALID_RESPONSE", `Cluster metadata contains an unsafe endpoint: ${message}`);
+  }
+}
+function parseClusterRouting(data, databaseId) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata must be an object");
+  }
+  const record = data;
+  if (record.databaseId !== databaseId) {
+    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata database id does not match the request");
+  }
+  if (record.primaryTerm !== void 0 && typeof record.primaryTerm !== "string") {
+    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata primaryTerm must be a string");
+  }
+  let currentPrimary = null;
+  if (record.currentPrimary !== void 0 && record.currentPrimary !== null) {
+    if (typeof record.currentPrimary !== "object" || Array.isArray(record.currentPrimary)) {
+      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata currentPrimary must be an object or null");
+    }
+    const primary = record.currentPrimary;
+    if (typeof primary.endpoint !== "string") {
+      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata currentPrimary.endpoint must be a string");
+    }
+    currentPrimary = toDiscoveredServerBaseUrl(primary.endpoint, databaseId);
+  }
+  const readEndpointsRaw = record.readEndpoints;
+  if (readEndpointsRaw !== void 0 && !Array.isArray(readEndpointsRaw)) {
+    throw new RemoteError("INVALID_RESPONSE", "Cluster metadata readEndpoints must be an array");
+  }
+  const readEndpoints = (readEndpointsRaw ?? []).map((endpointInfo) => {
+    if (typeof endpointInfo !== "object" || endpointInfo === null || Array.isArray(endpointInfo)) {
+      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata read endpoint must be an object");
+    }
+    const endpoint = endpointInfo;
+    if (typeof endpoint.endpoint !== "string") {
+      throw new RemoteError("INVALID_RESPONSE", "Cluster metadata read endpoint URL must be a string");
+    }
+    return {
+      url: toDiscoveredServerBaseUrl(endpoint.endpoint, databaseId),
+      readConcerns: parseDiscoveredReadConcerns(endpoint.readConcerns)
+    };
+  });
+  return {
+    currentPrimary,
+    primaryTerm: record.primaryTerm ?? null,
+    readEndpoints
+  };
+}
 var SirannonClient = class {
   baseUrl;
   wsBaseUrl;
   transport;
   headers;
+  webSocketProtocols;
   autoReconnect;
   reconnectInterval;
   databases = /* @__PURE__ */ new Map();
   closed = false;
-  constructor(url, options) {
-    this.baseUrl = url.replace(/\/$/, "");
-    this.wsBaseUrl = this.baseUrl.replace(/^http:\/\//i, "ws://").replace(/^https:\/\//i, "wss://");
-    this.transport = options?.transport ?? "websocket";
-    this.headers = options?.headers;
-    this.autoReconnect = options?.autoReconnect ?? true;
-    this.reconnectInterval = options?.reconnectInterval ?? 1e3;
+  topologyEnabled;
+  primaryUrl;
+  replicaUrls;
+  readPreference;
+  discovery;
+  readConcern;
+  starterEndpoints;
+  clusterRouting = /* @__PURE__ */ new Map();
+  topologyTransports = /* @__PURE__ */ new Map();
+  latencies = [];
+  latencyMeasuredAt = 0;
+  latencyMeasuring = null;
+  LATENCY_TTL_MS = 6e4;
+  removedReplicas = /* @__PURE__ */ new Set();
+  constructor(urlOrOpts, options) {
+    if (isTopologyConfig(urlOrOpts)) {
+      const topoOpts = urlOrOpts;
+      this.topologyEnabled = true;
+      this.primaryUrl = topoOpts.primary ? toBaseUrl(topoOpts.primary) : void 0;
+      this.replicaUrls = (topoOpts.replicas ?? []).map(toBaseUrl);
+      this.readPreference = topoOpts.readPreference ?? "primary";
+      this.discovery = topoOpts.discovery ?? "static";
+      this.readConcern = topoOpts.readConcern;
+      this.starterEndpoints = (topoOpts.endpoints ?? []).map(toBaseUrl);
+      this.baseUrl = this.primaryUrl ?? this.replicaUrls[0] ?? this.starterEndpoints[0] ?? "";
+      this.wsBaseUrl = toWsUrl(this.baseUrl);
+      this.transport = topoOpts.transport ?? "websocket";
+      this.headers = topoOpts.headers;
+      this.webSocketProtocols = topoOpts.webSocketProtocols;
+      this.autoReconnect = topoOpts.autoReconnect ?? true;
+      this.reconnectInterval = topoOpts.reconnectInterval ?? 1e3;
+    } else {
+      this.topologyEnabled = false;
+      this.primaryUrl = void 0;
+      this.replicaUrls = [];
+      this.readPreference = "primary";
+      this.discovery = "static";
+      this.readConcern = void 0;
+      this.starterEndpoints = [];
+      this.baseUrl = toBaseUrl(urlOrOpts);
+      this.wsBaseUrl = toWsUrl(this.baseUrl);
+      this.transport = options?.transport ?? "websocket";
+      this.headers = options?.headers;
+      this.webSocketProtocols = options?.webSocketProtocols;
+      this.autoReconnect = options?.autoReconnect ?? true;
+      this.reconnectInterval = options?.reconnectInterval ?? 1e3;
+    }
   }
-  /**
-   * Get a {@link RemoteDatabase} proxy for the given database ID.
-   * Returns a cached instance if one already exists for this ID.
-   *
-   * The underlying transport connection is established lazily on
-   * the first operation (query, execute, or subscribe).
-   */
   database(id) {
     if (this.closed) {
       throw new Error("Client is closed");
@@ -452,10 +616,6 @@ var SirannonClient = class {
     this.databases.set(id, db);
     return db;
   }
-  /**
-   * Close all database connections and release resources.
-   * After calling `close()`, new calls to `database()` will throw.
-   */
   close() {
     this.closed = true;
     const openDatabases = [...this.databases.values()];
@@ -465,15 +625,555 @@ var SirannonClient = class {
     }
   }
   createTransport(databaseId) {
+    if (!this.topologyEnabled) {
+      return this.createTransportForUrl(this.baseUrl, this.wsBaseUrl, databaseId);
+    }
+    const transport = new TopologyAwareTransport(databaseId, this);
+    this.topologyTransports.set(databaseId, transport);
+    return transport;
+  }
+  createTransportForUrl(baseUrl, wsBaseUrl, databaseId) {
     const encodedId = encodeURIComponent(databaseId);
     if (this.transport === "http") {
-      return new HttpTransport(`${this.baseUrl}/db/${encodedId}`, this.headers);
+      return new HttpTransport(`${baseUrl}/db/${encodedId}`, this.headers);
     }
-    return new WebSocketTransport(`${this.wsBaseUrl}/db/${encodedId}`, {
+    return new WebSocketTransport(`${wsBaseUrl}/db/${encodedId}`, {
       autoReconnect: this.autoReconnect,
-      reconnectInterval: this.reconnectInterval
+      reconnectInterval: this.reconnectInterval,
+      protocols: this.webSocketProtocols
+    });
+  }
+  _createTransportForEndpoint(url, databaseId) {
+    const base = toBaseUrl(url);
+    const ws = toWsUrl(base);
+    return this.createTransportForUrl(base, ws, databaseId);
+  }
+  async _getReadEndpoint(databaseId, readConcern) {
+    if (this.discovery === "coordinator" && databaseId) {
+      const routing = await this.ensureClusterRouting(databaseId);
+      const concern = readConcern ?? this.readConcern ?? "majority";
+      if (concern === "linearizable") {
+        if (routing.currentPrimary) return routing.currentPrimary;
+        throw new RemoteError("NO_SAFE_PRIMARY", "No current primary is available for linearizable reads");
+      }
+      const readable = routing.readEndpoints.filter((endpoint) => endpoint.readConcerns.includes(concern));
+      const preferredReadable = this.readPreference === "replica" && routing.currentPrimary ? readable.filter((endpoint) => endpoint.url !== routing.currentPrimary) : readable;
+      if (this.readPreference !== "primary" && preferredReadable.length > 0) {
+        if (this.readPreference === "nearest") {
+          return preferredReadable[0].url;
+        }
+        const idx = Math.floor(Math.random() * preferredReadable.length);
+        return preferredReadable[idx].url;
+      }
+      if (routing.currentPrimary) return routing.currentPrimary;
+      const localReadable = routing.readEndpoints.find((endpoint) => endpoint.readConcerns.includes("local"));
+      if (localReadable) return localReadable.url;
+      throw new RemoteError("ROUTING_ERROR", "No usable read endpoint is available");
+    }
+    if (this.readPreference === "primary") {
+      return this.primaryUrl ?? this.baseUrl;
+    }
+    const availableReplicas = this.replicaUrls.filter((r) => !this.removedReplicas.has(r));
+    if (this.readPreference === "replica") {
+      if (availableReplicas.length === 0) {
+        return this.primaryUrl ?? this.baseUrl;
+      }
+      const idx = Math.floor(Math.random() * availableReplicas.length);
+      return availableReplicas[idx];
+    }
+    if (this.readPreference === "nearest") {
+      await this.ensureLatencyMeasured();
+      const reachable = this.latencies.filter((l) => l.reachable && !this.removedReplicas.has(l.url));
+      if (reachable.length === 0) {
+        return this.primaryUrl ?? this.baseUrl;
+      }
+      reachable.sort((a, b) => a.latencyMs - b.latencyMs);
+      return reachable[0].url;
+    }
+    return this.primaryUrl ?? this.baseUrl;
+  }
+  async _getWriteEndpoint(databaseId) {
+    if (this.discovery === "coordinator" && databaseId) {
+      const routing = await this.ensureClusterRouting(databaseId);
+      if (!routing.currentPrimary) {
+        throw new RemoteError("NO_SAFE_PRIMARY", "No current primary is available");
+      }
+      return routing.currentPrimary;
+    }
+    return this.primaryUrl ?? this.baseUrl;
+  }
+  _getReadConcern() {
+    return this.readConcern;
+  }
+  _usesCoordinatorDiscovery() {
+    return this.discovery === "coordinator";
+  }
+  _removeReplica(url) {
+    this.removedReplicas.add(url);
+  }
+  async ensureLatencyMeasured() {
+    const now = Date.now();
+    if (this.latencies.length > 0 && now - this.latencyMeasuredAt < this.LATENCY_TTL_MS) {
+      return;
+    }
+    if (this.latencyMeasuring) {
+      await this.latencyMeasuring;
+      return;
+    }
+    this.latencyMeasuring = this.measureLatencies();
+    try {
+      await this.latencyMeasuring;
+    } finally {
+      this.latencyMeasuring = null;
+    }
+  }
+  async measureLatencies() {
+    const allEndpoints = [];
+    if (this.primaryUrl) {
+      allEndpoints.push(this.primaryUrl);
+    }
+    for (const r of this.replicaUrls) {
+      allEndpoints.push(r);
+    }
+    const results = await Promise.all(
+      allEndpoints.map(async (url) => {
+        const start = performance.now();
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5e3);
+        const unrefable = timeout;
+        if (typeof unrefable.unref === "function") {
+          unrefable.unref();
+        }
+        try {
+          const init = { signal: controller.signal };
+          const response = await fetch(`${url}/health`, init);
+          if (!response.ok) {
+            return { url, latencyMs: Number.MAX_SAFE_INTEGER, reachable: false };
+          }
+          return { url, latencyMs: performance.now() - start, reachable: true };
+        } catch {
+          return { url, latencyMs: Number.MAX_SAFE_INTEGER, reachable: false };
+        } finally {
+          clearTimeout(timeout);
+        }
+      })
+    );
+    this.latencies = results;
+    this.latencyMeasuredAt = Date.now();
+  }
+  async _refreshClusterRouting(databaseId) {
+    const candidates = this.clusterDiscoveryCandidates(databaseId);
+    const encodedId = encodeURIComponent(databaseId);
+    for (const endpoint of candidates) {
+      const base = toServerBaseUrl(endpoint, databaseId);
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), CLUSTER_DISCOVERY_FETCH_TIMEOUT_MS);
+      const unrefable = timeout;
+      unrefable.unref?.();
+      let next = null;
+      try {
+        const response = await fetch(`${base}/db/${encodedId}/cluster`, {
+          headers: this.headers,
+          signal: controller.signal
+        });
+        if (!response.ok) {
+          continue;
+        }
+        const data = await response.json();
+        next = parseClusterRouting(data, databaseId);
+      } catch (err) {
+        if (err instanceof RemoteError && err.code === "INVALID_RESPONSE") {
+          throw err;
+        }
+      } finally {
+        clearTimeout(timeout);
+      }
+      if (!next) {
+        continue;
+      }
+      const previous = this.clusterRouting.get(databaseId);
+      this.clusterRouting.set(databaseId, next);
+      if (clusterRoutingChanged(previous, next)) {
+        try {
+          await this.notifyClusterRoutingChanged(databaseId);
+        } catch (err) {
+          if (previous) {
+            this.clusterRouting.set(databaseId, previous);
+          } else {
+            this.clusterRouting.delete(databaseId);
+          }
+          throw err;
+        }
+      }
+      return;
+    }
+    throw new RemoteError("ROUTING_ERROR", `Could not discover cluster routing for database '${databaseId}'`);
+  }
+  async ensureClusterRouting(databaseId) {
+    const existing = this.clusterRouting.get(databaseId);
+    if (existing) return existing;
+    await this._refreshClusterRouting(databaseId);
+    const refreshed = this.clusterRouting.get(databaseId);
+    if (!refreshed) {
+      throw new RemoteError("ROUTING_ERROR", `Could not discover cluster routing for database '${databaseId}'`);
+    }
+    return refreshed;
+  }
+  clusterDiscoveryCandidates(databaseId) {
+    const candidates = /* @__PURE__ */ new Set();
+    for (const endpoint of this.starterEndpoints) candidates.add(endpoint);
+    if (this.primaryUrl) candidates.add(this.primaryUrl);
+    for (const endpoint of this.replicaUrls) candidates.add(endpoint);
+    const existing = this.clusterRouting.get(databaseId);
+    if (existing?.currentPrimary) candidates.add(existing.currentPrimary);
+    for (const endpoint of existing?.readEndpoints ?? []) candidates.add(endpoint.url);
+    if (this.baseUrl) candidates.add(this.baseUrl);
+    return [...candidates];
+  }
+  _unregisterTopologyTransport(databaseId, transport) {
+    if (this.topologyTransports.get(databaseId) === transport) {
+      this.topologyTransports.delete(databaseId);
+    }
+  }
+  async notifyClusterRoutingChanged(databaseId) {
+    const transport = this.topologyTransports.get(databaseId);
+    if (!transport) return;
+    await transport._handleClusterRoutingChanged();
+  }
+};
+var TopologyAwareTransport = class {
+  databaseId;
+  client;
+  closed = false;
+  readTransport = null;
+  writeTransport = null;
+  subscriptionTransport = null;
+  readTransportRequest = null;
+  writeTransportRequest = null;
+  subscriptionTransportRequest = null;
+  subscriptionOperation = Promise.resolve();
+  activeSubscriptions = /* @__PURE__ */ new Map();
+  nextSubscriptionId = 0;
+  currentReadUrl = "";
+  currentWriteUrl = "";
+  currentSubscriptionUrl = "";
+  constructor(databaseId, client) {
+    this.databaseId = databaseId;
+    this.client = client;
+  }
+  async query(sql, params) {
+    const readConcern = this.client._getReadConcern();
+    const transport = await this.getReadTransport(readConcern);
+    const endpointUsed = this.currentReadUrl;
+    try {
+      return await transport.query(sql, params, readConcern ? { level: readConcern } : void 0);
+    } catch (err) {
+      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
+        await this.client._refreshClusterRouting(this.databaseId);
+        this.readTransport = null;
+        this.currentReadUrl = "";
+        const refreshed = await this.getReadTransport(readConcern);
+        return refreshed.query(sql, params, readConcern ? { level: readConcern } : void 0);
+      }
+      const isTransportError = err instanceof Error && (err.name !== "RemoteError" || err.code === "CONNECTION_ERROR");
+      const writeEndpoint = await this.client._getWriteEndpoint(this.databaseId);
+      if (isTransportError && endpointUsed && endpointUsed !== writeEndpoint) {
+        this.client._removeReplica(endpointUsed);
+        if (this.currentReadUrl === endpointUsed) {
+          this.readTransport = null;
+          this.currentReadUrl = "";
+        }
+        const fallback = await this.getReadTransport();
+        return fallback.query(sql, params);
+      }
+      throw err;
+    }
+  }
+  async execute(sql, params) {
+    const transport = await this.getWriteTransport();
+    try {
+      return await transport.execute(sql, params);
+    } catch (err) {
+      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
+        await this.client._refreshClusterRouting(this.databaseId);
+        this.writeTransport = null;
+        this.currentWriteUrl = "";
+      }
+      throw err;
+    }
+  }
+  async transaction(statements) {
+    const transport = await this.getWriteTransport();
+    try {
+      return await transport.transaction(statements);
+    } catch (err) {
+      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
+        await this.client._refreshClusterRouting(this.databaseId);
+        this.writeTransport = null;
+        this.currentWriteUrl = "";
+      }
+      throw err;
+    }
+  }
+  async subscribe(table, filter, callback) {
+    try {
+      return await this.subscribeOnCurrentEndpoint(table, filter, callback);
+    } catch (err) {
+      if (this.client._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
+        const hadActiveSubscriptions = this.activeSubscriptions.size > 0;
+        if (!hadActiveSubscriptions) {
+          this.closeSubscriptionTransport();
+        }
+        await this.client._refreshClusterRouting(this.databaseId);
+        if (!hadActiveSubscriptions) {
+          this.closeSubscriptionTransport();
+        }
+        return this.subscribeOnCurrentEndpoint(table, filter, callback);
+      }
+      throw err;
+    }
+  }
+  async _handleClusterRoutingChanged() {
+    if (!this.client._usesCoordinatorDiscovery()) return;
+    if (this.activeSubscriptions.size === 0) return;
+    await this.withSubscriptionOperation(() => this.migrateSubscriptionsToCurrentEndpoint());
+  }
+  close() {
+    this.closed = true;
+    const sameTransport = this.readTransport !== null && this.readTransport === this.writeTransport;
+    const subscriptionIsRead = this.subscriptionTransport !== null && this.subscriptionTransport === this.readTransport;
+    const subscriptionIsWrite = this.subscriptionTransport !== null && this.subscriptionTransport === this.writeTransport;
+    for (const subscription of this.activeSubscriptions.values()) {
+      subscription.active = false;
+      subscription.remote = null;
+    }
+    this.activeSubscriptions.clear();
+    if (this.readTransport) {
+      this.readTransport.close();
+      this.readTransport = null;
+    }
+    if (this.writeTransport && !sameTransport) {
+      this.writeTransport.close();
+    }
+    this.writeTransport = null;
+    if (this.subscriptionTransport && !subscriptionIsRead && !subscriptionIsWrite) {
+      this.subscriptionTransport.close();
+    }
+    this.subscriptionTransport = null;
+    this.currentSubscriptionUrl = "";
+    this.client._unregisterTopologyTransport(this.databaseId, this);
+  }
+  async subscribeOnCurrentEndpoint(table, filter, callback) {
+    return this.withSubscriptionOperation(async () => {
+      const transport = await this.getSubscriptionTransport(this.client._getReadConcern());
+      const remote = await transport.subscribe(table, filter, callback);
+      const subscription = {
+        id: ++this.nextSubscriptionId,
+        table,
+        filter,
+        callback,
+        remote,
+        active: true
+      };
+      this.activeSubscriptions.set(subscription.id, subscription);
+      return this.createSubscriptionHandle(subscription);
+    });
+  }
+  createSubscriptionHandle(subscription) {
+    return {
+      unsubscribe: () => {
+        if (!subscription.active) return;
+        subscription.active = false;
+        this.activeSubscriptions.delete(subscription.id);
+        const remote = subscription.remote;
+        subscription.remote = null;
+        remote?.unsubscribe();
+      }
+    };
+  }
+  async migrateSubscriptionsToCurrentEndpoint() {
+    this.assertOpen();
+    const subscriptions = [...this.activeSubscriptions.values()].filter((subscription) => subscription.active);
+    if (subscriptions.length === 0) return;
+    const readConcern = this.client._getReadConcern();
+    const endpoint = await this.client._getReadEndpoint(this.databaseId, readConcern);
+    this.assertOpen();
+    if (this.subscriptionTransport && this.currentSubscriptionUrl === endpoint) {
+      return;
+    }
+    const nextTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
+    const nextSubscriptions = /* @__PURE__ */ new Map();
+    try {
+      for (const subscription of subscriptions) {
+        if (!subscription.active) continue;
+        const remote = await nextTransport.subscribe(subscription.table, subscription.filter, subscription.callback);
+        if (!subscription.active) {
+          remote.unsubscribe();
+          continue;
+        }
+        nextSubscriptions.set(subscription.id, remote);
+      }
+    } catch (err) {
+      for (const remote of nextSubscriptions.values()) {
+        remote.unsubscribe();
+      }
+      nextTransport.close();
+      throw toSubscriptionRoutingError(err, this.databaseId);
+    }
+    const oldTransport = this.subscriptionTransport;
+    this.subscriptionTransport = nextTransport;
+    this.currentSubscriptionUrl = endpoint;
+    for (const subscription of subscriptions) {
+      const nextRemote = nextSubscriptions.get(subscription.id);
+      if (!nextRemote) continue;
+      const previousRemote = subscription.remote;
+      if (!subscription.active) {
+        nextRemote.unsubscribe();
+        continue;
+      }
+      subscription.remote = nextRemote;
+      previousRemote?.unsubscribe();
+    }
+    if (oldTransport) {
+      oldTransport.close();
+    }
+  }
+  async getReadTransport(readConcern) {
+    this.assertOpen();
+    while (this.readTransportRequest) {
+      await this.readTransportRequest.catch(() => void 0);
+      this.assertOpen();
+    }
+    const request = this.resolveReadTransport(readConcern);
+    this.readTransportRequest = request;
+    try {
+      return await request;
+    } finally {
+      if (this.readTransportRequest === request) {
+        this.readTransportRequest = null;
+      }
+    }
+  }
+  async resolveReadTransport(readConcern) {
+    const endpoint = await this.client._getReadEndpoint(this.databaseId, readConcern);
+    this.assertOpen();
+    if (this.readTransport && this.currentReadUrl === endpoint) {
+      return this.readTransport;
+    }
+    const nextTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
+    const oldTransport = this.readTransport;
+    this.readTransport = nextTransport;
+    this.currentReadUrl = endpoint;
+    if (oldTransport) {
+      oldTransport.close();
+    }
+    return this.readTransport;
+  }
+  async getWriteTransport() {
+    this.assertOpen();
+    while (this.writeTransportRequest) {
+      await this.writeTransportRequest.catch(() => void 0);
+      this.assertOpen();
+    }
+    const request = this.resolveWriteTransport();
+    this.writeTransportRequest = request;
+    try {
+      return await request;
+    } finally {
+      if (this.writeTransportRequest === request) {
+        this.writeTransportRequest = null;
+      }
+    }
+  }
+  async resolveWriteTransport() {
+    const endpoint = await this.client._getWriteEndpoint(this.databaseId);
+    this.assertOpen();
+    if (this.writeTransport && this.currentWriteUrl === endpoint) {
+      return this.writeTransport;
+    }
+    const nextTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
+    const oldTransport = this.writeTransport;
+    this.writeTransport = nextTransport;
+    this.currentWriteUrl = endpoint;
+    if (oldTransport) {
+      oldTransport.close();
+    }
+    return this.writeTransport;
+  }
+  async getSubscriptionTransport(readConcern) {
+    this.assertOpen();
+    if (this.subscriptionTransport) {
+      return this.subscriptionTransport;
+    }
+    while (this.subscriptionTransportRequest) {
+      await this.subscriptionTransportRequest.catch(() => void 0);
+      this.assertOpen();
+      if (this.subscriptionTransport) {
+        return this.subscriptionTransport;
+      }
+    }
+    const request = this.resolveSubscriptionTransport(readConcern);
+    this.subscriptionTransportRequest = request;
+    try {
+      return await request;
+    } finally {
+      if (this.subscriptionTransportRequest === request) {
+        this.subscriptionTransportRequest = null;
+      }
+    }
+  }
+  async resolveSubscriptionTransport(readConcern) {
+    if (this.subscriptionTransport) {
+      return this.subscriptionTransport;
+    }
+    const endpoint = await this.client._getReadEndpoint(this.databaseId, readConcern);
+    this.assertOpen();
+    if (this.subscriptionTransport) {
+      return this.subscriptionTransport;
+    }
+    this.subscriptionTransport = this.client._createTransportForEndpoint(endpoint, this.databaseId);
+    this.currentSubscriptionUrl = endpoint;
+    return this.subscriptionTransport;
+  }
+  closeSubscriptionTransport() {
+    if (this.subscriptionTransport) {
+      this.subscriptionTransport.close();
+      this.subscriptionTransport = null;
+    }
+    this.currentSubscriptionUrl = "";
+  }
+  async withSubscriptionOperation(operation) {
+    const previous = this.subscriptionOperation;
+    let release = () => {
+    };
+    this.subscriptionOperation = new Promise((resolve) => {
+      release = resolve;
     });
+    await previous.catch(() => void 0);
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
+    }
   }
 };
+function toSubscriptionRoutingError(err, databaseId) {
+  const detail = err instanceof Error ? err.message : String(err);
+  return new RemoteError(
+    "ROUTING_ERROR",
+    `Could not re-establish active subscriptions on refreshed routing for database '${databaseId}': ${detail}`
+  );
+}
+function shouldRefreshRouting(err) {
+  if (!(err instanceof RemoteError)) {
+    return false;
+  }
+  return err.code === "STALE_PRIMARY" || err.code === "AUTHORITY_LOST" || err.code === "COORDINATOR_UNAVAILABLE" || err.code === "NO_SAFE_PRIMARY" || err.code === "CONNECTION_ERROR";
+}
 
 export { HttpTransport, RemoteDatabase, RemoteError, RemoteSubscriptionBuilderImpl, SirannonClient, WebSocketTransport };