@delali/sirannon-db 0.3.4-next.62 → 0.3.4

package/dist/client/topology.mjs

@@ -1,4 +1,4 @@
-import { DatabaseClient, toBaseUrl, createEndpointTransport, RemoteError, toServerBaseUrl, unrefTimer } from '../chunk-6IYS4WLH.mjs';
+import { DatabaseClient, toBaseUrl, createEndpointTransport, RemoteError, toServerBaseUrl, unrefTimer } from '../chunk-VO3ZWA2G.mjs';
 import '../chunk-3LXXH3RA.mjs';
 
 // src/client/cluster-routing.ts
@@ -370,6 +370,9 @@ function toSubscriptionRoutingError(err, databaseId) {
 }
 
 // src/client/topology-transport.ts
+function isEndpointUnreachable(err) {
+  return err instanceof Error && (err.name !== "RemoteError" || err.code === "CONNECTION_ERROR");
+}
 var TopologyAwareTransport = class {
   constructor(databaseId, routing, onClose) {
     this.databaseId = databaseId;
@@ -386,33 +389,41 @@ var TopologyAwareTransport = class {
   currentReadUrl = "";
   currentWriteUrl = "";
   async query(sql, params) {
+    return this.onReadTransport((transport, level) => transport.query(sql, params, level ? { level } : void 0));
+  }
+  async onReadTransport(read) {
     const readConcern = this.routing._getReadConcern();
     const transport = await this.getReadTransport(readConcern);
     const endpointUsed = this.currentReadUrl;
     try {
-      return await transport.query(sql, params, readConcern ? { level: readConcern } : void 0);
+      return await read(transport, readConcern);
     } catch (err) {
+      const unreachable = isEndpointUnreachable(err);
       if (this.routing._usesCoordinatorDiscovery() && shouldRefreshRouting(err)) {
+        if (unreachable && endpointUsed) {
+          this.routing._setEndpointAside(endpointUsed);
+        }
         await this.routing._refreshClusterRouting(this.databaseId);
-        this.readTransport = null;
-        this.currentReadUrl = "";
+        this.clearReadTransport();
         const refreshed = await this.getReadTransport(readConcern);
-        return refreshed.query(sql, params, readConcern ? { level: readConcern } : void 0);
+        return read(refreshed, readConcern);
       }
-      const isTransportError = err instanceof Error && (err.name !== "RemoteError" || err.code === "CONNECTION_ERROR");
       const writeEndpoint = await this.routing._getWriteEndpoint(this.databaseId);
-      if (isTransportError && endpointUsed && endpointUsed !== writeEndpoint) {
-        this.routing._removeReplica(endpointUsed);
+      if (unreachable && endpointUsed && endpointUsed !== writeEndpoint) {
+        this.routing._setEndpointAside(endpointUsed);
         if (this.currentReadUrl === endpointUsed) {
-          this.readTransport = null;
-          this.currentReadUrl = "";
+          this.clearReadTransport();
         }
         const fallback = await this.getReadTransport();
-        return fallback.query(sql, params);
+        return read(fallback, void 0);
       }
       throw err;
     }
   }
+  clearReadTransport() {
+    this.readTransport = null;
+    this.currentReadUrl = "";
+  }
   async execute(sql, params) {
     return this.onWriteTransport((transport) => transport.execute(sql, params));
   }
@@ -439,9 +450,7 @@ var TopologyAwareTransport = class {
     }
   }
   async queryNamed(name, args) {
-    const readConcern = this.routing._getReadConcern();
-    const transport = await this.getReadTransport(readConcern);
-    return transport.queryNamed(name, args, readConcern ? { level: readConcern } : void 0);
+    return this.onReadTransport((transport, level) => transport.queryNamed(name, args, level ? { level } : void 0));
   }
   async executeNamed(name, args, writeConcern) {
     return this.onWriteTransport((transport) => transport.executeNamed(name, args, writeConcern));
@@ -541,6 +550,7 @@ var TopologyAwareTransport = class {
 // src/client/topology.ts
 var CLUSTER_DISCOVERY_FETCH_TIMEOUT_MS = 2e3;
 var LATENCY_TTL_MS = 6e4;
+var UNREACHABLE_ENDPOINT_TTL_MS = 5e3;
 var LATENCY_PROBE_TIMEOUT_MS = 5e3;
 var TopologyAwareClient = class extends DatabaseClient {
   baseUrl;
@@ -555,7 +565,7 @@ var TopologyAwareClient = class extends DatabaseClient {
   latencies = [];
   latencyMeasuredAt = 0;
   latencyMeasuring = null;
-  removedReplicas = /* @__PURE__ */ new Set();
+  endpointsSetAside = /* @__PURE__ */ new Map();
   constructor(options) {
     super(options);
     this.primaryUrl = options.primary ? toBaseUrl(options.primary) : void 0;
@@ -567,10 +577,10 @@ var TopologyAwareClient = class extends DatabaseClient {
     this.baseUrl = this.primaryUrl ?? this.replicaUrls[0] ?? this.starterEndpoints[0] ?? "";
   }
   /**
-   * Builds the routing transport a database's requests travel over.
+   * Builds the routing transport that sends one database's requests.
    *
    * @param databaseId - Identifier of the database.
-   * @returns A transport that picks a node per request.
+   * @returns A transport that picks a node for each request.
    */
   createTransport(databaseId) {
     const transport = new TopologyAwareTransport(
@@ -586,7 +596,7 @@ var TopologyAwareClient = class extends DatabaseClient {
     return createEndpointTransport(this.settings, url, databaseId);
   }
   /**
-   * Returns the address writes are sent to, which is the current primary.
+   * Returns the address that the client sends writes to, which is the current primary.
    *
    * @param databaseId - Identifier of the database.
    * @returns Address of the node that accepts writes.
@@ -602,7 +612,7 @@ var TopologyAwareClient = class extends DatabaseClient {
     if (this.readPreference === "primary") {
       return this.primaryUrl ?? this.baseUrl;
     }
-    const availableReplicas = this.replicaUrls.filter((url) => !this.removedReplicas.has(url));
+    const availableReplicas = this.replicaUrls.filter((url) => this.isReachable(url));
     if (this.readPreference === "replica") {
       if (availableReplicas.length === 0) {
         return this.primaryUrl ?? this.baseUrl;
@@ -610,7 +620,7 @@ var TopologyAwareClient = class extends DatabaseClient {
       return availableReplicas[Math.floor(Math.random() * availableReplicas.length)];
     }
     await this.ensureLatencyMeasured();
-    const reachable = this.latencies.filter((entry) => entry.reachable && !this.removedReplicas.has(entry.url));
+    const reachable = this.latencies.filter((entry) => entry.reachable && this.isReachable(entry.url));
     if (reachable.length === 0) {
       return this.primaryUrl ?? this.baseUrl;
     }
@@ -624,7 +634,9 @@ var TopologyAwareClient = class extends DatabaseClient {
       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 readable = routing.readEndpoints.filter(
+      (endpoint) => endpoint.readConcerns.includes(concern) && this.isReachable(endpoint.url)
+    );
     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") {
@@ -657,8 +669,15 @@ var TopologyAwareClient = class extends DatabaseClient {
     return this.discovery === "coordinator";
   }
   /** @internal */
-  _removeReplica(url) {
-    this.removedReplicas.add(url);
+  _setEndpointAside(url) {
+    this.endpointsSetAside.set(url, Date.now() + UNREACHABLE_ENDPOINT_TTL_MS);
+  }
+  isReachable(url) {
+    const usableFrom = this.endpointsSetAside.get(url);
+    if (usableFrom === void 0) return true;
+    if (Date.now() < usableFrom) return false;
+    this.endpointsSetAside.delete(url);
+    return true;
   }
   /** @internal */
   async _refreshClusterRouting(databaseId) {

package/dist/client-base-BxTocU1x.d.ts

@@ -0,0 +1,398 @@
+import { B as BulkLoadDurability, a as BulkLoadResult, C as ClientOptions } from './server-options-aYtCkefX.js';
+import { R as ResultOp, L as LiveQueryOptions, a as LiveQuery } from './types-CEJG0eFS.js';
+import { O as OperationRef, b as OperationArguments } from './operation-registry-CGhNT-Sn.js';
+import { P as Params, R as ReadConcern, W as WriteConcern, C as ChangeEvent, Q as QueryOptions } from './query-types-5B02ixH0.js';
+import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse } from './protocol-DFpNNsIT.js';
+
+/**
+ * The message that the client throws when the server accepts no SQL over the network.
+ *
+ * @internal
+ */
+declare const 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.";
+/**
+ * The capability checks that the client performs before a remote database sends a statement.
+ *
+ * @public
+ */
+interface ServerCapabilityCheck {
+    /** Throws unless the server announces that it accepts SQL over the network, so the client sends SQL only to a server that accepts it. */
+    assertSqlAccepted(): Promise<void>;
+    /** Returns the digest of the server's operation registry, or `undefined` when the server announces none. */
+    registryDigest(refresh?: boolean): Promise<string | undefined>;
+}
+/**
+ * Fetches and caches the capability report that a server announces.
+ *
+ * @internal
+ */
+declare class ServerCapabilities implements ServerCapabilityCheck {
+    private readonly resolveUrl;
+    private readonly headers;
+    private readonly requestTimeoutMs;
+    private pending;
+    constructor(resolveUrl: () => string | Promise<string>, headers: Record<string, string> | undefined, requestTimeoutMs?: number);
+    private read;
+    registryDigest(refresh?: boolean): Promise<string | undefined>;
+    assertSqlAccepted(): Promise<void>;
+    private fetch;
+}
+
+/** Optional behaviours for a CDC subscription.
+ * @public
+ */
+interface SubscribeOptions {
+    /**
+     * Receives the error when the change callback, `onReset`, or `onSubscribed` throws or
+     * rejects, and the error for a change frame that the client cannot decode. The subscription
+     * does not await a callback, so this handler receives both a throw and a rejection.
+     * Sirannon discards any error that this handler throws itself.
+     */
+    onError?: (error: Error) => void;
+    /**
+     * Called when the server answers a subscribe with `resync: true` and skips the replay,
+     * because the changes after the resume point are older than the history that it
+     * retains, the resume cursor comes from another change-log epoch, or its replay fails.
+     * The subscription continues from the server's current position, so treat any earlier
+     * state as stale and read it again.
+     */
+    onReset?: () => void;
+    /** The identifier of the device that opens this subscription, so that the server can leave that device's own writes out of the stream. */
+    deviceId?: string;
+    /** The tables that one subscription covers, so the client receives a transaction that spans them as one stream in ascending order. */
+    tables?: readonly string[];
+    /** The highest migration version in the device's local database, which the server checks before it accepts the subscription. */
+    schemaVersion?: number;
+    /** Returns the sequence to resume from; the transport calls it again on each reconnect, so that the resume point matches the durable cursor. */
+    getResumeSeq?: () => bigint | undefined;
+    /** The sequence after which the first subscribe resumes. When it is absent, the subscription starts from the server's current position. */
+    sinceSeq?: bigint;
+    /** The change-log epoch of the resume cursor, so that the server answers with a resync when the cursor comes from another database file. */
+    epoch?: string;
+    /**
+     * Set to true when this device stages pulled changes durably and
+     * acknowledges staged sequences, so that the server can pack several events
+     * into each frame and pace the delivery window continuously. Set it only for
+     * a server that announces the `sync.staged-stream` capability.
+     */
+    stagedStream?: boolean;
+    /** Receives the values that the server confirms on subscribe, which are the baseline sequence, the epoch, whether a resync is due, and the delivery window. */
+    onSubscribed?: (info: {
+        seq: bigint | undefined;
+        epoch: string | undefined;
+        resync: boolean;
+        maxUnacknowledgedChanges: number | undefined;
+    }) => void;
+}
+/**
+ * The callbacks through which a transport passes a live query's updates.
+ *
+ * @public
+ */
+interface LiveHandlers<T = Record<string, unknown>> {
+    /** Receives a complete replacement result set. */
+    onRows(rows: T[]): void;
+    /** Receives the individual edits that move the result set to its new state. */
+    onOps(ops: ResultOp<T>[]): void;
+    /** Called when the server starts re-reading the query. */
+    onRevalidating(): void;
+    /** Called when the query fails. */
+    onError(error: RemoteError): void;
+}
+/**
+ * Returns the digest of the server's operation registry, so that the client can detect
+ * a change to the registered operations that a live query uses.
+ *
+ * @public
+ */
+type RegistryDigestSource = (refresh: boolean) => Promise<string | undefined>;
+/**
+ * The connection through which a client sends requests to a sirannon-db server.
+ * Each transport sends requests for one database.
+ *
+ * @public
+ */
+interface Transport {
+    /**
+     * Whether the transport sends a read concern passed to {@link Transport.query} or
+     * {@link Transport.queryNamed} to the server. Topology routing applies the
+     * client-wide setting when it chooses a node, so it leaves this unset, and the
+     * client throws for a per-read concern, so that it sends a read only at the
+     * level that the caller asked for.
+     */
+    readonly carriesReadConcern?: boolean;
+    /** Sends a read and returns its rows. */
+    query(sql: string, params?: Params, readConcern?: ReadConcern): Promise<QueryResponse>;
+    /** Sends one write. */
+    execute(sql: string, params?: Params): Promise<ExecuteResponse>;
+    /** Sends several statements that the server executes in one transaction. */
+    transaction(statements: Array<{
+        sql: string;
+        params?: Params;
+    }>): Promise<TransactionResponse>;
+    /** Sends one statement with many parameter sets, which the server executes in one transaction. */
+    batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<BatchResponse>;
+    /** Sends a bulk load, which the server executes at relaxed durability. */
+    load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<LoadResponse>;
+    /** Executes a registered read by name and returns its rows. */
+    queryNamed(name: string, args?: Record<string, unknown>, readConcern?: ReadConcern): Promise<QueryResponse>;
+    /** Executes a registered write by name. */
+    executeNamed(name: string, args?: Record<string, unknown>, writeConcern?: WriteConcern): Promise<TransactionResponse>;
+    /** Opens a live query on a registered read and passes its updates to the handlers. */
+    liveSubscribe(name: string, args: Record<string, unknown> | undefined, handlers: LiveHandlers, registryDigest?: RegistryDigestSource): Promise<RemoteSubscription>;
+    /** Opens a change subscription on a table. */
+    subscribe(table: string, filter: Record<string, unknown> | undefined, callback: (event: ChangeEvent) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
+    /** Closes the transport and ends every subscription on it. */
+    close(): void;
+}
+/** Handle for an active remote subscription.
+ * @public
+ */
+interface RemoteSubscription {
+    /** Ends the subscription, so the callback receives no further events. */
+    unsubscribe(): void;
+}
+/** Builder for creating remote CDC subscriptions with optional filters.
+ * @public
+ */
+interface RemoteSubscriptionBuilder {
+    /**
+     * Narrows the subscription to rows whose columns equal the given values.
+     *
+     * The subscription reports changes to the set of matching rows. When an update moves
+     * a row into the set, your callback receives an insert with no `oldRow`, and when an
+     * update moves a row out, it receives a delete with the old row in `oldRow` and an
+     * empty `row`. It receives an update that keeps the row in the set as an ordinary
+     * update, and nothing for an update outside the set. These insert and delete events look the
+     * same as real ones, so read `type` as the row entering or leaving the set.
+     *
+     * The subscriber sets this filter, so the subscriber controls which changes the server sends. An
+     * operator who needs to limit which rows a caller can subscribe to checks the table
+     * and the filter in an `onBeforeSubscribe` hook.
+     */
+    filter(conditions: Record<string, unknown>): RemoteSubscriptionBuilder;
+    /**
+     * Starts the subscription and calls your callback with each change.
+     *
+     * The subscription does not await your callback, so two calls to an asynchronous
+     * callback can overlap. When each change has to finish before the next one starts,
+     * chain the work onto one promise. `options.onError` receives both a throw and a
+     * rejection from the callback.
+     *
+     * @typeParam T - The shape of this table's rows, which sets the type of `row` and `oldRow`.
+     * @param callback - Receives each change that matches this subscription.
+     * @param options - The `onError` handler and the device-sync fields.
+     * @returns A handle whose `unsubscribe` ends the subscription.
+     */
+    subscribe<T = Record<string, unknown>>(callback: (event: ChangeEvent<T>) => void, options?: SubscribeOptions): Promise<RemoteSubscription>;
+}
+/**
+ * An error from a sirannon-db server, or from the client when it cannot complete a request.
+ * Its `code` holds the machine-readable code from the server's error response, or a code
+ * that the client sets, such as `TIMEOUT` or `CONNECTION_ERROR`.
+ *
+ * @public
+ */
+declare class RemoteError extends Error {
+    /** The machine-readable error code, from the server's error response or from the client. */
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+
+/** Options for {@link RemoteDatabase.loadAll}.
+ * @public
+ */
+interface LoadAllOptions {
+    /**
+     * The number of rows in each batch that the client sends to the server. Each
+     * batch is one request that must fit under the server's `maxBodyBytes`, so for
+     * wide rows, raise that limit or lower this value. Defaults to 1000.
+     */
+    batchSize?: number;
+    /** The writer's durability level during the load. Defaults to 'off'. */
+    durability?: BulkLoadDurability;
+}
+/**
+ * A handle to one database on a sirannon-db server. Its async methods match
+ * the core `Database` query methods and send each request through the
+ * configured transport.
+ *
+ * @public
+ */
+declare class RemoteDatabase {
+    /**
+     * The identifier of the database on the server.
+     */
+    readonly id: string;
+    private readonly transport;
+    private readonly capabilities;
+    private readonly onDispose?;
+    constructor(
+    /**
+     * The identifier of the database on the server.
+     */
+    id: string, transport: Transport, capabilities: ServerCapabilityCheck, onDispose?: (() => void) | undefined);
+    /**
+     * Sends a read to the server and returns its rows.
+     *
+     * @param sql - The statement to execute, which the client sends only to a server that accepts SQL.
+     * @param params - The values to bind to the statement, by name or by position.
+     * @param options - The read concern for this statement.
+     * @returns The rows that the server returns.
+     */
+    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
+    /**
+     * Executes a registered read by name and returns its rows.
+     *
+     * @param operation - A reference to the registered read, typed with its arguments and rows.
+     * @param args - The arguments that the read takes.
+     * @param options - The read concern for this statement.
+     * @returns The rows that the server returns.
+     */
+    query<Args, Row>(operation: OperationRef<Args, Row>, args: Args, options?: QueryOptions): Promise<Row[]>;
+    private assertReadConcernReaches;
+    /**
+     * Sends one write to the server.
+     *
+     * @param sql - The statement to execute, which the client sends only to a server that accepts SQL.
+     * @param params - The values to bind to the statement, by name or by position.
+     * @returns How many rows changed, and the last inserted row id.
+     */
+    execute(sql: string, params?: Params): Promise<ExecuteResponse>;
+    /**
+     * Executes a registered write by name.
+     *
+     * @param operation - A reference to the registered write, typed with its arguments.
+     * @param args - The arguments that the write takes.
+     * @param writeConcern - The acknowledgements that the server waits for before it confirms the write.
+     * @returns One result for each statement that the operation executes.
+     */
+    execute<Args>(operation: OperationRef<Args, unknown>, args: Args, writeConcern?: WriteConcern): Promise<ExecuteResponse[]>;
+    /**
+     * Opens a live query on a registered read, and keeps its rows current as rows change in the tables that the read selects from.
+     *
+     * @param name - The name of the registered read.
+     * @param args - The arguments that the read takes.
+     * @param options - Options with `onError`, which receives the error when any listener on this query fails.
+     * @returns The live query, which is already subscribed.
+     */
+    live<T = Record<string, unknown>>(name: string, args?: OperationArguments, options?: LiveQueryOptions): Promise<LiveQuery<T>>;
+    /**
+     * Opens a live query on a registered read, and keeps its rows current as rows change in the tables that the read selects from.
+     *
+     * @param operation - A reference to the registered read, typed with its arguments and rows.
+     * @param args - The arguments that the read takes.
+     * @param options - Options with `onError`, which receives the error when any listener on this query fails.
+     * @returns The live query, which is already subscribed.
+     */
+    live<Args, Row>(operation: OperationRef<Args, Row>, args: Args, options?: LiveQueryOptions): Promise<LiveQuery<Row>>;
+    /**
+     * Executes several statements as one atomic transaction and returns one result
+     * per statement.
+     *
+     * The client sends the whole list in one request, and the server commits or
+     * rolls it back as a unit, with no round trip between statements.
+     */
+    transaction(statements: Array<{
+        sql: string;
+        params?: Params;
+    }>): Promise<ExecuteResponse[]>;
+    /**
+     * Executes the same statement once for each parameter set, in one atomic
+     * transaction that commits with one fsync, and returns one result per
+     * parameter set, in order. Use it for a burst of writes with the same shape,
+     * such as an import or a bulk insert, that must all commit or all roll back.
+     */
+    batch(sql: string, paramsBatch: Params[], writeConcern?: WriteConcern): Promise<ExecuteResponse[]>;
+    /**
+     * Loads a whole dataset through one statement in requests of `batchSize` rows,
+     * and asks the server to perform the fsyncing WAL checkpoint once, after the final
+     * batch. The server restores the configured durability after every batch, so an
+     * import that stops partway leaves the writer at its configured level. Use this
+     * in place of {@link RemoteDatabase.load} for anything larger than one request,
+     * because it sets the `checkpoint` flag itself.
+     *
+     * It accepts a synchronous or asynchronous iterable of parameter sets, so rows can
+     * stream from a file or the network while the client holds at most two batches in
+     * memory. It returns the total number of rows loaded and changes applied.
+     *
+     * ```ts
+     * const summary = await db.loadAll(
+     *   'INSERT INTO events (id, payload) VALUES (?, ?)',
+     *   rowStream,
+     *   { batchSize: 5000, durability: 'off' },
+     * )
+     * ```
+     */
+    loadAll(sql: string, rows: Iterable<Params> | AsyncIterable<Params>, options?: LoadAllOptions): Promise<BulkLoadResult>;
+    /**
+     * Loads one batch of rows through one statement, while the server relaxes the
+     * writer's durability for this call and restores it before the call resolves.
+     * For a dataset that spans more than one request, use {@link RemoteDatabase.loadAll},
+     * which sets the `checkpoint` flag itself.
+     *
+     * It returns the total number of rows loaded and changes applied. When you split
+     * a dataset across many `load` calls yourself, pass `checkpoint: false` on every
+     * call except the last, so that the server performs the fsyncing WAL checkpoint once
+     * at the end. The server restores the configured durability after each call.
+     */
+    load(sql: string, paramsBatch: Params[], durability?: BulkLoadDurability, checkpoint?: boolean): Promise<BulkLoadResult>;
+    /**
+     * Returns a builder for a change subscription on one table.
+     * Chain `.filter()` to narrow the events, then call `.subscribe()`
+     * with a callback to start receiving change events.
+     *
+     * ```ts
+     * const sub = await db
+     *   .on('orders')
+     *   .filter({ status: 'pending' })
+     *   .subscribe(event => console.log(event))
+     *
+     * // Later:
+     * sub.unsubscribe()
+     * ```
+     *
+     * @param table - The name of the table.
+     * @returns A builder that you narrow with a filter and then subscribe to.
+     */
+    on(table: string): RemoteSubscriptionBuilder;
+    /**
+     * Closes the transport for this database, so every later call throws.
+     * With the WebSocket transport, it also rejects every pending request.
+     */
+    close(): void;
+}
+
+interface TransportSettings {
+    transport: 'websocket' | 'http';
+    headers: Record<string, string> | undefined;
+    webSocketProtocols: string | string[] | undefined;
+    autoReconnect: boolean;
+    reconnectInterval: number;
+    requestTimeout: number | undefined;
+}
+/**
+ * Opens one database handle per identifier and keeps it, so a later call for the same identifier returns the handle that is already open.
+ */
+declare abstract class DatabaseClient {
+    protected readonly settings: TransportSettings;
+    private readonly databases;
+    private closed;
+    constructor(options?: ClientOptions);
+    /**
+     * Returns the handle that you use to query and write one database, and opens it on the first call for that identifier.
+     *
+     * @param id - The identifier under which the server registered the database.
+     * @returns The database handle, which stays open until the caller closes it.
+     */
+    database(id: string): RemoteDatabase;
+    protected createCapabilities(databaseId: string): ServerCapabilities;
+    /**
+     * Closes every database that this client opened, which closes their transports and stops their subscriptions.
+     */
+    close(): void;
+    protected abstract createTransport(databaseId: string): Transport;
+    protected abstract resolveServerUrl(databaseId: string): string | Promise<string>;
+}
+
+export { DatabaseClient as D, type LiveHandlers as L, type RemoteSubscription as R, type SubscribeOptions as S, type Transport as T, type RemoteSubscriptionBuilder as a, type RegistryDigestSource as b, type LoadAllOptions as c, RemoteDatabase as d, RemoteError as e, SQL_REFUSED_MESSAGE as f, ServerCapabilities as g, type ServerCapabilityCheck as h };

package/dist/client-streams-YKANXMWO.mjs

@@ -0,0 +1,112 @@
+import { claimEndpoint, registerEndpointAbort, noteEndpointReachable, releaseEndpoint, scheduleEndpointRedial } from './chunk-55YRLSM2.mjs';
+import { buildChannelCreds, ReplicationClient } from './chunk-4KASJKKK.mjs';
+import { registerPeer, removePeer } from './chunk-HR7K3GZW.mjs';
+import { fromBatchPayload, fromAckPayload, fromSyncRequestPayload, fromSyncBatchPayload, fromSyncCompletePayload, fromSyncAckPayload } from './chunk-ADNWEHGZ.mjs';
+import './chunk-KU32OT4H.mjs';
+import './chunk-BLMRNSUG.mjs';
+import './chunk-KINDFBQP.mjs';
+
+// src/transport/grpc/client-streams.ts
+function cancelQuietly(stream) {
+  try {
+    stream.cancel();
+  } catch {
+  }
+}
+function connectToEndpoint(t, endpoint) {
+  if (!t.connected) return;
+  if (!claimEndpoint(t, endpoint)) return;
+  const channelCreds = buildChannelCreds(t.options);
+  const clientOpts = {};
+  const client = new ReplicationClient(endpoint, channelCreds, clientOpts);
+  const replicateStream = client.replicate();
+  const syncStream = client.sync();
+  const entry = {
+    client,
+    replicateStream,
+    syncStream
+  };
+  let replicatePeerId = null;
+  let syncPeerId = null;
+  let closed = false;
+  const teardown = () => {
+    if (closed) return;
+    closed = true;
+    releaseEndpoint(t, endpoint);
+    const peerId = replicatePeerId ?? syncPeerId;
+    if (peerId !== null && t.clientPeerStreams.get(peerId) === entry) {
+      t.clientPeerStreams.delete(peerId);
+      removePeer(t.connectedPeers, t.serverPeerStreams, t.peerDisconnectedHandler, peerId);
+    }
+    entry.replicateStream = null;
+    entry.syncStream = null;
+    cancelQuietly(replicateStream);
+    cancelQuietly(syncStream);
+    client.close();
+    scheduleEndpointRedial(t, endpoint, () => {
+      connectToEndpoint(t, endpoint);
+    });
+  };
+  registerEndpointAbort(t, endpoint, teardown);
+  const hello = {
+    nodeId: t.localNodeId,
+    role: t.localRole,
+    groupId: t.localGroupId ?? "",
+    primaryTerm: t.localPrimaryTerm ?? 0n,
+    protocolVersion: t.localProtocolVersion ?? ""
+  };
+  replicateStream.write({ hello });
+  syncStream.write({ hello });
+  replicateStream.on("data", (msg) => {
+    if (replicatePeerId === null) {
+      if (!msg.hello) {
+        teardown();
+        return;
+      }
+      replicatePeerId = msg.hello.nodeId;
+      const peerRole = msg.hello.role;
+      t.clientPeerStreams.set(replicatePeerId, entry);
+      noteEndpointReachable(t, endpoint);
+      registerPeer(t.connectedPeers, t.peerConnectedHandler, replicatePeerId, peerRole, {
+        groupId: msg.hello.groupId || void 0,
+        primaryTerm: msg.hello.primaryTerm === 0n ? void 0 : msg.hello.primaryTerm,
+        protocolVersion: msg.hello.protocolVersion || void 0
+      });
+      return;
+    }
+    if (msg.batch) {
+      t.batchHandler?.(fromBatchPayload(msg.batch), replicatePeerId).catch(() => {
+      });
+    } else if (msg.ack) {
+      t.ackHandler?.(fromAckPayload(msg.ack), replicatePeerId);
+    }
+  });
+  replicateStream.on("end", teardown);
+  replicateStream.on("error", teardown);
+  syncStream.on("data", (msg) => {
+    if (syncPeerId === null) {
+      if (!msg.hello) {
+        teardown();
+        return;
+      }
+      syncPeerId = msg.hello.nodeId;
+      return;
+    }
+    if (msg.syncRequest) {
+      t.syncRequestHandler?.(fromSyncRequestPayload(msg.syncRequest), syncPeerId).catch(() => {
+      });
+    } else if (msg.syncBatch) {
+      t.syncBatchHandler?.(fromSyncBatchPayload(msg.syncBatch), syncPeerId).catch(() => {
+      });
+    } else if (msg.syncComplete) {
+      t.syncCompleteHandler?.(fromSyncCompletePayload(msg.syncComplete), syncPeerId).catch(() => {
+      });
+    } else if (msg.syncAck) {
+      t.syncAckHandler?.(fromSyncAckPayload(msg.syncAck), syncPeerId);
+    }
+  });
+  syncStream.on("end", teardown);
+  syncStream.on("error", teardown);
+}
+
+export { connectToEndpoint };