@delali/sirannon-db 0.1.8 → 0.2.0

package/dist/chunk-H237TXZW.mjs

@@ -0,0 +1,1407 @@
+// src/client/types.ts
+var RemoteError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "RemoteError";
+    this.code = code;
+  }
+};
+
+// src/client/remote-live-query.ts
+var RemoteLiveQuery = class _RemoteLiveQuery {
+  state = { status: "pending" };
+  rows = [];
+  listeners = /* @__PURE__ */ new Set();
+  subscription = null;
+  closed = false;
+  static async open(subscribe) {
+    const query = new _RemoteLiveQuery();
+    try {
+      query.subscription = await subscribe(query.handlers());
+    } catch (err) {
+      query.closed = true;
+      throw err;
+    }
+    if (query.state.status === "error") {
+      const failure = query.state.error;
+      await query.close();
+      throw failure;
+    }
+    return query;
+  }
+  getState() {
+    return this.state;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.listeners.clear();
+    this.subscription?.unsubscribe();
+    this.subscription = null;
+  }
+  handlers() {
+    return {
+      onRows: (rows) => this.replace(rows),
+      onOps: (ops) => this.apply(ops),
+      onRevalidating: () => this.markRevalidating(),
+      onError: (error) => this.fail(error)
+    };
+  }
+  replace(rows) {
+    if (this.closed) return;
+    this.rows = rows;
+    this.publish({ status: "ready", rows: this.rows, revalidating: false }, { kind: "rows" });
+  }
+  apply(ops) {
+    if (this.closed) return;
+    if (this.state.status !== "ready") {
+      this.fail(new RemoteError("INVALID_RESPONSE", "A live query received row operations before its first result"));
+      return;
+    }
+    const next = this.rows.slice();
+    for (const op of ops) {
+      const highest = op.op === "insert" ? next.length : next.length - 1;
+      if (!Number.isInteger(op.index) || op.index < 0 || op.index > highest) {
+        this.fail(new RemoteError("INVALID_RESPONSE", "A live query received an operation outside its rows"));
+        return;
+      }
+      if (op.op === "insert") next.splice(op.index, 0, op.row);
+      else if (op.op === "update") next[op.index] = op.row;
+      else next.splice(op.index, 1);
+    }
+    this.rows = next;
+    this.publish({ status: "ready", rows: this.rows, revalidating: false }, { kind: "ops", ops });
+  }
+  markRevalidating() {
+    if (this.closed || this.state.status !== "ready" || this.state.revalidating) return;
+    this.publish({ status: "ready", rows: this.rows, revalidating: true }, { kind: "revalidating" });
+  }
+  fail(error) {
+    if (this.closed) return;
+    this.publish({ status: "error", error }, { kind: "error" });
+  }
+  publish(next, update) {
+    this.state = next;
+    for (const listener of [...this.listeners]) {
+      try {
+        listener(update);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/client/subscription.ts
+var RemoteSubscriptionBuilderImpl = class {
+  constructor(table, transport) {
+    this.table = table;
+    this.transport = transport;
+  }
+  conditions = {};
+  filter(conditions) {
+    this.conditions = { ...this.conditions, ...conditions };
+    return this;
+  }
+  subscribe(callback, options) {
+    const filter = Object.keys(this.conditions).length > 0 ? this.conditions : void 0;
+    return this.transport.subscribe(this.table, filter, callback, options);
+  }
+};
+
+// src/client/database-proxy.ts
+var DEFAULT_LOAD_BATCH_SIZE = 1e3;
+var READ_CONCERN_UNSUPPORTED_MESSAGE = "This transport does not carry a per-read concern to the server. Use the HTTP transport for a per-call readConcern, or set the client-wide readConcern that topology routing applies when choosing a node.";
+function isAsyncIterable(value) {
+  return typeof value[Symbol.asyncIterator] === "function";
+}
+var RemoteDatabase = class {
+  constructor(id, transport, capabilities, onDispose) {
+    this.id = id;
+    this.transport = transport;
+    this.capabilities = capabilities;
+    this.onDispose = onDispose;
+  }
+  async query(operation, params, options) {
+    this.assertReadConcernReaches(options?.readConcern);
+    if (typeof operation !== "string") {
+      const named = await this.transport.queryNamed(
+        operation.name,
+        params,
+        options?.readConcern
+      );
+      return named.rows;
+    }
+    await this.capabilities.assertSqlAccepted();
+    const response = await this.transport.query(operation, params, options?.readConcern);
+    return response.rows;
+  }
+  assertReadConcernReaches(readConcern) {
+    if (readConcern === void 0 || this.transport.carriesReadConcern === true) return;
+    throw new RemoteError("INVALID_ARGUMENT", READ_CONCERN_UNSUPPORTED_MESSAGE);
+  }
+  async execute(operation, params, writeConcern) {
+    if (typeof operation !== "string") {
+      const named = await this.transport.executeNamed(
+        operation.name,
+        params,
+        writeConcern
+      );
+      return named.results;
+    }
+    await this.capabilities.assertSqlAccepted();
+    return this.transport.execute(operation, params);
+  }
+  async live(operation, args) {
+    const name = typeof operation === "string" ? operation : operation.name;
+    return RemoteLiveQuery.open(
+      (handlers) => this.transport.liveSubscribe(name, args, handlers, (refresh) => this.capabilities.registryDigest(refresh))
+    );
+  }
+  /**
+   * Execute multiple statements as a single atomic transaction.
+   * Returns an array of results, one per statement.
+   *
+   * The whole list travels in one request and commits or rolls back as a
+   * unit, so the client is never in the loop between statements.
+   */
+  async transaction(statements) {
+    await this.capabilities.assertSqlAccepted();
+    const response = await this.transport.transaction(statements);
+    return response.results;
+  }
+  /**
+   * Run the same statement once per parameter set as a single atomic
+   * transaction that commits with one fsync. Returns one result per
+   * parameter set, in order. Use this for a burst of same-shape writes
+   * (an import, a bulk insert) that must all commit or all roll back.
+   */
+  async batch(sql, paramsBatch, writeConcern) {
+    await this.capabilities.assertSqlAccepted();
+    const response = await this.transport.batch(sql, paramsBatch, writeConcern);
+    return response.results;
+  }
+  /**
+   * Load a whole dataset through the same statement, batching it into requests
+   * for you and paying the one fsyncing WAL checkpoint once, after the final
+   * batch. The configured durability is restored after every batch, so an
+   * import that stops partway never leaves the writer at the relaxed level.
+   * Prefer this over {@link load} for anything larger than a single request:
+   * it runs the finalize itself, so there is no checkpoint flag to forget.
+   *
+   * Accepts a synchronous or asynchronous iterable of parameter sets, so rows
+   * can stream from a file or the network without being held in memory at
+   * once. Returns the total rows loaded and changes applied.
+   *
+   * ```ts
+   * const summary = await db.loadAll(
+   *   'INSERT INTO events (id, payload) VALUES (?, ?)',
+   *   rowStream,
+   *   { batchSize: 5000, durability: 'off' },
+   * )
+   * ```
+   */
+  async loadAll(sql, rows, options) {
+    const batchSize = options?.batchSize ?? DEFAULT_LOAD_BATCH_SIZE;
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+      throw new RemoteError("INVALID_ARGUMENT", "loadAll batchSize must be a positive integer");
+    }
+    await this.capabilities.assertSqlAccepted();
+    const durability = options?.durability;
+    const total = { rowsLoaded: 0, changes: 0 };
+    const send = async (paramsBatch, checkpoint) => {
+      const summary = await this.transport.load(sql, paramsBatch, durability, checkpoint);
+      total.rowsLoaded += summary.rowsLoaded;
+      total.changes += summary.changes;
+    };
+    let batch = [];
+    let previous = null;
+    const rotate = async () => {
+      if (previous !== null) await send(previous, false);
+      previous = batch;
+      batch = [];
+    };
+    if (isAsyncIterable(rows)) {
+      for await (const row of rows) {
+        batch.push(row);
+        if (batch.length >= batchSize) await rotate();
+      }
+    } else {
+      for (const row of rows) {
+        batch.push(row);
+        if (batch.length >= batchSize) await rotate();
+      }
+    }
+    if (batch.length > 0) {
+      if (previous !== null) await send(previous, false);
+      await send(batch, true);
+    } else if (previous !== null) {
+      await send(previous, true);
+    }
+    return total;
+  }
+  /**
+   * Load one batch of rows through the same statement with writer durability
+   * relaxed for the duration, then restored before this resolves. This is the
+   * low-level primitive; prefer {@link loadAll} for a dataset that spans more
+   * than one request, since it runs the finalize itself rather than relying on
+   * a `checkpoint` flag.
+   *
+   * Returns the total rows loaded and changes applied. When splitting a dataset
+   * across many `load` calls by hand, pass `checkpoint: false` on every call
+   * but the last so the one fsyncing WAL checkpoint runs once at the end; the
+   * configured durability is restored after each call regardless.
+   */
+  async load(sql, paramsBatch, durability, checkpoint) {
+    await this.capabilities.assertSqlAccepted();
+    return this.transport.load(sql, paramsBatch, durability, checkpoint);
+  }
+  /**
+   * Start building a CDC subscription for the given table.
+   * Chain `.filter()` to narrow the events, then call `.subscribe()`
+   * with a callback to begin receiving real-time change events.
+   *
+   * ```ts
+   * const sub = await db
+   *   .on('orders')
+   *   .filter({ status: 'pending' })
+   *   .subscribe(event => console.log(event))
+   *
+   * // Later:
+   * sub.unsubscribe()
+   * ```
+   */
+  on(table) {
+    return new RemoteSubscriptionBuilderImpl(table, this.transport);
+  }
+  /**
+   * Close the transport for this database. After calling `close()`,
+   * all pending requests are rejected and new calls will throw.
+   */
+  close() {
+    this.transport.close();
+    this.onDispose?.();
+  }
+};
+
+// src/client/endpoint-urls.ts
+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 toBaseUrl(url) {
+  return normaliseEndpointUrl(url);
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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://");
+}
+
+// src/client/http-json.ts
+var DEFAULT_HTTP_REQUEST_TIMEOUT_MS = 3e4;
+function unrefTimer(timer) {
+  const unrefable = timer;
+  unrefable.unref?.();
+}
+async function requestJson(url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  unrefTimer(timer);
+  let response;
+  try {
+    response = await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    throw new RemoteError(
+      "CONNECTION_ERROR",
+      `Failed to connect to ${url}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  } finally {
+    clearTimeout(timer);
+  }
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw new RemoteError("INVALID_RESPONSE", `Server returned non-JSON response (HTTP ${response.status})`);
+  }
+  if (!response.ok) {
+    const errorData = data;
+    throw new RemoteError(
+      errorData.error?.code ?? "UNKNOWN_ERROR",
+      errorData.error?.message ?? `HTTP ${response.status}`
+    );
+  }
+  return data;
+}
+async function postJson(url, body, headers, timeoutMs = DEFAULT_HTTP_REQUEST_TIMEOUT_MS) {
+  return requestJson(
+    url,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json", ...headers },
+      body: JSON.stringify(body)
+    },
+    timeoutMs
+  );
+}
+async function getJson(url, headers, timeoutMs = DEFAULT_HTTP_REQUEST_TIMEOUT_MS) {
+  return requestJson(url, { method: "GET", headers: { ...headers } }, timeoutMs);
+}
+
+// src/core/cdc/encoding.ts
+var BLOB_TAG = "__sirannon_blob";
+var INT_TAG = "__sirannon_int";
+var SAFE_INT_BOUND = 9007199254740991n;
+var HEX_BYTES_RE = /^[0-9a-fA-F]*$/;
+var INT_PAYLOAD_RE = /^-?\d{1,19}$/;
+function encodeTaggedValues(value) {
+  if (typeof value === "bigint" || isBinaryValue(value)) {
+    return encodeTaggedLeaf(value);
+  }
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) {
+    return value.map(encodeTaggedValues);
+  }
+  if (typeof value.toJSON === "function") {
+    return value;
+  }
+  const obj = value;
+  const out = {};
+  for (const k of Object.keys(obj)) {
+    out[k] = encodeTaggedValues(obj[k]);
+  }
+  return out;
+}
+function encodeTaggedLeaf(value) {
+  if (typeof value === "bigint") {
+    if (value >= -SAFE_INT_BOUND && value <= SAFE_INT_BOUND) {
+      return Number(value);
+    }
+    return { [INT_TAG]: value.toString() };
+  }
+  if (isBinaryValue(value)) {
+    return { [BLOB_TAG]: encodeHexBytes(value) };
+  }
+  return value;
+}
+function decodeTaggedValues(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (isBinaryValue(value)) return value;
+  if (Array.isArray(value)) {
+    return value.map(decodeTaggedValues);
+  }
+  const obj = value;
+  const keys = Object.keys(obj);
+  if (keys.length === 1) {
+    const tag = keys[0];
+    const tagValue = obj[tag];
+    if (tag === BLOB_TAG && typeof tagValue === "string") {
+      return decodeHexBytes(tagValue);
+    }
+    if (tag === INT_TAG && typeof tagValue === "string") {
+      if (!INT_PAYLOAD_RE.test(tagValue)) {
+        throw new Error("Invalid tagged integer payload");
+      }
+      return BigInt(tagValue);
+    }
+  }
+  const out = {};
+  for (const k of keys) {
+    out[k] = decodeTaggedValues(obj[k]);
+  }
+  return out;
+}
+function isBinaryValue(value) {
+  return value instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(value);
+}
+function encodeHexBytes(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("hex").toUpperCase();
+  }
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex.toUpperCase();
+}
+function decodeHexBytes(hex) {
+  if (hex.length % 2 !== 0 || !HEX_BYTES_RE.test(hex)) {
+    throw new Error("Invalid CDC BLOB hex payload");
+  }
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(hex, "hex");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    const byte = Number.parseInt(hex.slice(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Invalid CDC BLOB hex payload");
+    }
+    bytes[i / 2] = byte;
+  }
+  return bytes;
+}
+
+// src/server/capabilities.ts
+var REQUIRED_DEVICE_SYNC_CAPABILITIES = [
+  "sync.push",
+  "sync.echo-suppression",
+  "sync.ack",
+  "sync.resume",
+  "sync.snapshot",
+  "sync.migrations",
+  "sync.schema-gate",
+  "sync.stream-apply"
+];
+var STAGED_STREAM_CAPABILITY = "sync.staged-stream";
+var SQL_QUERY_CAPABILITY = "query.sql";
+
+// src/client/sync-capabilities.ts
+function validateCapabilities(raw) {
+  const record = raw;
+  if (record === null || typeof record !== "object" || !Array.isArray(record.capabilities) || record.capabilities.some((name) => typeof name !== "string")) {
+    throw new RemoteError("INVALID_RESPONSE", "Capabilities response is malformed");
+  }
+  const digest = record.registry?.digest;
+  if (digest !== void 0 && typeof digest !== "string") {
+    throw new RemoteError("INVALID_RESPONSE", "Capabilities response carries a non-string registry digest");
+  }
+  return { capabilities: record.capabilities, registryDigest: digest };
+}
+async function fetchCapabilityReport(options) {
+  return validateCapabilities(await getJson(`${options.url}/capabilities`, options.headers, options.requestTimeoutMs));
+}
+async function fetchServerCapabilities(options) {
+  return (await fetchCapabilityReport(options)).capabilities;
+}
+async function verifyDeviceSyncCapabilities(options) {
+  let capabilities;
+  try {
+    capabilities = await fetchServerCapabilities(options);
+  } catch (err) {
+    if (err instanceof RemoteError && err.code === "NOT_FOUND") {
+      throw new RemoteError(
+        "SYNC_UNSUPPORTED",
+        "The server does not announce capabilities; it predates device sync and cannot sync safely. Upgrade the server."
+      );
+    }
+    throw err;
+  }
+  const announced = new Set(capabilities);
+  const missing = REQUIRED_DEVICE_SYNC_CAPABILITIES.filter((name) => !announced.has(name));
+  if (missing.length > 0) {
+    throw new RemoteError(
+      "SYNC_UNSUPPORTED",
+      `The server does not support required device sync capabilities: ${missing.join(", ")}. Upgrade the server.`
+    );
+  }
+  return capabilities;
+}
+
+// src/client/server-capabilities.ts
+var SQL_REFUSED_MESSAGE = "This server does not accept SQL over the network. Call a registered operation by name, or start the server with acceptSql: true.";
+var SQL_UNCONFIRMED_MESSAGE = "GET /capabilities returned 404, so this client cannot confirm that the server accepts SQL and refuses to send it. Check that the URL reaches a sirannon-db server and that any proxy in front of it forwards /capabilities.";
+var ServerCapabilities = class {
+  constructor(resolveUrl, headers, requestTimeoutMs = DEFAULT_HTTP_REQUEST_TIMEOUT_MS) {
+    this.resolveUrl = resolveUrl;
+    this.headers = headers;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  pending = null;
+  async read(refresh = false) {
+    if (refresh) this.pending = null;
+    if (this.pending === null) {
+      const request = this.fetch();
+      this.pending = request;
+      request.catch(() => {
+        if (this.pending === request) this.pending = null;
+      });
+    }
+    return this.pending;
+  }
+  async registryDigest(refresh = false) {
+    try {
+      return (await this.read(refresh)).registryDigest;
+    } catch (err) {
+      if (isMissingEndpoint(err)) return void 0;
+      throw err;
+    }
+  }
+  async assertSqlAccepted() {
+    let report;
+    try {
+      report = await this.read();
+    } catch (err) {
+      if (isMissingEndpoint(err)) throw new RemoteError("SQL_NOT_ACCEPTED", SQL_UNCONFIRMED_MESSAGE);
+      throw err;
+    }
+    if (!report.capabilities.includes(SQL_QUERY_CAPABILITY)) {
+      throw new RemoteError("SQL_NOT_ACCEPTED", SQL_REFUSED_MESSAGE);
+    }
+  }
+  async fetch() {
+    const url = await this.resolveUrl();
+    return fetchCapabilityReport({ url, headers: this.headers, requestTimeoutMs: this.requestTimeoutMs });
+  }
+};
+function isMissingEndpoint(err) {
+  return err instanceof RemoteError && err.code === "NOT_FOUND";
+}
+
+// src/client/transport/http.ts
+var HttpTransport = class {
+  carriesReadConcern = true;
+  baseUrl;
+  headers;
+  closed = false;
+  constructor(baseUrl, headers) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.headers = {
+      "content-type": "application/json",
+      ...headers
+    };
+  }
+  async query(sql, params, readConcern) {
+    const response = await this.post("/query", {
+      sql,
+      params: encodeTaggedValues(params),
+      readConcern
+    });
+    return { rows: decodeTaggedValues(response.rows ?? []) };
+  }
+  async execute(sql, params) {
+    return this.post("/execute", { sql, params: encodeTaggedValues(params) });
+  }
+  async transaction(statements) {
+    return this.post("/transaction", {
+      statements: statements.map((stmt) => ({ sql: stmt.sql, params: encodeTaggedValues(stmt.params) }))
+    });
+  }
+  async batch(sql, paramsBatch, writeConcern) {
+    return this.post("/batch", {
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      writeConcern
+    });
+  }
+  async load(sql, paramsBatch, durability, checkpoint) {
+    return this.post("/load", {
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      durability,
+      checkpoint
+    });
+  }
+  async queryNamed(name, args, readConcern) {
+    const response = await this.post(`/query/${encodeURIComponent(name)}`, {
+      args: encodeTaggedValues(args),
+      readConcern
+    });
+    return { rows: decodeTaggedValues(response.rows ?? []) };
+  }
+  async executeNamed(name, args, writeConcern) {
+    return this.post(`/execute/${encodeURIComponent(name)}`, {
+      args: encodeTaggedValues(args),
+      writeConcern
+    });
+  }
+  async liveSubscribe() {
+    throw new RemoteError(
+      "TRANSPORT_ERROR",
+      'Live queries require WebSocket transport. Create the client with { transport: "websocket" } to use them.'
+    );
+  }
+  async subscribe(_table, _filter, _callback) {
+    throw new RemoteError(
+      "TRANSPORT_ERROR",
+      'Subscriptions require WebSocket transport. Create the client with { transport: "websocket" } to use real-time subscriptions.'
+    );
+  }
+  close() {
+    this.closed = true;
+  }
+  async post(path, body) {
+    if (this.closed) {
+      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
+    }
+    const url = `${this.baseUrl}${path}`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(body)
+      });
+    } catch (err) {
+      throw new RemoteError(
+        "CONNECTION_ERROR",
+        `Failed to connect to ${url}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let data;
+    try {
+      data = await response.json();
+    } catch {
+      throw new RemoteError("INVALID_RESPONSE", `Server returned non-JSON response (HTTP ${response.status})`);
+    }
+    if (!response.ok) {
+      const errorData = data;
+      throw new RemoteError(
+        errorData.error?.code ?? "UNKNOWN_ERROR",
+        errorData.error?.message ?? `HTTP ${response.status}`
+      );
+    }
+    return data;
+  }
+};
+
+// src/core/ws-handshake.ts
+var SIRANNON_WS_SUBPROTOCOL = "sirannon.v1";
+var WS_CLOSE_UNAUTHENTICATED = 4401;
+var WS_CLOSE_FORBIDDEN = 4403;
+var REFUSAL_CLOSE_CODE_MIN = 4e3;
+var REFUSAL_CLOSE_CODE_MAX = 4099;
+function withSirannonSubprotocol(protocols) {
+  if (protocols === void 0) return void 0;
+  const configured = typeof protocols === "string" ? [protocols] : [...protocols];
+  return [SIRANNON_WS_SUBPROTOCOL, ...configured.filter((value) => value !== SIRANNON_WS_SUBPROTOCOL)];
+}
+function isRefusalCloseCode(code) {
+  if (code === WS_CLOSE_UNAUTHENTICATED || code === WS_CLOSE_FORBIDDEN) return true;
+  return code >= REFUSAL_CLOSE_CODE_MIN && code <= REFUSAL_CLOSE_CODE_MAX;
+}
+function refusalErrorCode(code) {
+  return code === WS_CLOSE_FORBIDDEN ? "FORBIDDEN" : "UNAUTHORIZED";
+}
+
+// src/client/transport/ws-headers.ts
+var HEADERS_UNSUPPORTED_MESSAGE = "This runtime builds a WebSocket from the global constructor, which carries no handshake header, so 'headers' reaches the server on HTTP requests but never on the WebSocket upgrade. Carry the credential in 'webSocketProtocols' as well, which a browser handshake does carry, or create the client with { transport: 'http' }.";
+function currentRuntime() {
+  return globalThis;
+}
+function runtimeSupportsHandshakeHeaders(runtime = currentRuntime()) {
+  if (runtime.Deno !== void 0 || runtime.window !== void 0) return false;
+  return typeof runtime.process?.versions?.node === "string";
+}
+function carriesSubprotocolCredential(protocols) {
+  return protocols !== void 0 && protocols.length > 0;
+}
+function assertHandshakeHeadersSupported(headers, webSocketProtocols, runtime = currentRuntime()) {
+  if (headers === void 0 || Object.keys(headers).length === 0) return;
+  if (carriesSubprotocolCredential(webSocketProtocols)) return;
+  if (runtimeSupportsHandshakeHeaders(runtime)) return;
+  throw new RemoteError("INVALID_ARGUMENT", HEADERS_UNSUPPORTED_MESSAGE);
+}
+
+// src/client/transport/ws-connect.ts
+function createSocket(url, options) {
+  const { protocols, headers } = options;
+  if (headers !== void 0 && Object.keys(headers).length > 0 && runtimeSupportsHandshakeHeaders()) {
+    const construct = WebSocket;
+    return new construct(url, protocols === void 0 ? { headers } : { headers, protocols });
+  }
+  return protocols === void 0 ? new WebSocket(url) : new WebSocket(url, protocols);
+}
+function readCloseInfo(event) {
+  const raw = event;
+  return {
+    code: typeof raw.code === "number" ? raw.code : 0,
+    reason: typeof raw.reason === "string" ? raw.reason : ""
+  };
+}
+function refusalError(close) {
+  const detail = close.reason.length > 0 ? close.reason : "no reason given";
+  return new RemoteError(refusalErrorCode(close.code), `The server refused the WebSocket connection: ${detail}`);
+}
+function openWebSocket(url, options, callbacks) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const ws = createSocket(url, options);
+    const onOpen = () => {
+      settled = true;
+      callbacks.onConnected(ws);
+      resolve();
+    };
+    const onError = () => {
+      if (!settled) {
+        settled = true;
+        reject(new RemoteError("CONNECTION_ERROR", `Failed to connect to ${url}`));
+      }
+    };
+    const onClose = (event) => {
+      ws.removeEventListener("open", onOpen);
+      ws.removeEventListener("error", onError);
+      const close = readCloseInfo(event);
+      const refusal = isRefusalCloseCode(close.code) ? refusalError(close) : null;
+      if (refusal) {
+        callbacks.onRefused(refusal);
+      }
+      if (!settled) {
+        settled = true;
+        reject(
+          refusal ?? new RemoteError("CONNECTION_ERROR", `Connection closed during handshake: ${close.code} ${close.reason}`)
+        );
+        return;
+      }
+      callbacks.onDisconnected();
+    };
+    const onMessage = (event) => {
+      callbacks.onMessage(String(event.data));
+    };
+    ws.addEventListener("open", onOpen);
+    ws.addEventListener("error", onError);
+    ws.addEventListener("close", onClose);
+    ws.addEventListener("message", onMessage);
+  });
+}
+
+// src/client/transport/ws-subscription-state.ts
+function applySubscribedMessage(sub, msg) {
+  if (msg.epoch !== void 0) {
+    sub.epoch = msg.epoch;
+  }
+  let baseline;
+  if (msg.seq !== void 0) {
+    try {
+      baseline = BigInt(msg.seq);
+    } catch {
+      baseline = void 0;
+    }
+  }
+  if (msg.resync) {
+    sub.lastSeq = baseline;
+    try {
+      sub.onReset?.();
+    } catch {
+    }
+  } else if (sub.lastSeq === void 0 && baseline !== void 0) {
+    sub.lastSeq = baseline;
+  }
+  try {
+    sub.onSubscribed?.({
+      seq: baseline,
+      epoch: sub.epoch,
+      resync: msg.resync === true,
+      maxUnacknowledgedChanges: msg.maxUnacknowledgedChanges
+    });
+  } catch {
+  }
+}
+function deliverChangeMessage(sub, msg) {
+  deliverWireEvent(sub, msg.event);
+}
+function deliverChangesMessage(sub, msg) {
+  if (!Array.isArray(msg.events)) return;
+  for (const event of msg.events) {
+    deliverWireEvent(sub, event);
+  }
+}
+function deliverWireEvent(sub, wire) {
+  try {
+    const event = {
+      type: wire.type,
+      table: wire.table,
+      row: decodeTaggedValues(wire.row),
+      oldRow: wire.oldRow === void 0 ? void 0 : decodeTaggedValues(wire.oldRow),
+      seq: BigInt(wire.seq),
+      timestamp: wire.timestamp,
+      ...wire.hlc !== void 0 ? { hlc: wire.hlc } : {},
+      ...wire.origin !== void 0 ? { origin: wire.origin } : {},
+      ...wire.rowId !== void 0 ? { rowId: wire.rowId } : {},
+      ...wire.txId !== void 0 ? { txId: wire.txId } : {},
+      ...wire.txEnd === true ? { txEnd: true } : {}
+    };
+    if (sub.lastSeq === void 0 || event.seq > sub.lastSeq) {
+      sub.lastSeq = event.seq;
+    }
+    sub.callback(event);
+  } catch {
+  }
+}
+function buildResubscribeMessage(id, sub) {
+  const resumeFrom = sub.resumeSeq === void 0 ? sub.lastSeq : sub.resumeSeq();
+  return {
+    type: "subscribe",
+    id,
+    table: sub.table,
+    ...sub.tables !== void 0 ? { tables: [...sub.tables] } : {},
+    ...sub.filter ? { filter: encodeTaggedValues(sub.filter) } : {},
+    ...resumeFrom !== void 0 ? { sinceSeq: resumeFrom.toString() } : {},
+    ...sub.epoch !== void 0 ? { epoch: sub.epoch } : {},
+    ...sub.deviceId !== void 0 ? { deviceId: sub.deviceId } : {},
+    ...sub.schemaVersion !== void 0 ? { schemaVersion: sub.schemaVersion } : {},
+    ...sub.stagedStream === true ? { stagedStream: true } : {}
+  };
+}
+
+// src/client/transport/ws-inbound.ts
+function routeServerMessage(raw, sinks) {
+  let msg;
+  try {
+    msg = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  switch (msg.type) {
+    case "result":
+      sinks.pending.resolve(msg.id, msg.data);
+      return;
+    case "subscribed": {
+      const sub = sinks.subscriptions.get(msg.id);
+      if (sub) applySubscribedMessage(sub, msg);
+      sinks.live.deliverSubscribed(msg.id, msg.rows ?? []);
+      sinks.pending.resolve(msg.id, void 0);
+      return;
+    }
+    case "error": {
+      const failure = new RemoteError(msg.error.code, msg.error.message);
+      if (!sinks.pending.reject(msg.id, failure)) sinks.live.fail(msg.id, failure);
+      return;
+    }
+    case "change": {
+      const sub = sinks.subscriptions.get(msg.id);
+      if (sub) deliverChangeMessage(sub, msg);
+      return;
+    }
+    case "changes": {
+      const sub = sinks.subscriptions.get(msg.id);
+      if (sub) deliverChangesMessage(sub, msg);
+      return;
+    }
+    case "live":
+      sinks.live.deliver(msg.id, msg);
+      return;
+    case "unsubscribed":
+      return;
+  }
+}
+
+// src/client/transport/ws-live-state.ts
+var LiveQueryRegistry = class {
+  constructor(port) {
+    this.port = port;
+  }
+  queries = /* @__PURE__ */ new Map();
+  get size() {
+    return this.queries.size;
+  }
+  async open(id, name, args, handlers, digest) {
+    const live = { name, args, handlers, digest, established: false };
+    this.queries.set(id, live);
+    try {
+      await this.send(id, live);
+    } catch (err) {
+      this.queries.delete(id);
+      throw err;
+    }
+    return {
+      unsubscribe: () => {
+        this.queries.delete(id);
+        this.port.sendUnsubscribe(id);
+      }
+    };
+  }
+  deliverSubscribed(id, rows) {
+    this.queries.get(id)?.handlers.onRows(decodeLiveRows(rows));
+  }
+  deliver(id, message) {
+    const live = this.queries.get(id);
+    if (live !== void 0) deliverLiveMessage(live, message);
+  }
+  fail(id, error) {
+    this.queries.get(id)?.handlers.onError(error);
+  }
+  markDisconnected() {
+    for (const live of this.queries.values()) {
+      live.established = false;
+      live.handlers.onRevalidating();
+    }
+  }
+  clear() {
+    this.queries.clear();
+  }
+  async restart() {
+    let unreachable = null;
+    for (const [id, live] of [...this.queries.entries()]) {
+      if (this.port.isClosed() || live.established) continue;
+      try {
+        await this.send(id, live);
+      } catch (err) {
+        const failure = err instanceof RemoteError ? err : new RemoteError("CONNECTION_ERROR", "The live query could not restart");
+        if (failure.code === "CONNECTION_ERROR" || failure.code === "TIMEOUT") {
+          unreachable = failure;
+          continue;
+        }
+        this.queries.delete(id);
+        live.handlers.onError(failure);
+      }
+    }
+    if (unreachable !== null && !this.port.isClosed()) throw unreachable;
+  }
+  async send(id, live) {
+    const digest = await live.digest?.(false);
+    try {
+      await this.port.request(liveSubscribeMessage(id, live, digest));
+    } catch (err) {
+      if (!(err instanceof RemoteError) || err.code !== "REGISTRY_MISMATCH" || live.digest === void 0) {
+        throw err;
+      }
+      await this.port.request(liveSubscribeMessage(id, live, await live.digest(true)));
+    }
+    live.established = true;
+  }
+};
+function liveSubscribeMessage(id, live, registryDigest) {
+  return {
+    type: "subscribe",
+    id,
+    name: live.name,
+    ...live.args === void 0 ? {} : { args: encodeTaggedValues(live.args) },
+    ...registryDigest === void 0 ? {} : { registryDigest }
+  };
+}
+function decodeLiveRows(rows) {
+  return decodeTaggedValues(rows);
+}
+function deliverLiveMessage(live, msg) {
+  if (msg.rows !== void 0) {
+    live.handlers.onRows(decodeLiveRows(msg.rows));
+    return;
+  }
+  if (msg.ops !== void 0) {
+    live.handlers.onOps(msg.ops.map(decodeLiveOp));
+    return;
+  }
+  if (msg.revalidating === true) {
+    live.handlers.onRevalidating();
+    return;
+  }
+  live.handlers.onError(new RemoteError("INVALID_RESPONSE", "A live message carried no rows, operations, or status"));
+}
+function decodeLiveOp(op) {
+  if (op.op === "delete") return { op: "delete", index: op.index };
+  return { op: op.op, index: op.index, row: decodeTaggedValues(op.row) };
+}
+
+// src/client/transport/ws-pending.ts
+var PendingRequests = class {
+  constructor(timeoutMs) {
+    this.timeoutMs = timeoutMs;
+  }
+  requests = /* @__PURE__ */ new Map();
+  start(id, send) {
+    return new Promise((resolve, reject) => {
+      const timer = this.timeoutMs > 0 ? setTimeout(() => {
+        this.requests.delete(id);
+        reject(new RemoteError("TIMEOUT", `Request timed out after ${this.timeoutMs}ms`));
+      }, this.timeoutMs) : void 0;
+      this.requests.set(id, { resolve, reject, timer });
+      send();
+    });
+  }
+  resolve(id, value) {
+    const pending = this.take(id);
+    if (pending === void 0) return false;
+    pending.resolve(value);
+    return true;
+  }
+  reject(id, error) {
+    const pending = this.take(id);
+    if (pending === void 0) return false;
+    pending.reject(error);
+    return true;
+  }
+  rejectAll(error) {
+    for (const [, pending] of this.requests) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.requests.clear();
+  }
+  take(id) {
+    const pending = this.requests.get(id);
+    if (pending === void 0) return void 0;
+    clearTimeout(pending.timer);
+    this.requests.delete(id);
+    return pending;
+  }
+};
+
+// src/client/transport/ws.ts
+var DEFAULT_REQUEST_TIMEOUT = 3e4;
+var WebSocketTransport = class {
+  carriesReadConcern = true;
+  ws = null;
+  url;
+  autoReconnect;
+  reconnectInterval;
+  requestTimeout;
+  protocols;
+  headers;
+  refusal = null;
+  pending;
+  activeSubscriptions = /* @__PURE__ */ new Map();
+  liveQueries = new LiveQueryRegistry({
+    request: (message) => this.request(message),
+    sendUnsubscribe: (id) => this.sendUnsubscribe(id),
+    isClosed: () => this.closed
+  });
+  idCounter = 0;
+  closed = false;
+  connectPromise = null;
+  reconnectTimer = null;
+  constructor(url, options) {
+    this.url = url;
+    this.autoReconnect = options?.autoReconnect ?? true;
+    this.reconnectInterval = options?.reconnectInterval ?? 1e3;
+    this.requestTimeout = options?.requestTimeout ?? DEFAULT_REQUEST_TIMEOUT;
+    this.protocols = withSirannonSubprotocol(options?.protocols);
+    this.headers = options?.headers;
+    this.pending = new PendingRequests(this.requestTimeout);
+  }
+  async query(sql, params, readConcern) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    const response = await this.request({
+      type: "query",
+      id,
+      sql,
+      params: encodeTaggedValues(params),
+      ...readConcern ? { readConcern } : {}
+    });
+    return { rows: decodeTaggedValues(response.rows ?? []) };
+  }
+  async execute(sql, params) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({
+      type: "execute",
+      id,
+      sql,
+      params: encodeTaggedValues(params)
+    });
+  }
+  async transaction(statements) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({
+      type: "transaction",
+      id,
+      statements: statements.map((stmt) => ({
+        sql: stmt.sql,
+        params: encodeTaggedValues(stmt.params)
+      }))
+    });
+  }
+  async batch(sql, paramsBatch, writeConcern) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({
+      type: "batch",
+      id,
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      ...writeConcern ? { writeConcern } : {}
+    });
+  }
+  async load(sql, paramsBatch, durability, checkpoint) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({
+      type: "load",
+      id,
+      sql,
+      paramsBatch: paramsBatch.map((entry) => encodeTaggedValues(entry)),
+      ...durability ? { durability } : {},
+      ...checkpoint !== void 0 ? { checkpoint } : {}
+    });
+  }
+  async queryNamed(name, args, readConcern) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    const response = await this.request({
+      type: "query",
+      id,
+      name,
+      ...args === void 0 ? {} : { args: encodeTaggedValues(args) },
+      ...readConcern ? { readConcern } : {}
+    });
+    return { rows: decodeTaggedValues(response.rows ?? []) };
+  }
+  async executeNamed(name, args, writeConcern) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({
+      type: "execute",
+      id,
+      name,
+      ...args === void 0 ? {} : { args: encodeTaggedValues(args) },
+      ...writeConcern ? { writeConcern } : {}
+    });
+  }
+  async liveSubscribe(name, args, handlers, registryDigest) {
+    await this.ensureConnected();
+    return this.liveQueries.open(this.nextId(), name, args, handlers, registryDigest);
+  }
+  async subscribe(table, filter, callback, options) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    this.activeSubscriptions.set(id, {
+      table,
+      filter,
+      callback,
+      onReset: options?.onReset,
+      onSubscribed: options?.onSubscribed,
+      deviceId: options?.deviceId,
+      tables: options?.tables,
+      schemaVersion: options?.schemaVersion,
+      lastSeq: options?.sinceSeq,
+      resumeSeq: options?.getResumeSeq,
+      epoch: options?.epoch,
+      stagedStream: options?.stagedStream
+    });
+    try {
+      const msg = {
+        type: "subscribe",
+        id,
+        table,
+        ...filter ? { filter: encodeTaggedValues(filter) } : {},
+        ...options?.tables !== void 0 ? { tables: [...options.tables] } : {},
+        ...options?.sinceSeq !== void 0 ? { sinceSeq: options.sinceSeq.toString() } : {},
+        ...options?.epoch !== void 0 ? { epoch: options.epoch } : {},
+        ...options?.deviceId !== void 0 ? { deviceId: options.deviceId } : {},
+        ...options?.schemaVersion !== void 0 ? { schemaVersion: options.schemaVersion } : {},
+        ...options?.stagedStream === true ? { stagedStream: true } : {}
+      };
+      await this.request(msg);
+    } catch (err) {
+      this.activeSubscriptions.delete(id);
+      throw err;
+    }
+    return {
+      unsubscribe: () => {
+        this.activeSubscriptions.delete(id);
+        this.sendUnsubscribe(id);
+      }
+    };
+  }
+  sendUnsubscribe(id) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify({ type: "unsubscribe", id }));
+    }
+  }
+  async ack(deviceId, seq) {
+    await this.ensureConnected();
+    const id = this.nextId();
+    return this.request({ type: "ack", id, deviceId, seq: seq.toString() });
+  }
+  close() {
+    this.closed = true;
+    this.cancelReconnect();
+    this.pending.rejectAll(new RemoteError("TRANSPORT_ERROR", "Transport closed"));
+    this.activeSubscriptions.clear();
+    this.liveQueries.clear();
+    if (this.ws) {
+      this.ws.close(1e3, "Client closed");
+      this.ws = null;
+    }
+    this.connectPromise = null;
+  }
+  nextId() {
+    return `c_${++this.idCounter}_${Date.now()}`;
+  }
+  async ensureConnected() {
+    if (this.closed) {
+      throw new RemoteError("TRANSPORT_ERROR", "Transport is closed");
+    }
+    if (this.refusal) {
+      throw this.refusal;
+    }
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      return;
+    }
+    if (!this.connectPromise) {
+      this.connectPromise = this.connect().finally(() => {
+        this.connectPromise = null;
+      });
+    }
+    return this.connectPromise;
+  }
+  connect() {
+    return openWebSocket(
+      this.url,
+      { protocols: this.protocols, headers: this.headers },
+      {
+        onConnected: (ws) => {
+          this.ws = ws;
+        },
+        onRefused: (error) => {
+          this.refusal = error;
+        },
+        onDisconnected: () => {
+          this.ws = null;
+          this.handleDisconnect();
+        },
+        onMessage: (raw) => routeServerMessage(raw, {
+          pending: this.pending,
+          subscriptions: this.activeSubscriptions,
+          live: this.liveQueries
+        })
+      }
+    );
+  }
+  handleDisconnect() {
+    this.pending.rejectAll(this.refusal ?? new RemoteError("CONNECTION_ERROR", "WebSocket disconnected"));
+    this.liveQueries.markDisconnected();
+    const restorable = this.activeSubscriptions.size + this.liveQueries.size;
+    if (this.autoReconnect && !this.closed && this.refusal === null && restorable > 0) {
+      this.scheduleReconnect();
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer !== null || this.closed) {
+      return;
+    }
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      if (this.closed) return;
+      try {
+        await this.ensureConnected();
+        await this.resubscribeAll();
+      } catch {
+        if (!this.closed && this.refusal === null && this.activeSubscriptions.size + this.liveQueries.size > 0) {
+          this.scheduleReconnect();
+        }
+      }
+    }, this.reconnectInterval);
+  }
+  async resubscribeAll() {
+    const entries = [...this.activeSubscriptions.entries()];
+    for (const [id, sub] of entries) {
+      if (this.closed) break;
+      try {
+        await this.request(buildResubscribeMessage(id, sub));
+      } catch {
+        this.activeSubscriptions.delete(id);
+      }
+    }
+    await this.liveQueries.restart();
+  }
+  request(msg) {
+    if (this.refusal) {
+      return Promise.reject(this.refusal);
+    }
+    const socket = this.ws;
+    if (!socket || socket.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new RemoteError("CONNECTION_ERROR", "WebSocket is not connected"));
+    }
+    return this.pending.start(msg.id, () => socket.send(JSON.stringify(msg)));
+  }
+  cancelReconnect() {
+    if (this.reconnectTimer !== null) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// src/client/client-base.ts
+function resolveTransportSettings(options) {
+  const transport = options?.transport ?? "websocket";
+  if (transport === "websocket") {
+    assertHandshakeHeadersSupported(options?.headers, options?.webSocketProtocols);
+  }
+  return {
+    transport,
+    headers: options?.headers,
+    webSocketProtocols: options?.webSocketProtocols,
+    autoReconnect: options?.autoReconnect ?? true,
+    reconnectInterval: options?.reconnectInterval ?? 1e3,
+    requestTimeout: options?.requestTimeout
+  };
+}
+function createEndpointTransport(settings, baseUrl, databaseId) {
+  const base = toBaseUrl(baseUrl);
+  const encodedId = encodeURIComponent(databaseId);
+  if (settings.transport === "http") {
+    return new HttpTransport(`${base}/db/${encodedId}`, settings.headers);
+  }
+  return new WebSocketTransport(`${toWsUrl(base)}/db/${encodedId}`, {
+    autoReconnect: settings.autoReconnect,
+    reconnectInterval: settings.reconnectInterval,
+    protocols: settings.webSocketProtocols,
+    headers: settings.headers,
+    requestTimeout: settings.requestTimeout
+  });
+}
+var DatabaseClient = class {
+  settings;
+  databases = /* @__PURE__ */ new Map();
+  closed = false;
+  constructor(options) {
+    this.settings = resolveTransportSettings(options);
+  }
+  database(id) {
+    if (this.closed) {
+      throw new Error("Client is closed");
+    }
+    const existing = this.databases.get(id);
+    if (existing) {
+      return existing;
+    }
+    const db = new RemoteDatabase(id, this.createTransport(id), this.createCapabilities(id), () => {
+      this.databases.delete(id);
+    });
+    this.databases.set(id, db);
+    return db;
+  }
+  createCapabilities(databaseId) {
+    const timeout = this.settings.requestTimeout;
+    return new ServerCapabilities(
+      () => this.resolveServerUrl(databaseId),
+      this.settings.headers,
+      timeout !== void 0 && timeout > 0 ? timeout : DEFAULT_HTTP_REQUEST_TIMEOUT_MS
+    );
+  }
+  close() {
+    this.closed = true;
+    const openDatabases = [...this.databases.values()];
+    this.databases.clear();
+    for (const db of openDatabases) {
+      db.close();
+    }
+  }
+};
+
+export { DEFAULT_HTTP_REQUEST_TIMEOUT_MS, DatabaseClient, HttpTransport, RemoteDatabase, RemoteError, RemoteLiveQuery, RemoteSubscriptionBuilderImpl, SQL_REFUSED_MESSAGE, STAGED_STREAM_CAPABILITY, ServerCapabilities, WebSocketTransport, createEndpointTransport, decodeTaggedValues, encodeTaggedValues, postJson, toBaseUrl, toServerBaseUrl, toWsUrl, unrefTimer, verifyDeviceSyncCapabilities };