camusdb 0.6.0 → 0.8.0

package/README.md

@@ -12,6 +12,9 @@ The gRPC transport needs two more packages. Install them only if you use it:
 npm install @grpc/grpc-js @grpc/proto-loader
 ```
 
+Traces and metrics need `@opentelemetry/api`. Install it only if you collect them. See
+[OpenTelemetry](#opentelemetry).
+
 **Requirements**: Node.js 20.19 or later, or 22.12 or later. The package ships as ECMAScript
 modules with TypeScript declarations.
 
@@ -36,8 +39,10 @@ modules with TypeScript declarations.
 - [Databases and branches](#databases-and-branches)
 - [The query result cache](#the-query-result-cache)
 - [Backups](#backups)
+- [Node stats](#node-stats)
 - [Errors](#errors)
 - [Cancellation and deadlines](#cancellation-and-deadlines)
+- [OpenTelemetry](#opentelemetry)
 - [What a client shares](#what-a-client-shares)
 - [Security notes](#security-notes)
 - [Development](#development)
@@ -119,6 +124,7 @@ const b = CamusClient.fromConnectionString('Endpoint=http://localhost:8082;Datab
 | `coalescingDelayMs` | `CoalescingDelay` | No | gRPC only: milliseconds. Default `0`, which is off. |
 | `requestFrames` | `RequestFrames` | No | gRPC only: pack the operations that wait together into one stream message. Default `true`. |
 | `streamDrainTimeoutMs` | `StreamDrainTimeout` | No | gRPC only: milliseconds a rotated-out stream stays open for its transactions. Default `300000`. |
+| `httpVersion` | `HttpVersion` | No | The highest HTTP version for REST calls. Only `1.1` (the default) is accepted. See the note below. |
 | `backupEndpoint` | `BackupEndpoint` | No | The HTTP endpoint for the backup admin API. Required with `grpc`. |
 | `backupTimeoutSeconds` | `BackupTimeout` | No | The backup request timeout in seconds. Default `300`. |
 | `allowInsecureCredentials` | `AllowInsecureCredentials` | No | Waives the refusal to send credentials to a remote plaintext endpoint. |
@@ -127,6 +133,13 @@ const b = CamusClient.fromConnectionString('Endpoint=http://localhost:8082;Datab
 | `routingMaxHintAgeMs` | `RoutingMaxHintAge` | No | The ceiling on how long a learned route is reused. Default `5000`. |
 | `defaultTransactionOptions` | `IsolationLevel`, `TransactionMode`, `Locking` | No | Concurrency defaults for every transaction and autocommit statement. |
 | `int64` | `Int64` | No | `auto` (the default), `number`, or `bigint`. See [Types](#types). |
+| `traceQueryText` | `TraceQueryText` | No | Put the SQL text on the driver's spans as `db.query.text`. Default `false`. See [OpenTelemetry](#opentelemetry). |
+
+**`HttpVersion`.** The .NET driver reads `HttpVersion=1.1|2|3` and can send REST calls over HTTP/2
+or HTTP/3. Node's `fetch` sends HTTP/1.1 only. So this driver accepts `1.1`, and it refuses `2` and
+`3` (also `2.0` and `3.0`) with a `CamusError` when the client is built. Remove the key, or set it
+to `1.1`, in a connection string that you share with a .NET service. Any other value reads as `1.1`,
+as in .NET. The key does not apply to `protocol: 'grpc'`, which always uses HTTP/2.
 
 ### How a connection string is parsed
 
@@ -601,6 +614,63 @@ same transaction, `SELECT currval('…')` returns the value again. The server ac
 where it can count the values before the statement runs, so a `nextval` in a derived table fails
 with `CADB0547`.
 
+### C# extensions: procedures, triggers, and functions
+
+The server can run C# code from an extension assembly as stored procedures, row triggers, and scalar
+functions. The operator deploys the assembly and lists it in the server configuration. The driver
+needs no setup.
+
+Run a procedure with `CALL`. A procedure returns no result set. `execute` reports the number of rows
+that the procedure's SQL changed:
+
+```ts
+const { affectedRows } = await client.execute('CALL transfer(@from, @to, @amount)', {
+  from: 'alice',
+  to: 'bob',
+  amount: 30,
+});
+```
+
+`call` takes the procedure name only. It sends `CALL name(@a, @b, ...)` with the parameters in the
+order of the object's keys, because a procedure takes its arguments by position:
+
+```ts
+await client.call('transfer', { from: 'alice', to: 'bob', amount: 30 });
+// runs CALL transfer(@from, @to, @amount)
+```
+
+- The procedure name must be a plain identifier: a letter or `_`, then letters, digits, or `_`. Any
+  other text throws `TypeError` before the driver sends the call.
+- JavaScript puts a key that is a whole number, such as `'0'`, before the other keys. So give the
+  parameters names.
+- Only input parameters are supported. A procedure has no output parameters and no return value.
+- `query`, `queryOne`, `scalar`, and `queryStream` also send `CALL` to the non-query route. The
+  result has no rows, and `affectedRows` is the changed-row count. On a stream, `affectedRows` is
+  `undefined` for a query.
+- A pipeline accepts `CALL` through `query`, `execute`, and `call`.
+- `CALL` is not prepared. It runs inside the `transaction` option, if there is one, and an error
+  rolls back everything that the procedure wrote.
+- `CALL` needs a superuser in this server version.
+
+`CREATE TRIGGER` and `DROP TRIGGER` go to the DDL route, as other schema statements do:
+
+```ts
+await client.execute(
+  "CREATE TRIGGER audit ON orders AFTER INSERT, UPDATE, DELETE EXTERNAL NAME 'MyCompany.Ext.AuditTrigger'",
+);
+```
+
+An extension function is called in SQL like a built-in function, for example
+`SELECT slugify(title) FROM posts`. `SHOW EXTENSIONS` lists the assemblies that a node loaded. It
+needs a superuser.
+
+The server reports extension errors with `CADB08xx` codes in `CamusError.code`. For example,
+`CADB0822` means that a procedure threw, and `CADB0818` means that a trigger threw. `CADB0817` means
+that this node does not load the trigger's extension, or loads another build of it. The driver does
+not retry `CADB0817`, because the cause is the deployment, not a conflict. The server can run a
+statement again after a serializable conflict, so a trigger or a procedure can run more than once.
+See `docs/csharp-extensions.md` in the server repository for the full rules.
+
 ---
 
 ## Streaming
@@ -693,6 +763,10 @@ await client.transaction(work, {
 - **`locking`** — `Pessimistic` (the default) takes locks up front. `Optimistic` stages the writes
   and detects a conflict only at commit; a losing transaction fails its commit and must be retried.
   It does not protect against phantoms.
+- **`deferBegin`** — `true` sends `BEGIN` with the first statement, and not from
+  `beginTransaction`. When that first statement is a pipeline send, `BEGIN` travels inside the same
+  exchange. With learned routing on, `BEGIN` is deferred already. The transaction identity reads as
+  zero until the first statement, and a failure to begin comes from that statement.
 
 Every knob is optional. A knob left unset falls back to the client's `defaultTransactionOptions`,
 then to the connection-string defaults, then to the server default.
@@ -706,6 +780,63 @@ dead, so the driver re-issues the **same** commit on the **same** handle, backin
 times. It never replays the work from the start, because that could apply an already-durable commit
 a second time. This is handled inside the driver; you do not write it.
 
+### Pipelined transactions
+
+A transaction that awaits each statement pays one round trip for each statement: six for a bank
+transfer (`BEGIN`, two reads, two writes, `COMMIT`). At high concurrency, those round trips set the
+latency, and the statements do not. A pipeline sends the statements whose inputs are known as one
+stream message, and it settles the promise of each statement from its own answer.
+
+```ts
+const txn = await client.beginTransaction({
+  locking: CamusLocking.Optimistic,
+  deferBegin: true, // BEGIN travels inside the first send
+});
+
+const pipeline = txn.pipeline();
+
+// Exchange 1: [BEGIN, SELECT a, SELECT b]
+const readA = pipeline.query<{ balance: number }>('SELECT balance FROM accounts WHERE id = @id', { id: a });
+const readB = pipeline.query<{ balance: number }>('SELECT balance FROM accounts WHERE id = @id', { id: b });
+await pipeline.send();
+
+const fromBalance = (await readA).rows[0]!.balance;
+const toBalance = (await readB).rows[0]!.balance;
+
+// Exchange 2: [UPDATE a, UPDATE b, COMMIT]. The commit happens only if both updates succeed.
+pipeline.execute('UPDATE accounts SET balance = @v WHERE id = @id', { v: fromBalance - amount, id: a });
+pipeline.execute('UPDATE accounts SET balance = @v WHERE id = @id', { v: toBalance + amount, id: b });
+await pipeline.commit();
+
+console.log(`${pipeline.exchanges} round trips`); // 2 over gRPC
+```
+
+- **Results.** `query` returns the promise of a `QueryResult`, and `execute` returns the promise of
+  an `ExecuteResult`, as the client methods do. A write with `RETURNING` in `query` gives its rows
+  and `affectedRows`. `send` and `commit` also reject with the first failure, so a caller that awaits
+  only the send still learns of it. A queued promise that nobody awaits is never reported as an
+  unhandled rejection.
+- **Failure.** The statements after a failed one in the same exchange still get an answer. The
+  transaction has ended, so they fail too, and `commit` rejects with the first failure and does not
+  commit. The server rolled the transaction back, so `rollback` is then a harmless call. To retry,
+  run the whole transaction again from `BEGIN`, as for any failed statement.
+- **Commit.** After a successful `pipeline.commit()`, the transaction is committed. A later
+  `txn.rollback()` does nothing, and a later `txn.commit()` throws. Inside `client.transaction`, the
+  helper sees the pipeline commit and does not commit a second time.
+- **Order.** The queued statements run in queue order, after every statement of the transaction
+  sent before them. A pipeline can be sent more than once on one transaction, and an ordinary
+  statement can run between two sends. One send at a time for each pipeline.
+- **Exchanges.** `pipeline.exchanges` gives the round trips used. Over gRPC, to a server that
+  announces frame contract version 2 or higher, it is one for each send. Over REST, with
+  `requestFrames: false`, or against an older server, the driver runs the same statements one
+  exchange per step, with the same results, and the count shows it. The driver never sends an
+  older server something that it could misread.
+- **Routing.** With learned routing on, a pipelined statement asks for routing advice, and the
+  driver learns the route from its reply, as for a lone statement. So the next deferred transaction
+  begins on the node that the advice names.
+- **What cannot be queued.** DDL, which does not run inside the transaction, and `TRUNCATE`. These
+  throw a `CamusError` at queue time, and the pipeline stays usable.
+
 ---
 
 ## Retries
@@ -845,6 +976,10 @@ frame, and the fixed cost of a message is paid once instead of six times. A fram
 more statements. A lone statement stays a plain single message, and a server that does not announce
 frames never receives one. Set `requestFrames` to `false` to turn frames off.
 
+A whole transaction can travel as one frame too: a pipeline puts the `BEGIN`, the statements, and a
+conditional commit in one stream message. That needs a server that announces frame contract version
+2. See [Pipelined transactions](#pipelined-transactions).
+
 A stream carries its bearer token once, in the metadata it opens with, and gRPC gives no way to
 change it later. The token provider renews the token every few minutes, so a long-lived stream
 outlives the token it presented. Whether a server tolerates that is the server's decision. The
@@ -1066,6 +1201,39 @@ HTTP endpoint; the driver refuses to guess rather than send HTTP at a gRPC port.
 
 ---
 
+## Node stats
+
+`client.nodeStats()` returns the disk, CPU, and memory of one node. It works over REST
+(`GET /v1/admin/stats`) and gRPC (`GetNodeStats`).
+
+```ts
+const stats = await client.nodeStats(); // the next endpoint in the rotation
+const data = stats.dataVolume!; // the volume that holds data_dir
+
+console.log(`${data.availableBytes} bytes free of ${data.totalBytes}`);
+console.log(`writes refused (below min_free_disk_bytes): ${data.belowWatermark}`);
+
+for (const endpoint of client.endpoints) {
+  const node = await client.nodeStats(endpoint); // one call for each node of a cluster
+  console.log(`${node.address}: ${node.cpu.processCpuPercent}% CPU, ${node.memory.hostAvailableBytes} bytes free`);
+}
+```
+
+- **Each node answers for itself.** `address` names the configured endpoint that answered.
+  `nodeStats(endpoint)` accepts only an endpoint from `client.endpoints`, so the client's credentials
+  never go to another address. Any other endpoint throws a `TypeError`.
+- **`-1` means unknown.** A value that the node could not read is `-1`, and `errors` names the field
+  and the reason. One failed probe never fails the call. A value that an older server does not send
+  is `-1` too.
+- **`belowWatermark` is the answer of the write gate.** While it is `true`, writes on that node fail
+  with `CADB0536`.
+- **`MONITOR`, not superuser.** With authentication on, the account needs the superuser attribute or
+  the `MONITOR` privilege: `GRANT MONITOR ON *.* TO monitoring;`. Other accounts get `CADB0517`.
+- **Cheap enough to poll.** The server answers from caches and a background sampler, so one call
+  each minute from several monitors costs nothing measurable.
+
+---
+
 ## Errors
 
 Every database-level failure is a `CamusError` carrying the server's `CADBxxxx` code.
@@ -1117,6 +1285,88 @@ not marked unreachable.
 
 ---
 
+## OpenTelemetry
+
+The driver reports traces and metrics through `@opentelemetry/api`, which is an optional peer
+dependency. Install it, and register an OpenTelemetry SDK as usual. The driver needs no plugin and
+no extra setting:
+
+```shell
+npm install @opentelemetry/api @opentelemetry/sdk-node
+```
+
+```ts
+import { NodeSDK } from '@opentelemetry/sdk-node';
+
+new NodeSDK({ /* exporters */ }).start();
+
+// Every client reports from now on, under the instrumentation scope 'camusdb' (CAMUS_TELEMETRY_NAME).
+```
+
+Without the package, the driver reports nothing and loads nothing for telemetry. The driver loads
+the package with `require` on the first operation, so the first operation is reported too. Register
+the SDK before the first database call.
+
+**Spans.** The driver records one client span for each of these operations:
+
+- A statement: `query` (and so `queryOne`, `scalar`, and `nextSequenceValue`), `queryStream`,
+  `execute`, `executeDdl`, `evictCache`, and `evictAllCache`.
+- A typed insert (`insert`).
+- `BEGIN`, `COMMIT`, and `ROLLBACK`. One `COMMIT` span covers all the retries of an unresolved
+  commit (`CADB0509`), with one `camusdb.retry` event for each retry.
+- A pipeline exchange, as one `BATCH` span with `db.operation.batch.size` and
+  `camusdb.pipeline.commit`.
+
+The span name is `{operation} {target}`, for example `SELECT shop`. The target is the table for a
+typed insert, and the database for all other operations. The span has these attributes from the
+[OpenTelemetry database conventions](https://opentelemetry.io/docs/specs/semconv/database/):
+
+| Attribute | Value |
+| --- | --- |
+| `db.system.name` | `camusdb` |
+| `db.namespace` | The database of the client. |
+| `db.operation.name` | The first keyword of the SQL text, if it is a known verb (`SELECT`, `INSERT`, `UPDATE`, `DELETE`, `CREATE`, `ALTER`, `DROP`, `TRUNCATE`, and others), or `BEGIN`, `COMMIT`, `ROLLBACK`, `BATCH`. |
+| `db.collection.name` | The table of a typed insert. |
+| `server.address`, `server.port` | The endpoint that received the operation, after routing. |
+| `db.query.text` | The SQL text. Only with `traceQueryText: true`. |
+| `error.type`, `db.response.status_code` | The `CADBxxxx` code of a failed operation, or the error name when there is no code. |
+| `camusdb.transport` | `rest` or `grpc`. |
+
+The span is a child of the active span. While the operation runs, the driver span is the active
+span, so the HTTP or gRPC spans of the transport are its children. This needs a context manager,
+which `NodeSDK` registers.
+
+**Duration metric.** The driver records the `db.client.operation.duration` histogram, in seconds,
+for the same operations. Its attributes are `db.system.name`, `db.namespace`, `db.operation.name`,
+`server.address`, `server.port`, `error.type`, and `db.response.status_code`. The SQL text is never
+an attribute.
+
+**Driver metrics.** The same meter also has these metrics:
+
+| Metric | Type | Attributes | What it counts |
+| --- | --- | --- | --- |
+| `camusdb.client.operation.retries` | Counter | `camusdb.retry.kind`, `error.type`, and `db.namespace` and `db.operation.name` when known | Each time the driver sends an operation again. The kinds are `finalize` (a `COMMIT` or `ROLLBACK` after `CADB0509`), `autocommit` (`withRetry`), `transaction` (`client.transaction` from `BEGIN`), `token_renewal` (a call sent again with a new token after `CADB0516`), and `create_database`. When a driver span is active, the retry is also a `camusdb.retry` event on it. |
+| `camusdb.client.endpoint.quarantines` | Counter | `server.address`, `server.port` | Each time an endpoint fails at the transport level and the driver sets it aside for 30 seconds. |
+| `camusdb.client.endpoint.quarantined` | Gauge | `server.address`, `server.port` | `1` while the endpoint is set aside, `0` while it takes traffic. |
+| `camusdb.client.prepared_statement.lookups` | Counter | `db.namespace`, `camusdb.prepared_statement.result` | Each execution of a preparable statement: `hit` (already prepared), `registered` (prepared by this execution), or `miss` (sent as SQL text). |
+| `camusdb.client.prepared_statement.registrations` | Counter | `db.namespace`, `camusdb.prepared_statement.result`, `error.type` | Each request to prepare a statement that got an answer: `success`, `refused` (the statement runs as SQL text from then on), or `unsupported` (the server has no prepared statements, so automatic preparation stops). |
+| `camusdb.client.prepared_statement.evictions` | Counter | `db.namespace` | Each prepared statement released to make room for one used more recently. See `maxAutoPrepare`. |
+| `camusdb.client.prepared_statement.count` | UpDownCounter | `db.namespace` | The statements kept prepared now. |
+
+If `count` stays at `maxAutoPrepare` and `evictions` keeps growing, `maxAutoPrepare` is too small
+for the workload.
+
+- **The SQL text is opt-in.** SQL text with literal values can contain sensitive data, so set
+  `traceQueryText: true` (or `TraceQueryText=true`) to record it. The driver never records
+  parameter values.
+- **A stream ends its span at the last row.** For `queryStream`, the span ends when the iteration
+  reaches the last row, when a read fails, or when the stream is closed.
+- **A provider registered later.** The metrics API has no proxy provider, so the driver makes its
+  instruments again when the global meter provider changes. Spans go through the proxy tracer of the
+  API, so a tracer provider registered later gets them too.
+
+---
+
 ## What a client shares
 
 A client holds no socket of its own. Four kinds of state are shared process-wide, keyed by what

package/dist/client.d.ts

@@ -7,6 +7,7 @@
 import { CamusBackupClient } from './backup.js';
 import type { CamusCacheMetadata } from './cache.js';
 import type { CamusClientOptions, CamusProtocol, ResolvedConfig } from './config.js';
+import type { CamusNodeStats } from './node-stats.js';
 import type { CamusTransactionOptions } from './options.js';
 import { CamusQueryStream } from './query-stream.js';
 import type { CamusColumn } from './result-set.js';
@@ -169,8 +170,12 @@ export declare class CamusClient implements AsyncDisposable {
      * All the `RETURNING` rows arrive in one reply. On gRPC the server refuses a reply larger than
      * 4 MiB with `CADB0550`, before the commit, so the statement stores nothing. Use `queryStream` for
      * a large result, such as an `INSERT … SELECT … RETURNING` or an `UPDATE` of many rows.
+     *
+     * A `CALL` goes to the non-query route, because the server runs a procedure only there. The
+     * result has no rows, and `affectedRows` is the number of rows that the procedure's SQL changed.
      */
     query<T = Record<string, unknown>>(sql: string, parameters?: Parameters, options?: AutocommitStatementOptions): Promise<QueryResult<T>>;
+    private runQuery;
     /**
      * Runs a `SELECT` and reads its first row, or `undefined` when it returned none. It accepts an
      * `INSERT`, `UPDATE`, or `DELETE` with `RETURNING` as `query` does.
@@ -218,8 +223,13 @@ export declare class CamusClient implements AsyncDisposable {
      * the same streaming query endpoint. Use this method for a `RETURNING` result that is too large
      * for `query`. The server sends no row before the commit, so a conflict never surfaces mid-read
      * for it. The stream reports no written-row count, so count the rows as you read them.
+     *
+     * A `CALL` goes to the non-query route, because the server runs a procedure only there. The
+     * procedure runs before this returns. The stream has no rows, and `affectedRows` is the number of
+     * rows that the procedure's SQL changed.
      */
     queryStream<T = Record<string, unknown>>(sql: string, parameters?: Parameters, options?: AutocommitStatementOptions): Promise<CamusQueryStream<T>>;
+    private openQueryStream;
     /**
      * Runs an `INSERT`, `UPDATE`, or `DELETE` and reports how many rows it changed.
      *
@@ -237,6 +247,25 @@ export declare class CamusClient implements AsyncDisposable {
      * To read the rows, use `query`, `queryOne`, `scalar`, or `queryStream`.
      */
     execute(sql: string, parameters?: Parameters, options?: AutocommitStatementOptions): Promise<ExecuteResult>;
+    /**
+     * Runs a procedure that a C# extension on the server defines, and reports how many rows the
+     * procedure's SQL changed.
+     *
+     * ```ts
+     * const { affectedRows } = await client.call('transfer', { from: 'alice', to: 'bob', amount: 30 });
+     * // runs CALL transfer(@from, @to, @amount)
+     * ```
+     *
+     * It sends `CALL procedure(@a, @b, ...)` with the parameters in the order of the object's keys,
+     * because a procedure takes its arguments by position. A procedure has no output parameters and
+     * no return value. The same statement as text also runs through `execute`, `query`, and
+     * `queryStream`. A `CALL` is not prepared, and it runs inside `options.transaction` when one is
+     * given.
+     *
+     * @throws {TypeError} when `procedure` is not a plain identifier: a letter or `_`, then letters,
+     * digits, or `_`. The driver sends nothing.
+     */
+    call(procedure: string, parameters?: Parameters, options?: AutocommitStatementOptions): Promise<ExecuteResult>;
     /**
      * Runs a schema statement: `CREATE TABLE`, `ALTER TABLE`, `DROP INDEX`, a view definition, and
      * so on.
@@ -246,6 +275,7 @@ export declare class CamusClient implements AsyncDisposable {
      * deliver, and the driver refuses it before the round trip.
      */
     executeDdl(sql: string, options?: AutocommitStatementOptions): Promise<boolean>;
+    private runDdl;
     /**
      * Inserts one row through the server's typed row-level route, naming a table and a column-to-value
      * map instead of composing SQL.
@@ -258,6 +288,38 @@ export declare class CamusClient implements AsyncDisposable {
      * health, and error translation. Use it to avoid building statement text for a hot write path.
      */
     insert(table: string, values: Parameters, options?: StatementOptions): Promise<number>;
+    /** The endpoints that this client is configured with, in configuration order. */
+    get endpoints(): readonly string[];
+    /**
+     * The disk, CPU, and memory of one node. See `CamusNodeStats` for every field.
+     *
+     * ```ts
+     * const stats = await client.nodeStats();
+     * const data = stats.dataVolume!;
+     *
+     * console.log(`${data.availableBytes} bytes free of ${data.totalBytes}`);
+     *
+     * for (const endpoint of client.endpoints) {
+     *   const node = await client.nodeStats(endpoint);
+     *   console.log(`${node.address}: ${node.cpu.processCpuPercent}% CPU`);
+     * }
+     * ```
+     *
+     * Without `endpoint`, it asks the next node in the rotation. Each node answers only for itself.
+     * An `endpoint` must be one of `endpoints`, so the client's credentials go only to the addresses
+     * it was configured with.
+     *
+     * It is server-level, not scoped to this client's database, and it works over REST
+     * (`GET /v1/admin/stats`) and gRPC (`GetNodeStats`). With authentication on, the account needs
+     * the superuser attribute or the `MONITOR` privilege (`GRANT MONITOR ON *.* TO <user>`). Any
+     * other account gets `CADB0517`.
+     *
+     * @throws {TypeError} when `endpoint` is not one of `endpoints`.
+     */
+    nodeStats(endpoint?: string, options?: {
+        signal?: AbortSignal;
+        timeoutSeconds?: number;
+    }): Promise<CamusNodeStats>;
     /** Reports whether the server answers. */
     ping(options?: {
         signal?: AbortSignal;
@@ -280,6 +342,9 @@ export declare class CamusClient implements AsyncDisposable {
      *
      * With `await using`, a transaction that is left without a commit is rolled back as the block
      * unwinds.
+     *
+     * With `deferBegin`, or with learned routing on, `BEGIN` is not sent here. The first statement,
+     * or the first `CamusPipeline` send, sends it.
      */
     beginTransaction(options?: CamusTransactionOptions, signal?: AbortSignal): Promise<CamusTransaction>;
     /**
@@ -299,6 +364,9 @@ export declare class CamusClient implements AsyncDisposable {
      * an exponential back-off. So the function must be safe to run more than once — it must not send
      * an email, charge a card, or mutate state outside the database on a path that could repeat.
      *
+     * The work can commit the transaction itself with `CamusPipeline.commit`. The transaction is
+     * then not committed a second time.
+     *
      * A commit that reports an unresolved outcome is **not** retried this way. That case is resolved
      * inside `CamusTransaction`, by re-issuing the same commit on the same handle, because replaying
      * the work could apply an already-durable commit twice.
@@ -442,8 +510,11 @@ export declare class CamusClient implements AsyncDisposable {
      * without `RETURNING`, so this sets it on every statement and does not parse the SQL for the clause.
      */
     private executeNonQuery;
-    /** Runs a write with `RETURNING` on the non-query route and maps the rows it sent back. */
-    private queryWriteReturning;
+    /**
+     * Runs a write with `RETURNING`, or a `CALL`, on the non-query route and maps the rows it sent
+     * back. A `CALL` sends back none.
+     */
+    private queryNonQueryRoute;
     /**
      * Runs a write on the non-query route. The endpoint, the negotiation flag, and the learning after
      * a success follow the same routing rules as the query path.
@@ -467,43 +538,6 @@ export declare class CamusClient implements AsyncDisposable {
      */
     private route;
     private buildRequest;
-    /**
-     * Whether this execution should name a prepared statement instead of carrying its SQL,
-     * registering it first when this is the execution that tips it over the threshold.
-     *
-     * The registration is awaited rather than started in the background, because the whole point is
-     * that this execution and the ones after it are cheap. Firing it off and running inline anyway
-     * would leave a busy statement racing its own warm-up. It costs one extra round trip, once per
-     * statement per endpoint.
-     *
-     * The caller passes the endpoint it already resolved. A REST handle is node-local and the pool
-     * rotates, so registering against a freshly drawn endpoint would routinely prepare on one node
-     * and execute on another — correct, because the transport re-registers where it lands, but a
-     * wasted round trip every single time.
-     */
-    private shouldPrepare;
-    /**
-     * Registers a statement and records what happened, reporting whether it may now run prepared.
-     *
-     * A registration failure never reaches the caller: preparing is an optimization, and the
-     * statement runs inline exactly as it would have if the driver had not tried. What the failure
-     * does decide is whether to ask again. A refusal specific to this statement stops asking for that
-     * statement; anything that says the node has no prepared-statement support at all stops asking
-     * for every statement, because one round trip per distinct SQL to relearn that is worse than not
-     * trying. A failure that never reached a verdict — a timeout, an unreachable node — drops the
-     * entry instead, so one network blip does not cost this statement its registration for the life
-     * of the process.
-     */
-    private register;
-    /**
-     * Releases a statement the policy evicted, so the server stops holding a handle this client has
-     * stopped using.
-     *
-     * It is best effort and off the caller's path: it is bookkeeping, not part of the statement being
-     * run. It takes the endpoint the caller already resolved rather than drawing a new one, which
-     * would rotate the pool as a side effect of housekeeping.
-     */
-    private release;
     /**
      * The effective options for a transaction or an autocommit statement: the caller's explicit knobs
      * win, then this client's defaults, then the server default for any knob still unset.

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}