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

package/dist/{chunk-2QLXDHAP.mjs → chunk-BLMRNSUG.mjs}

@@ -1,4 +1,4 @@
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
 
 // src/core/sync/errors.ts
 var ReplicationError = class extends SirannonError {
@@ -8,6 +8,15 @@ var ReplicationError = class extends SirannonError {
     this.name = "ReplicationError";
   }
 };
+var ConflictError = class extends ReplicationError {
+  constructor(message, table, rowId, cause) {
+    super(message, "CONFLICT_ERROR");
+    this.table = table;
+    this.rowId = rowId;
+    this.name = "ConflictError";
+    if (cause !== void 0) this.cause = cause;
+  }
+};
 var BatchValidationError = class extends ReplicationError {
   constructor(message) {
     super(message, "BATCH_VALIDATION_ERROR");
@@ -15,4 +24,4 @@ var BatchValidationError = class extends ReplicationError {
   }
 };
 
-export { BatchValidationError, ReplicationError };
+export { BatchValidationError, ConflictError, ReplicationError };

package/dist/chunk-BVMZJOVM.mjs

@@ -0,0 +1,5 @@
+// src/transport/grpc/options.ts
+var DEFAULT_FORWARD_DEADLINE_MS = 3e4;
+var SERVICE_NAME = "sirannon.replication.v1.Replication";
+
+export { DEFAULT_FORWARD_DEADLINE_MS, SERVICE_NAME };

package/dist/{chunk-IWGIYDMZ.mjs → chunk-BZWDPF4G.mjs}

@@ -1,4 +1,4 @@
-import { MigrationError } from './chunk-PBRXXISQ.mjs';
+import { MigrationError } from './chunk-KINDFBQP.mjs';
 
 // src/core/migrations/baseline.ts
 var SQLITE_USER_VERSION_MAX = 2147483647;

package/dist/{chunk-YVF2ZJTE.mjs → chunk-CZL4D3BM.mjs}

@@ -1,4 +1,4 @@
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
 
 // src/core/backup/chain-records.ts
 function isWholeNumber(value) {

package/dist/{chunk-7SC2TZAS.mjs → chunk-DX4WGJL7.mjs}

@@ -1,5 +1,5 @@
-import { listStoredFilePieces, fetchStoredFile } from './chunk-U445A3C4.mjs';
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { listStoredFilePieces, fetchStoredFile } from './chunk-QGVRRKB2.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
 
 // src/core/backup/verify.ts
 function findRecord(chains, name) {

package/dist/{chunk-45MKELYA.mjs → chunk-ESTZZPT5.mjs}

@@ -1,5 +1,92 @@
-import { META_TABLE, CHANGES_TABLE, MIGRATIONS_TABLE, APPLIED_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-6CMCO7S4.mjs';
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { ReplicationError } from './chunk-BLMRNSUG.mjs';
+import { META_TABLE, CHANGES_TABLE, MIGRATIONS_TABLE, APPLIED_CHANGES_TABLE, COLUMN_VERSIONS_TABLE, DEVICE_CURSORS_TABLE, PEER_STATE_TABLE, SYNC_STATE_TABLE, STAGED_CHANGES_TABLE, isReservedIdentifier } from './chunk-2O3PP4CF.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
+
+// src/core/sync/hlc.ts
+var MAX_LOGICAL = 65535;
+var HLC = class _HLC {
+  wallMs;
+  logical;
+  nodeId;
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+    this.wallMs = 0;
+    this.logical = 0;
+  }
+  /**
+   * Returns a new timestamp and advances the clock.
+   *
+   * @internal
+   */
+  now() {
+    const physicalMs = Date.now();
+    if (physicalMs > this.wallMs) {
+      this.wallMs = physicalMs;
+      this.logical = 0;
+    } else {
+      this.logical += 1;
+      if (this.logical > MAX_LOGICAL) {
+        throw new ReplicationError("HLC logical counter overflow");
+      }
+    }
+    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
+  }
+  /**
+   * Merges a remote timestamp into the clock and returns the new local timestamp.
+   *
+   * @internal
+   */
+  receive(remote) {
+    const r = _HLC.decode(remote);
+    const physicalMs = Date.now();
+    if (physicalMs > this.wallMs && physicalMs > r.wallMs) {
+      this.wallMs = physicalMs;
+      this.logical = 0;
+    } else if (r.wallMs > this.wallMs) {
+      this.wallMs = r.wallMs;
+      this.logical = r.logical + 1;
+    } else if (this.wallMs > r.wallMs) {
+      this.logical += 1;
+    } else {
+      this.logical = Math.max(this.logical, r.logical) + 1;
+    }
+    if (this.logical > MAX_LOGICAL) {
+      throw new ReplicationError("HLC logical counter overflow");
+    }
+    return _HLC.encode(this.wallMs, this.logical, this.nodeId);
+  }
+  /** Compares two encoded timestamps as strings and returns -1, 0, or 1. */
+  static compare(a, b) {
+    if (a < b) return -1;
+    if (a > b) return 1;
+    return 0;
+  }
+  /** Parses an encoded timestamp into its wall-clock, logical, and node ID parts. */
+  static decode(hlc) {
+    const parts = hlc.split("-");
+    if (parts.length < 3) {
+      throw new ReplicationError(`Invalid HLC format: ${hlc}`);
+    }
+    return {
+      wallMs: Number.parseInt(parts[0], 16),
+      logical: Number.parseInt(parts[1], 16),
+      nodeId: parts.slice(2).join("-")
+    };
+  }
+  /**
+   * Returns the string form of a clock reading, padded so that string order matches clock order.
+   *
+   * @param wallMs - The wall-clock milliseconds since the Unix epoch.
+   * @param logical - The counter that orders events within one millisecond.
+   * @param nodeId - The ID of the node that takes the reading.
+   * @returns The encoded stamp.
+   */
+  static encode(wallMs, logical, nodeId) {
+    const wallHex = wallMs.toString(16).padStart(12, "0");
+    const logicalHex = logical.toString(16).padStart(4, "0");
+    return `${wallHex}-${logicalHex}-${nodeId}`;
+  }
+};
 
 // src/core/system-catalog/sqlite-catalog.ts
 async function selectTableExists(conn, table) {
@@ -156,9 +243,6 @@ function updateUnstampedChangeStampsSql(tableName) {
 function selectMinChangeSeqSql(tableName) {
   return `SELECT MIN(seq) AS seq FROM "${tableName}"`;
 }
-function selectMinForeignChangeSeqSql(tableName) {
-  return `SELECT MIN(seq) AS seq FROM "${tableName}" WHERE seq > ? AND node_id != ?`;
-}
 function deleteChangesBeforeSql(tableName) {
   return `DELETE FROM "${tableName}" WHERE changed_at < ?`;
 }
@@ -367,15 +451,50 @@ async function upsertDeviceCursor(conn, deviceId, ackedSeq, updatedAt) {
   );
   await stmt.run(deviceId, ackedSeq.toString(), updatedAt);
 }
-async function deleteDeviceCursorsUpdatedBefore(conn, cutoff) {
-  const stmt = await conn.prepare(`DELETE FROM "${DEVICE_CURSORS_TABLE}" WHERE updated_at < ?`);
-  const result = await stmt.run(cutoff);
+async function deleteExpiredDeviceCursors(conn, changesTable, bounds) {
+  assertSafeIdentifier(changesTable);
+  const stmt = await conn.prepare(
+    `DELETE FROM "${DEVICE_CURSORS_TABLE}"
+     WHERE updated_at < ?
+        OR (? > 0 AND (
+              SELECT COUNT(*) FROM "${changesTable}" AS held
+              WHERE held.seq > "${DEVICE_CURSORS_TABLE}".acked_seq
+                AND held.node_id != "${DEVICE_CURSORS_TABLE}".device_id
+            ) > ?)
+        OR EXISTS (
+             SELECT 1 FROM "${changesTable}" AS oldest
+             WHERE oldest.seq = (
+                     SELECT MIN(later.seq) FROM "${changesTable}" AS later
+                     WHERE later.seq > "${DEVICE_CURSORS_TABLE}".acked_seq
+                       AND later.node_id != "${DEVICE_CURSORS_TABLE}".device_id
+                   )
+               AND oldest.changed_at < ?
+           )`
+  );
+  const result = await stmt.run(
+    bounds.idleCutoff,
+    bounds.maxChangesHeldForDevice,
+    bounds.maxChangesHeldForDevice,
+    bounds.changeAgeCutoff
+  );
   return result.changes;
 }
-async function selectDeviceCursors(conn) {
-  const stmt = await conn.prepare(`SELECT device_id, acked_seq FROM "${DEVICE_CURSORS_TABLE}"`);
-  const rows = await stmt.all();
-  return rows.map((row) => ({ deviceId: row.device_id, ackedSeq: BigInt(row.acked_seq) }));
+async function selectMinDeviceCursorBoundary(conn, changesTable) {
+  assertSafeIdentifier(changesTable);
+  const stmt = await conn.prepare(
+    `SELECT MIN(
+              COALESCE(
+                (SELECT MIN(later.seq) FROM "${changesTable}" AS later
+                 WHERE later.seq > cursors.acked_seq AND later.node_id != cursors.device_id) - 1,
+                (SELECT COALESCE(MAX(seq), 0) FROM "${changesTable}")
+              )
+            ) AS boundary
+     FROM "${DEVICE_CURSORS_TABLE}" AS cursors`
+  );
+  const row = await stmt.get();
+  const boundary = row?.boundary;
+  if (boundary === void 0 || boundary === null) return null;
+  return typeof boundary === "bigint" ? boundary : BigInt(String(boundary));
 }
 
 // src/core/system-catalog/peer-state-table.ts
@@ -663,4 +782,4 @@ function extractDroppedTable(sql) {
   return m?.[1] ?? null;
 }
 
-export { IDENTIFIER_RE, PkResolver, SEQ_STRING_RE, UPSERT_META_VALUE_SQL, assertSafeIdentifier, canonicaliseForChecksum, deleteAllStagedChanges, deleteChangesBeforeSql, deleteChangesBeforeUpToSeqSql, deleteDeviceCursorsUpdatedBefore, deleteMetaValue, deleteStagedChangesUpToSeq, deleteSyncTableStates, ensureBatchApplyTables, ensureChangesTable, ensureDeviceCursorsTable, ensureMetaTable, ensureMigrationsTable, ensureReplicationStateTables, ensureStagedChangesTable, extractDroppedTable, highestMigrationVersion, insertDdlChange, insertMetaValueIfAbsent, prepareDeleteMigration, prepareDeleteRowColumnVersions, prepareDeleteRowColumnVersionsUpToHlc, prepareInsertAppliedChange, prepareInsertMigration, prepareUpdateMigrationChecksum, prepareUpsertColumnVersion, prepareUpsertNewerColumnVersion, referencedTables, replaceMigrationHistory, selectAppliedMigrations, selectAppliedMigrationsNewestFirst, selectAppliedSourceSeqsInRange, selectChangesAfterSeqSql, selectCompletedSyncTableNames, selectCountOutboundChanges, selectCountTableRows, selectDeviceCursors, selectFirstStagedTransactionEnd, selectMaxAppliedSourceSeq, selectMaxAppliedSourceSeqByNode, selectMaxChangeHlc, selectMaxChangeSeq, selectMaxColumnVersionHlc, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, selectMaxStagedSeq, selectMetaValue, selectMinChangeSeqSql, selectMinForeignChangeSeqSql, selectMinPeerAckedSeq, selectNodeChangesAfterSeqSql, selectOutboundChangesSql, selectPeerAckedSeq, selectStagedChangesInRange, selectSyncMetaRow, selectTableExists, selectTableSql, selectTablesChangesInRangeSql, selectUserSchemaObjects, selectUserTableNames, setForeignKeysEnabled, tableColumnNames, tableInfoRows, tablePkColumns, updateChangeStampsAfterSeqSql, updateUnstampedChangeStampsSql, upsertDeviceCursor, upsertMetaValue, upsertPeerAckedSeq, upsertStagedChangeSql, upsertSyncMeta, upsertSyncTableStatus, validateDdlSafety, validateIdentifier };
+export { HLC, IDENTIFIER_RE, PkResolver, SEQ_STRING_RE, UPSERT_META_VALUE_SQL, assertSafeIdentifier, canonicaliseForChecksum, deleteAllStagedChanges, deleteChangesBeforeSql, deleteChangesBeforeUpToSeqSql, deleteExpiredDeviceCursors, deleteMetaValue, deleteStagedChangesUpToSeq, deleteSyncTableStates, ensureBatchApplyTables, ensureChangesTable, ensureDeviceCursorsTable, ensureMetaTable, ensureMigrationsTable, ensureReplicationStateTables, ensureStagedChangesTable, extractDroppedTable, highestMigrationVersion, insertDdlChange, insertMetaValueIfAbsent, prepareDeleteMigration, prepareDeleteRowColumnVersions, prepareDeleteRowColumnVersionsUpToHlc, prepareInsertAppliedChange, prepareInsertMigration, prepareUpdateMigrationChecksum, prepareUpsertColumnVersion, prepareUpsertNewerColumnVersion, referencedTables, replaceMigrationHistory, selectAppliedMigrations, selectAppliedMigrationsNewestFirst, selectAppliedSourceSeqsInRange, selectChangesAfterSeqSql, selectCompletedSyncTableNames, selectCountOutboundChanges, selectCountTableRows, selectFirstStagedTransactionEnd, selectMaxAppliedSourceSeq, selectMaxAppliedSourceSeqByNode, selectMaxChangeHlc, selectMaxChangeSeq, selectMaxColumnVersionHlc, selectMaxColumnVersionHlcForRow, selectMaxRowChangeHlc, selectMaxStagedSeq, selectMetaValue, selectMinChangeSeqSql, selectMinDeviceCursorBoundary, selectMinPeerAckedSeq, selectNodeChangesAfterSeqSql, selectOutboundChangesSql, selectPeerAckedSeq, selectStagedChangesInRange, selectSyncMetaRow, selectTableExists, selectTableSql, selectTablesChangesInRangeSql, selectUserSchemaObjects, selectUserTableNames, setForeignKeysEnabled, tableColumnNames, tableInfoRows, tablePkColumns, updateChangeStampsAfterSeqSql, updateUnstampedChangeStampsSql, upsertDeviceCursor, upsertMetaValue, upsertPeerAckedSeq, upsertStagedChangeSql, upsertSyncMeta, upsertSyncTableStatus, validateDdlSafety, validateIdentifier };

package/dist/{chunk-QP5L5DFJ.mjs → chunk-FJPR2CJX.mjs}

@@ -1,6 +1,6 @@
-import { IDENTIFIER_RE, selectCountTableRows, canonicaliseForChecksum, selectUserSchemaObjects, validateDdlSafety, selectUserTableNames, referencedTables } from './chunk-45MKELYA.mjs';
-import { ReplicationError } from './chunk-2QLXDHAP.mjs';
-import { INTERNAL_TABLE_PREFIX } from './chunk-6CMCO7S4.mjs';
+import { IDENTIFIER_RE, selectCountTableRows, canonicaliseForChecksum, selectUserSchemaObjects, validateDdlSafety, selectUserTableNames, referencedTables } from './chunk-ESTZZPT5.mjs';
+import { ReplicationError } from './chunk-BLMRNSUG.mjs';
+import { INTERNAL_TABLE_PREFIX } from './chunk-2O3PP4CF.mjs';
 import { createHash } from 'crypto';
 
 var DumpOps = class {

package/dist/chunk-HR7K3GZW.mjs

@@ -0,0 +1,36 @@
+// src/transport/grpc/peer-streams.ts
+function replicateWriteStream(serverPeerStreams, clientPeerStreams, peerId) {
+  return serverPeerStreams.get(peerId)?.replicateStream ?? clientPeerStreams.get(peerId)?.replicateStream ?? null;
+}
+function syncWriteStream(serverPeerStreams, clientPeerStreams, peerId) {
+  return serverPeerStreams.get(peerId)?.syncStream ?? clientPeerStreams.get(peerId)?.syncStream ?? null;
+}
+function peerIdForServerStream(serverPeerStreams, entry) {
+  for (const [peerId, candidate] of serverPeerStreams) {
+    if (candidate === entry) return peerId;
+  }
+  return null;
+}
+function registerPeer(connectedPeers, peerConnectedHandler, nodeId, role, metadata = {}) {
+  if (connectedPeers.has(nodeId)) return;
+  const peerInfo = {
+    id: nodeId,
+    groupId: metadata.groupId,
+    role,
+    primaryTerm: metadata.primaryTerm,
+    protocolVersion: metadata.protocolVersion,
+    joinedAt: Date.now(),
+    lastSeenAt: Date.now(),
+    lastAckedSeq: 0n
+  };
+  connectedPeers.set(nodeId, peerInfo);
+  peerConnectedHandler?.(peerInfo);
+}
+function removePeer(connectedPeers, serverPeerStreams, peerDisconnectedHandler, nodeId) {
+  if (!connectedPeers.has(nodeId)) return;
+  connectedPeers.delete(nodeId);
+  serverPeerStreams.delete(nodeId);
+  peerDisconnectedHandler?.(nodeId);
+}
+
+export { peerIdForServerStream, registerPeer, removePeer, replicateWriteStream, syncWriteStream };

package/dist/{chunk-LXCGPZPA.mjs → chunk-IEKIYO4V.mjs}

@@ -1,4 +1,4 @@
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
 
 // src/core/driver/define.ts
 function defineDriver(config) {

package/dist/{chunk-TUD5CJ76.mjs → chunk-KB4OLJAD.mjs}

@@ -13,12 +13,12 @@ function ownEntry(group, key) {
   if (group === void 0 || !Object.hasOwn(group, key)) return void 0;
   return group[key];
 }
-function findRead(registry, databaseId, name) {
-  const operation = ownEntry(ownEntry(registry, databaseId)?.reads, name);
+function findRead(sets, databaseId, name) {
+  const operation = ownEntry(ownEntry(sets.registry, databaseId)?.reads, name) ?? ownEntry(sets.shared?.reads, name);
   return operation ?? unknownOperation(name, databaseId);
 }
-function findWrite(registry, databaseId, name) {
-  const operation = ownEntry(ownEntry(registry, databaseId)?.writes, name);
+function findWrite(sets, databaseId, name) {
+  const operation = ownEntry(ownEntry(sets.registry, databaseId)?.writes, name) ?? ownEntry(sets.shared?.writes, name);
   return operation ?? unknownOperation(name, databaseId);
 }
 function isRefusal(value) {
@@ -76,11 +76,12 @@ function resolveArguments(operation, supplied, identity) {
   }
   return { ok: true, value: resolved };
 }
-function createOperationSource(registry) {
+function createOperationSource(registry, shared) {
+  const sets = { registry, shared };
   return {
-    digest: operationRegistryDigest(registry),
+    digest: operationRegistryDigest(sets.registry, sets.shared),
     resolve: (kind, databaseId, name, supplied, identity) => {
-      const operation = kind === "read" ? findRead(registry, databaseId, name) : findWrite(registry, databaseId, name);
+      const operation = kind === "read" ? findRead(sets, databaseId, name) : findWrite(sets, databaseId, name);
       if (isRefusal(operation)) return { ok: false, refusal: operation };
       const args = resolveArguments(operation, supplied, identity);
       if (!args.ok) return { ok: false, refusal: args.refusal };
@@ -106,20 +107,26 @@ function operationLine(databaseId, kind, name, operation) {
   ).sort();
   return [databaseId, kind, name, declared.join(","), identityFields.join(",")].join(DIGEST_FIELD_SEPARATOR);
 }
-function operationRegistryDigest(registry) {
-  if (registry === void 0) return void 0;
+function databaseLines(databaseId, operations, kindPrefix) {
   const lines = [];
-  for (const databaseId of Object.keys(registry).sort()) {
-    const operations = registry[databaseId] ?? {};
-    for (const name of Object.keys(operations.reads ?? {}).sort()) {
-      const read = operations.reads?.[name];
-      if (read) lines.push(operationLine(databaseId, "read", name, read));
-    }
-    for (const name of Object.keys(operations.writes ?? {}).sort()) {
-      const write = operations.writes?.[name];
-      if (write) lines.push(operationLine(databaseId, "write", name, write));
-    }
+  for (const name of Object.keys(operations.reads ?? {}).sort()) {
+    const read = operations.reads?.[name];
+    if (read) lines.push(operationLine(databaseId, `${kindPrefix}read`, name, read));
+  }
+  for (const name of Object.keys(operations.writes ?? {}).sort()) {
+    const write = operations.writes?.[name];
+    if (write) lines.push(operationLine(databaseId, `${kindPrefix}write`, name, write));
+  }
+  return lines;
+}
+var SHARED_KIND_PREFIX = "shared-";
+function operationRegistryDigest(registry, shared) {
+  if (registry === void 0 && shared === void 0) return void 0;
+  const lines = [];
+  for (const databaseId of Object.keys(registry ?? {}).sort()) {
+    lines.push(...databaseLines(databaseId, registry?.[databaseId] ?? {}, ""));
   }
+  if (shared !== void 0) lines.push(...databaseLines("", shared, SHARED_KIND_PREFIX));
   return sha256Hex(lines.join("\n"));
 }
 

package/dist/{chunk-PBRXXISQ.mjs → chunk-KINDFBQP.mjs}

@@ -32,9 +32,10 @@ var QueryError = class extends SirannonError {
   }
 };
 var TransactionError = class extends SirannonError {
-  constructor(message) {
+  constructor(message, cause) {
     super(message, "TRANSACTION_ERROR");
     this.name = "TransactionError";
+    if (cause !== void 0) this.cause = cause;
   }
 };
 var MigrationError = class extends SirannonError {
@@ -55,7 +56,7 @@ var HookDeniedError = class extends SirannonError {
 };
 var RequestDeniedError = class extends SirannonError {
   /**
-   * HTTP status the server answers the refused request with.
+   * The HTTP status that the server responds to the rejected request with.
    */
   status;
   constructor(status, code, message) {

package/dist/{chunk-E6IMX7RS.mjs → chunk-KJLNYOOL.mjs}

@@ -1,5 +1,5 @@
-import { LOG_HEADER_BYTES, readLogHeader, logFrameOffset, readValidLogFrame } from './chunk-GYCEJNU4.mjs';
-import { SirannonError } from './chunk-PBRXXISQ.mjs';
+import { LOG_HEADER_BYTES, readLogHeader, logFrameOffset, readValidLogFrame } from './chunk-R7GBXNTO.mjs';
+import { SirannonError } from './chunk-KINDFBQP.mjs';
 import { open } from 'fs/promises';
 
 var READ_CHUNK_BYTES = 4 * 1024 * 1024;

package/dist/{chunk-BTTFW4Z4.mjs → chunk-KU32OT4H.mjs}

@@ -1,14 +1,6 @@
-import { ReplicationError } from './chunk-2QLXDHAP.mjs';
+import { ReplicationError } from './chunk-BLMRNSUG.mjs';
 
 // src/replication/errors.ts
-var ConflictError = class extends ReplicationError {
-  constructor(message, table, rowId) {
-    super(message, "CONFLICT_ERROR");
-    this.table = table;
-    this.rowId = rowId;
-    this.name = "ConflictError";
-  }
-};
 var TransportError = class extends ReplicationError {
   constructor(message) {
     super(message, "TRANSPORT_ERROR");
@@ -95,4 +87,4 @@ var SyncError = class extends ReplicationError {
   }
 };
 
-export { AuthorityError, ConflictError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError };
+export { AuthorityError, CoordinatorError, FailoverError, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, ProtocolVersionMismatchError, ReadConcernError, StalePrimaryError, SyncError, TopologyError, TransportError, UnsafeRecoveryRequiredError, WriteConcernError };