@delali/sirannon-db 0.3.6-next.77 → 0.3.6-next.78

package/dist/{chunk-BTUD6XQO.mjs → chunk-N3MHZV3B.mjs}

@@ -1,4 +1,4 @@
-import { startCopyWithoutHoldingWriter } from './chunk-W67A4H2E.mjs';
+import { readPageSize, readMainDatabasePath, defaultDestinationName, assertPieceBytes, DEFAULT_PIECE_BYTES, startCopyWithoutHoldingWriter } from './chunk-I4JY5QPA.mjs';
 import { readLogPosition } from './chunk-AHCMO4YL.mjs';
 import { reportQuietly } from './chunk-BUWJH3D3.mjs';
 import { randomHex, destinationWithDeadline, DEFAULT_DESTINATION_TIMEOUT_MS, assertDeadline, withinDeadline } from './chunk-BGJ5JVYL.mjs';
@@ -10,30 +10,6 @@ import { open, mkdir, mkdtemp, rm } from 'fs/promises';
 import { tmpdir } from 'os';
 import { createHash } from 'crypto';
 
-// src/core/backup/report.ts
-var DEFAULT_PIECE_BYTES = 16 * 1024 * 1024;
-function defaultDestinationName() {
-  return `backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.db`;
-}
-function assertPieceBytes(pieceBytes) {
-  if (!Number.isInteger(pieceBytes) || pieceBytes <= 0) {
-    throw new SirannonError(
-      `Piece size must be a positive whole number of bytes, and it was ${pieceBytes}`,
-      "BACKUP_ERROR"
-    );
-  }
-}
-async function readPageSize(conn) {
-  const stmt = await conn.prepare("PRAGMA page_size");
-  const row = await stmt.get();
-  return row ? Number(row.page_size) : 0;
-}
-async function readMainDatabasePath(conn) {
-  const stmt = await conn.prepare("PRAGMA database_list");
-  const rows = await stmt.all();
-  const main = rows.find((row) => row.name === "main");
-  return main?.file ?? "";
-}
 function destinationPieceError(name, index, err) {
   if (err instanceof SirannonError) return err;
   return new SirannonError(
@@ -490,13 +466,18 @@ var BackupStreamHost = class _BackupStreamHost {
 
 // src/core/backup/streamed-copy.ts
 var VFS_NAME = "sirannon";
+var ENCRYPTING_VFS_PREFIX = "multipleciphers-";
 var PIECE_BLOCK_BYTES = 512;
 var DRAIN_POLL_MS = 1;
 var STILL_TAKING_REPORT_MS = 5;
 var REPORTS_BEFORE_THE_EXTENSION_STOPS_WAITING = 6;
 var MICROSECONDS_PER_MS = 1e3;
-function destinationUri(streamId) {
-  return `file:sirannon-stream-${streamId}?vfs=${VFS_NAME}`;
+async function destinationVfs(conn) {
+  const engine = await (await conn.prepare("SELECT 1 AS present FROM pragma_function_list WHERE name = 'sqlite3mc_version'")).get();
+  return engine === void 0 ? VFS_NAME : `${ENCRYPTING_VFS_PREFIX}${VFS_NAME}`;
+}
+function destinationUri(streamId, vfs) {
+  return `file:sirannon-stream-${streamId}?vfs=${vfs}`;
 }
 function sizeTheSteps(requestedPagesPerStep, pieceBytes, pageSize) {
   const pagesPerPiece = Math.max(1, Math.floor(pieceBytes / pageSize));
@@ -546,6 +527,7 @@ async function copyToDestinationStreamed(conn, request, support) {
     pageSize
   );
   const copyRunsOffCallerThread = conn.copyRunsOffCallerThread === true;
+  const vfs = await destinationVfs(conn);
   const host = await BackupStreamHost.start(support.openConnection, support.extensionPath);
   let streamId;
   try {
@@ -559,7 +541,7 @@ async function copyToDestinationStreamed(conn, request, support) {
     await host.stop().catch(() => void 0);
     throw err;
   }
-  const uri = destinationUri(streamId);
+  const uri = destinationUri(streamId, vfs);
   const stillTaking = copyRunsOffCallerThread ? setInterval(() => {
     void host.reportStillTaking(streamId).catch(() => void 0);
   }, STILL_TAKING_REPORT_MS) : null;
@@ -1324,4 +1306,4 @@ var BackupScheduler = class {
   }
 };
 
-export { BackupManager, BackupScheduler, DEFAULT_PIECE_BYTES, sendFileInPieces };
+export { BackupManager, BackupScheduler, sendFileInPieces };

package/dist/{chunk-UHUDPQFI.mjs → chunk-OJXV4L3N.mjs}

@@ -1,7 +1,7 @@
 import { checkpointLog } from './chunk-QGVRRKB2.mjs';
 import { readLogFileHeader, sameLog, cursorChecksum, scanLogFrames, copyLogRange } from './chunk-AHCMO4YL.mjs';
 import { logFrameOffset } from './chunk-BUWJH3D3.mjs';
-import { isBackupChainPosition } from './chunk-CZL4D3BM.mjs';
+import { isBackupChainPosition } from './chunk-6CABU54O.mjs';
 import { randomHex } from './chunk-BGJ5JVYL.mjs';
 import { SirannonError } from './chunk-KINDFBQP.mjs';
 import { readFile, mkdir, writeFile, rename, rm, readdir } from 'fs/promises';
@@ -45,8 +45,6 @@ async function writeCycleState(stagingDir, state) {
 async function removeCycleState(stagingDir) {
   await rm(cycleStatePath(stagingDir), { force: true });
 }
-
-// src/core/backup/cycle-capture.ts
 var STAGED_CAPTURE_PREFIX = "capture-";
 var STAGED_CAPTURE_SUFFIX = ".wal";
 function stagedCapturePath(stagingDir, sequence) {

package/dist/chunk-QF7WF7RJ.mjs

@@ -0,0 +1,34 @@
+import { status, Metadata } from '@grpc/grpc-js';
+
+// src/transport/grpc/peer-refusal.ts
+var ERROR_CODE_TRAILER = "sirannon-error-code";
+function refusalStatus(error) {
+  const trailer = new Metadata();
+  trailer.set(ERROR_CODE_TRAILER, error.code);
+  return Object.assign(new Error(error.message), {
+    code: status.FAILED_PRECONDITION,
+    details: error.message,
+    metadata: trailer
+  });
+}
+function refusePeerStreams(t, peerId, error) {
+  const served = t.serverPeerStreams.get(peerId);
+  for (const stream of [served?.replicateStream, served?.syncStream]) {
+    if (stream?.writable === true) stream.emit("error", refusalStatus(error));
+  }
+  const dialled = t.clientPeerStreams.get(peerId);
+  for (const stream of [dialled?.replicateStream, dialled?.syncStream]) {
+    try {
+      stream?.cancel();
+    } catch {
+    }
+  }
+}
+function refusalCodeOf(err) {
+  const serviceError = err;
+  if (serviceError?.code !== status.FAILED_PRECONDITION) return null;
+  const [code] = serviceError.metadata?.get(ERROR_CODE_TRAILER) ?? [];
+  return typeof code === "string" && code.length > 0 ? code : null;
+}
+
+export { ERROR_CODE_TRAILER, refusalCodeOf, refusePeerStreams };

package/dist/chunk-RLBV4YTB.mjs

@@ -0,0 +1,22 @@
+import { SirannonError, ExtensionError } from './chunk-KINDFBQP.mjs';
+import { AsyncLocalStorage } from 'async_hooks';
+
+// src/core/driver/extension.ts
+async function loadThroughRuntime(extensionPath, load) {
+  try {
+    load();
+  } catch (err) {
+    if (err instanceof SirannonError) throw err;
+    throw new ExtensionError(extensionPath, err instanceof Error ? err.message : String(err));
+  }
+}
+function asyncLocalWriterContext() {
+  const held = new AsyncLocalStorage();
+  return {
+    run: (operation) => held.run(true, operation),
+    isActive: () => held.getStore() === true,
+    exit: (operation) => held.exit(operation)
+  };
+}
+
+export { asyncLocalWriterContext, loadThroughRuntime };

package/dist/{chunk-ISDT4RBD.mjs → chunk-ULUZUBON.mjs}

@@ -1,4 +1,4 @@
-import { execute, commitFailure, asQueryError } from './chunk-DDIHBUEN.mjs';
+import { execute, commitFailure, asQueryError } from './chunk-ZWW53O5P.mjs';
 import { rowCountsOf } from './chunk-E2GRX4ZD.mjs';
 
 // src/core/group-executor.ts

package/dist/{chunk-AP4367HK.mjs → chunk-VGRAAQX3.mjs}

@@ -1,8 +1,8 @@
-import { record, string, unknown, object, optional, nullable, picklist, safeParse, summarize } from './chunk-ZFFUVYYE.mjs';
-import { withoutRowCounts, runWriterTransaction, queryMetered, execute, executeBatch } from './chunk-DDIHBUEN.mjs';
-import { HLC, ensureMetaTable, selectMetaValue, IDENTIFIER_RE, attributeChangeSeqs, validateDdlSafety, insertDdlChange, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundHistoryChangesSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareUpsertNewerColumnVersion, canonicaliseForChecksum, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion, selectTableExists, selectAppliedSourceSeqsInRange, selectStagedPushTail, selectStagedPushSeqsInRange, deleteStagedPushChanges, prepareInsertStagedPushChange, selectStagedPushChangesAfter, insertAppliedChangesFromStagedPush, prepareInsertAppliedChange } from './chunk-RPWBYASV.mjs';
+import { withoutRowCounts, runWriterTransaction, queryMetered, execute, executeBatch } from './chunk-ZWW53O5P.mjs';
+import { HLC, ensureMetaTable, selectMetaValue, IDENTIFIER_RE, attributeChangeSeqs, validateDdlSafety, insertDdlChange, extractDroppedTable, selectMaxChangeSeq, updateChangeStampsAfterSeqSql, selectOutboundHistoryChangesSql, selectOutboundChangesSql, selectNodeChangesAfterSeqSql, prepareUpsertNewerColumnVersion, canonicaliseForChecksum, upsertMetaValue, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, validateIdentifier, prepareDeleteRowColumnVersions, prepareUpsertColumnVersion, selectTableExists, selectAppliedSourceSeqsInRange, selectStagedPushTail, selectStagedPushSeqsInRange, deleteStagedPushChanges, prepareInsertStagedPushChange, selectStagedPushChangesAfter, insertAppliedChangesFromStagedPush, prepareInsertAppliedChange } from './chunk-MTOQ6QIS.mjs';
+import { record, string, unknown, object, optional, nullable, picklist, safeParse, summarize } from './chunk-5DKWHT6K.mjs';
 import { BatchValidationError, ConflictError, ReplicationError } from './chunk-BLMRNSUG.mjs';
-import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, encodeTaggedValues } from './chunk-JFVEGN7J.mjs';
+import { CHANGES_TABLE, isReservedIdentifier, decodeTaggedValues, encodeTaggedValues } from './chunk-ZAUHAJ4G.mjs';
 import { sha256Hex } from './chunk-GVCNMPOS.mjs';
 import { lateRowCountsOf } from './chunk-K43WJORM.mjs';
 import { rowCountsOf, totalRowCounts, addRowCounts } from './chunk-E2GRX4ZD.mjs';

package/dist/chunk-W74HFQFD.mjs

@@ -0,0 +1,153 @@
+import { pipe, instance, check, union, object, optional, string, safeParse } from './chunk-5DKWHT6K.mjs';
+import { EncryptionError } from './chunk-5O4J6LQQ.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
+
+// src/core/backup/chain-queries.ts
+function chainError(message) {
+  return new SirannonError(message, "BACKUP_CHAIN_BROKEN");
+}
+function firstMissingSequence(changes) {
+  for (let expected = 1; expected <= changes.length; expected++) {
+    if (changes[expected - 1]?.sequence !== expected) return expected;
+  }
+  return void 0;
+}
+function withBase(chains) {
+  return chains.filter((chain) => chain.base !== void 0);
+}
+function planBackupRestore(chains, moment) {
+  const candidates = withBase(chains).filter((chain2) => chain2.base.finishedAt <= moment).sort((left, right) => right.base.finishedAt - left.base.finishedAt);
+  const chain = candidates[0];
+  if (!chain) {
+    const earliest = withBase(chains).map((candidate) => candidate.base.finishedAt).sort((left, right) => left - right)[0];
+    throw chainError(
+      earliest === void 0 ? "The destination holds no full copy, so no moment can be restored" : `The destination holds no full copy finished at or before ${new Date(moment).toISOString()}; the earliest moment it can restore is ${new Date(earliest).toISOString()}`
+    );
+  }
+  const changes = chain.changes.filter((change) => change.capturedAt <= moment);
+  const missing = firstMissingSequence(changes);
+  if (missing !== void 0) {
+    throw chainError(
+      `Chain '${chain.chainId}' is missing change piece ${missing}, so it cannot be applied past piece ${missing - 1}`
+    );
+  }
+  const last = changes[changes.length - 1];
+  return {
+    chainId: chain.chainId,
+    base: chain.base,
+    changes,
+    restoresTo: last ? last.capturedAt : chain.base.finishedAt
+  };
+}
+function backupPiecesSafeToDelete(chains, options) {
+  const restorableFrom = options?.restorableFrom;
+  const superseded = restorableFrom === void 0 ? void 0 : withBase(chains).filter((chain) => chain.base.finishedAt <= restorableFrom).sort((left, right) => right.base.finishedAt - left.base.finishedAt)[0];
+  const oldestFirst = [...chains].sort((left, right) => left.startedAt - right.startedAt);
+  const deletable = [];
+  for (const chain of oldestFirst) {
+    if (!chain.base) {
+      deletable.push(...chain.changes);
+      continue;
+    }
+    if (superseded && chain.base.finishedAt < superseded.base.finishedAt) {
+      deletable.push(chain.base, ...chain.changes);
+      continue;
+    }
+    const missing = firstMissingSequence(chain.changes);
+    if (missing !== void 0) {
+      deletable.push(...chain.changes.filter((change) => change.sequence > missing));
+    }
+  }
+  return deletable;
+}
+
+// src/core/encryption/key.ts
+var ENCRYPTION_KEY_BYTES = 32;
+var RAW_KEY_SCHEMA = pipe(
+  instance(Uint8Array),
+  check((bytes) => bytes.length === ENCRYPTION_KEY_BYTES)
+);
+var KEY_SCHEMA = union([RAW_KEY_SCHEMA, object({ key: RAW_KEY_SCHEMA, id: optional(string()) })]);
+async function resolveEncryptionKey(source) {
+  let returned;
+  try {
+    returned = await source();
+  } catch (err) {
+    throw new EncryptionError(
+      "The encryption key function threw or rejected, so Sirannon has no key to open the database with",
+      "ENCRYPTION_KEY_UNAVAILABLE",
+      err
+    );
+  }
+  const parsed = safeParse(KEY_SCHEMA, returned);
+  if (!parsed.success) {
+    throw new EncryptionError(
+      `The encryption key function returned no ${ENCRYPTION_KEY_BYTES}-byte key. Return ${ENCRYPTION_KEY_BYTES} random bytes as a Uint8Array, alone or as { key, id }; Sirannon accepts no password and no string`,
+      "INVALID_ENCRYPTION_KEY"
+    );
+  }
+  const value = parsed.output;
+  if (value instanceof Uint8Array) return { bytes: Uint8Array.from(value) };
+  return { bytes: Uint8Array.from(value.key), ...value.id === void 0 ? {} : { id: value.id } };
+}
+function wipeEncryptionKey(key) {
+  key?.bytes.fill(0);
+}
+
+// src/core/encryption/keyring.ts
+var EncryptionKeyring = class {
+  constructor(source) {
+    this.source = source;
+  }
+  lastKeyId;
+  /** `true` when the database opens under a key. */
+  get encrypted() {
+    return this.source !== null;
+  }
+  /** The identifier that came with the key that the last open used, or `undefined` when it came with none. */
+  get keyId() {
+    return this.lastKeyId;
+  }
+  /** The key function that the database currently opens under, or `null` for a plaintext database. */
+  get keySource() {
+    return this.source;
+  }
+  /**
+   * Makes the database open every later connection under a new key function, or as plaintext.
+   *
+   * @param source - The key function of the key that the file now holds, or `null` for a plaintext file.
+   */
+  replace(source) {
+    this.source = source;
+    this.lastKeyId = void 0;
+  }
+  /**
+   * Calls the key function once, passes the key to the opens, and wipes Sirannon's copy of the key once they settle.
+   *
+   * @param open - Opens the connections with the settings that carry the key.
+   * @returns What `open` returns.
+   */
+  async openWith(open) {
+    if (this.source === null) return open({}, void 0);
+    const key = await resolveEncryptionKey(this.source);
+    this.lastKeyId = key.id;
+    try {
+      return await open({ encryption: { key: key.bytes } }, key);
+    } finally {
+      wipeEncryptionKey(key);
+    }
+  }
+  /**
+   * Calls the key function and returns a copy of the key bytes, which the caller hands to a writer worker and wipes.
+   *
+   * @returns The key bytes.
+   */
+  async freshKeyBytes() {
+    if (this.source === null) throw new Error("A plaintext database has no key to hand to its writer worker");
+    const key = await resolveEncryptionKey(this.source);
+    this.lastKeyId = key.id;
+    return key.bytes;
+  }
+};
+
+export { EncryptionKeyring, backupPiecesSafeToDelete, planBackupRestore, resolveEncryptionKey, wipeEncryptionKey };

package/dist/chunk-Y4SP7CRF.mjs

@@ -0,0 +1,9 @@
+// src/core/backup/cycle-options.ts
+var DEFAULT_CAPTURE_INTERVAL_MS = 6e4;
+var DEFAULT_FULL_COPY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var DEFAULT_BACKUP_NAME_PREFIX = "sirannon-backup";
+function defaultStagingDir(sourcePath) {
+  return `${sourcePath}-backup`;
+}
+
+export { DEFAULT_BACKUP_NAME_PREFIX, DEFAULT_CAPTURE_INTERVAL_MS, DEFAULT_FULL_COPY_INTERVAL_MS, defaultStagingDir };

package/dist/{chunk-JFVEGN7J.mjs → chunk-ZAUHAJ4G.mjs}

@@ -15,6 +15,7 @@ var STAGED_PUSH_CHANGES_TABLE = "_sirannon_staged_push_changes";
 var REPLACED_ROWS_TABLE = "_sirannon_replaced_rows";
 var CDC_TRIGGER_PREFIX = "_sirannon_trg_";
 var LIVE_PROBE_TABLE_PREFIX = "_sirannon_live_probe_";
+var KEY_CHANGE_CAPTURE_PREFIX = "_sirannon_key_change_";
 var SIRANNON_PREFIX = "_sirannon";
 var SQLITE_PREFIX = "sqlite_";
 var SIRANNON_MESSAGE = "Access to internal tables is not permitted: identifiers beginning with '_sirannon' are reserved";
@@ -301,4 +302,4 @@ function decodeHexBytes(hex) {
   return bytes;
 }
 
-export { APPLIED_CHANGES_TABLE, CDC_TRIGGER_PREFIX, CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, INTERNAL_TABLE_PREFIX, LIVE_PROBE_TABLE_PREFIX, META_TABLE, MIGRATIONS_TABLE, PEER_STATE_TABLE, REPLACED_ROWS_TABLE, SAFE_INT_BOUND_TEXT, STAGED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, SYNC_STATE_TABLE, assertSqlAllowed, changedAtToEventTimestamp, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, eventTimestampToChangedAt, isReservedIdentifier };
+export { APPLIED_CHANGES_TABLE, CDC_TRIGGER_PREFIX, CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, INTERNAL_TABLE_PREFIX, KEY_CHANGE_CAPTURE_PREFIX, LIVE_PROBE_TABLE_PREFIX, META_TABLE, MIGRATIONS_TABLE, PEER_STATE_TABLE, REPLACED_ROWS_TABLE, SAFE_INT_BOUND_TEXT, STAGED_CHANGES_TABLE, STAGED_PUSH_CHANGES_TABLE, SYNC_STATE_TABLE, assertSqlAllowed, changedAtToEventTimestamp, decodeTaggedValues, encodeTaggedValues, encodeWireRowsInPlace, eventTimestampToChangedAt, isReservedIdentifier };

package/dist/{chunk-DDIHBUEN.mjs → chunk-ZWW53O5P.mjs}

@@ -1,4 +1,4 @@
-import { encodeWireRowsInPlace, assertSqlAllowed } from './chunk-JFVEGN7J.mjs';
+import { encodeWireRowsInPlace, assertSqlAllowed } from './chunk-ZAUHAJ4G.mjs';
 import { withRowCounts, rowCountsOf, allMetered, addRowCounts } from './chunk-E2GRX4ZD.mjs';
 import { SirannonError, QueryError, TransactionError } from './chunk-KINDFBQP.mjs';
 
@@ -74,23 +74,27 @@ function withoutRowCounts(result) {
 function metered(value, counts) {
   return counts === void 0 ? { value } : { value, rowsRead: counts.rowsRead, rowsWritten: counts.rowsWritten };
 }
-async function query(conn, sql, params) {
+async function query(conn, sql, params, leasedFrom) {
   try {
     const handle = guardedStatement(conn, sql);
     const stmt = handle instanceof Promise ? await handle : handle;
     return await stmt.all(...bindParams(params));
   } catch (err) {
     throw asQueryError(err, sql);
+  } finally {
+    leasedFrom?.releaseReader();
   }
 }
-async function queryMetered(conn, sql, params) {
+async function queryMetered(conn, sql, params, leasedFrom) {
   try {
     return await allMetered(await guardedStatement(conn, sql), bindParams(params));
   } catch (err) {
     throw asQueryError(err, sql);
+  } finally {
+    leasedFrom?.releaseReader();
   }
 }
-async function queryForWire(conn, sql, params) {
+async function queryForWire(conn, sql, params, leasedFrom) {
   try {
     const stmt = await guardedStatement(conn, sql);
     const bound = bindParams(params);
@@ -103,9 +107,11 @@ async function queryForWire(conn, sql, params) {
     return { value: encodeWireRowsInPlace(rows) };
   } catch (err) {
     throw asQueryError(err, sql);
+  } finally {
+    leasedFrom?.releaseReader();
   }
 }
-async function queryRowsForWire(conn, sql, params) {
+async function queryRowsForWire(conn, sql, params, leasedFrom) {
   try {
     const handle = guardedStatement(conn, sql);
     const stmt = handle instanceof Promise ? await handle : handle;
@@ -114,18 +120,22 @@ async function queryRowsForWire(conn, sql, params) {
     return encodeWireRowsInPlace(rows);
   } catch (err) {
     throw asQueryError(err, sql);
+  } finally {
+    leasedFrom?.releaseReader();
   }
 }
-async function queryOne(conn, sql, params) {
+async function queryOne(conn, sql, params, leasedFrom) {
   try {
     const handle = guardedStatement(conn, sql);
     const stmt = handle instanceof Promise ? await handle : handle;
     return await stmt.get(...bindParams(params));
   } catch (err) {
     throw asQueryError(err, sql);
+  } finally {
+    leasedFrom?.releaseReader();
   }
 }
-async function queryOneMetered(conn, sql, params) {
+async function queryOneMetered(conn, sql, params, leasedFrom) {
   try {
     const stmt = await guardedStatement(conn, sql);
     const bound = bindParams(params);
@@ -133,6 +143,8 @@ async function queryOneMetered(conn, sql, params) {
     return { value: await stmt.get(...bound) };
   } catch (err) {
     throw asQueryError(err, sql);
+  } finally {
+    leasedFrom?.releaseReader();
   }
 }
 async function execute(conn, sql, params, trusted = false) {

package/dist/client/index.d.ts

@@ -1,17 +1,17 @@
 export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-BnNAEjwB.js';
 import { C as ConflictResolver, R as ReplicationBatch } from '../types-BG31TtrQ.js';
 export { a as ConflictContext, b as ConflictResolution } from '../types-BG31TtrQ.js';
-import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-B9CsAZp5.js';
-import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-Doaqwrx3.js';
-export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-Doaqwrx3.js';
+import { C as ClientOptions, B as BulkLoadDurability } from '../server-options-Bhdlvehe.js';
+import { D as DatabaseClient, T as Transport, L as LiveHandlers, R as RemoteSubscription, a as RemoteSubscriptionBuilder, S as SubscribeOptions, b as RegistryDigestSource } from '../client-base-DJZbSY55.js';
+export { c as LoadAllOptions, d as RemoteDatabase, e as RemoteError, f as SQL_REFUSED_MESSAGE, g as ServerCapabilities, h as ServerCapabilityCheck } from '../client-base-DJZbSY55.js';
 import { a as LiveQuery, b as LiveQueryState, c as LiveUpdate } from '../types-CEJG0eFS.js';
-import { q as DeviceSyncPort, D as Database } from '../database-fz-8CJBP.js';
+import { b as DeviceSyncPort, D as Database } from '../database-BZ96ZzAx.js';
 import { C as ChangeEvent, P as Params, R as ReadConcern, W as WriteConcern } from '../query-types-5B02ixH0.js';
-import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-DZSYSv0S.js';
+import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse, A as AckResponse } from '../protocol-DE10taas.js';
+import '../types-BWyv_N18.js';
 import '../operation-registry-CGhNT-Sn.js';
-import '../types-DTmi7pXp.js';
-import '../change-tracker-Dpo99EI-.js';
-import '../database-backup-BwTNiBm2.js';
+import '../errors-DLMAGQFb.js';
+import '../database-backup-BhM8yJ1A.js';
 
 /**
  * Connects to one sirannon-db server and returns a {@link RemoteDatabase} for each database on it.

package/dist/client/topology.d.ts

@@ -1,11 +1,11 @@
 import { a as ReadConcernLevel } from '../query-types-5B02ixH0.js';
-import { C as ClientOptions } from '../server-options-B9CsAZp5.js';
-import { T as Transport, D as DatabaseClient } from '../client-base-Doaqwrx3.js';
-import { I as ClusterStatusInfo } from '../types-DTmi7pXp.js';
+import { C as ClientOptions } from '../server-options-Bhdlvehe.js';
+import { T as Transport, D as DatabaseClient } from '../client-base-DJZbSY55.js';
+import { K as ClusterStatusInfo } from '../types-BWyv_N18.js';
 import '../operation-registry-CGhNT-Sn.js';
 import '../types-BG31TtrQ.js';
 import '../types-CEJG0eFS.js';
-import '../protocol-DZSYSv0S.js';
+import '../protocol-DE10taas.js';
 
 interface TopologyRouting {
     _getReadEndpoint(databaseId?: string, readConcern?: ReadConcernLevel): Promise<string>;

package/dist/{client-base-Doaqwrx3.d.ts → client-base-DJZbSY55.d.ts}

@@ -1,8 +1,8 @@
-import { B as BulkLoadDurability, a as BulkLoadResult, C as ClientOptions } from './server-options-B9CsAZp5.js';
+import { B as BulkLoadDurability, a as BulkLoadResult, C as ClientOptions } from './server-options-Bhdlvehe.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-DZSYSv0S.js';
+import { Q as QueryResponse, E as ExecuteResponse, T as TransactionResponse, B as BatchResponse, L as LoadResponse } from './protocol-DE10taas.js';
 
 /**
  * The message that the client throws when the server accepts no SQL over the network.

package/dist/{client-streams-MKPE4MXW.mjs → client-streams-F7IG3PTU.mjs}

@@ -1,6 +1,7 @@
-import { claimEndpoint, registerEndpointAbort, noteEndpointReachable, releaseEndpoint, scheduleEndpointRedial } from './chunk-KOTBP4AW.mjs';
-import { buildChannelCreds, ReplicationClient } from './chunk-UIDQGPJY.mjs';
-import { registerPeer, removePeer } from './chunk-RLBKZZ24.mjs';
+import { buildChannelCreds, ReplicationClient, localHello, peerHelloFields } from './chunk-4O7WYZHN.mjs';
+import { refusalCodeOf } from './chunk-QF7WF7RJ.mjs';
+import { claimEndpoint, registerEndpointAbort, noteEndpointReachable, releaseEndpoint, scheduleEndpointRedial, noteEndpointRefused, noteEndpointServing } from './chunk-C7E4H6UN.mjs';
+import { registerPeer, removePeer } from './chunk-AC7TKWNH.mjs';
 import { fromBatchPayload, fromAckPayload, fromSyncRequestPayload, fromSyncBatchPayload, fromSyncCompletePayload, fromSyncAckPayload } from './chunk-3VTT3VU6.mjs';
 import './chunk-KU32OT4H.mjs';
 import './chunk-BLMRNSUG.mjs';
@@ -48,13 +49,11 @@ function 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 ?? ""
+  const endOnError = (err) => {
+    if (!closed && refusalCodeOf(err) !== null) noteEndpointRefused(t, endpoint);
+    teardown();
   };
+  const hello = localHello(t);
   replicateStream.write({ hello });
   syncStream.write({ hello });
   replicateStream.on("data", (msg) => {
@@ -67,14 +66,11 @@ function connectToEndpoint(t, endpoint) {
       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
-      });
+      registerPeer(t.connectedPeers, t.peerConnectedHandler, replicatePeerId, peerRole, peerHelloFields(msg.hello));
       return;
     }
     if (msg.batch) {
+      noteEndpointServing(t, endpoint);
       t.batchHandler?.(fromBatchPayload(msg.batch), replicatePeerId).catch(() => {
       });
     } else if (msg.ack) {
@@ -82,7 +78,7 @@ function connectToEndpoint(t, endpoint) {
     }
   });
   replicateStream.on("end", teardown);
-  replicateStream.on("error", teardown);
+  replicateStream.on("error", endOnError);
   syncStream.on("data", (msg) => {
     if (syncPeerId === null) {
       if (!msg.hello || !t.validateTlsIdentity(syncStream, msg.hello.nodeId)) {
@@ -92,6 +88,7 @@ function connectToEndpoint(t, endpoint) {
       syncPeerId = msg.hello.nodeId;
       return;
     }
+    if (msg.syncBatch || msg.syncComplete) noteEndpointServing(t, endpoint);
     if (msg.syncRequest) {
       t.syncRequestHandler?.(fromSyncRequestPayload(msg.syncRequest), syncPeerId).catch(() => {
       });
@@ -106,7 +103,7 @@ function connectToEndpoint(t, endpoint) {
     }
   });
   syncStream.on("end", teardown);
-  syncStream.on("error", teardown);
+  syncStream.on("error", endOnError);
 }
 
 export { connectToEndpoint };