@delali/sirannon-db 0.2.3-next.37 → 0.2.3-next.39

package/dist/server/index.mjs

@@ -1,11 +1,18 @@
+import { restoreBackup, MAX_RESTORE_BATCH_SIZE } from '../chunk-63VBFSCS.mjs';
 import { dumpSchema, tablesInFkOrder, dumpTablePages } from '../chunk-XF2HH5E6.mjs';
 import { ChangeTracker, SubscriptionManager, ensureCdcEpoch, migrationChecksum, needsResync, filteredChange, TransactionGrouper, isBulkLoadDurability, PrimedSubscription } from '../chunk-ECEGYTVF.mjs';
+import '../chunk-YNTDOFTN.mjs';
 import { SEQ_STRING_RE, highestMigrationVersion, selectCountTableRows, selectTableExists, selectAppliedMigrations, PkResolver, ensureDeviceCursorsTable, upsertDeviceCursor, selectMaxChangeSeq, canonicaliseForChecksum, selectDeviceCursors, selectMinForeignChangeSeqSql, IDENTIFIER_RE, deleteDeviceCursorsUpdatedBefore } from '../chunk-7FQRQH5Z.mjs';
 import '../chunk-2QLXDHAP.mjs';
 import { encodeTaggedValues, MIGRATIONS_TABLE, decodeTaggedValues, encodeWireRowsInPlace, CHANGES_TABLE, DEVICE_CURSORS_TABLE, INTERNAL_TABLE_PREFIX } from '../chunk-7R4ER4FB.mjs';
 import { createOperationSource, operationRegistryDigest, findRead, isRefusal, resolveArguments, findWrite } from '../chunk-TUD5CJ76.mjs';
 import '../chunk-GVCNMPOS.mjs';
+import { discardStagedChain } from '../chunk-W77EEVOT.mjs';
+import '../chunk-U445A3C4.mjs';
+import '../chunk-2QCPVE67.mjs';
+import '../chunk-DVS4QSIZ.mjs';
 import '../chunk-OUSWVNWT.mjs';
+import '../chunk-YVF2ZJTE.mjs';
 import '../chunk-V5FUJEYY.mjs';
 import { SQLITE_USER_VERSION_MAX } from '../chunk-IWGIYDMZ.mjs';
 import { SirannonError, WriteOverloadError } from '../chunk-PBRXXISQ.mjs';
@@ -131,6 +138,90 @@ function paramsBatchValidationError(value) {
   return null;
 }
 
+// src/server/backup-restore-runs.ts
+function describeFailure(err) {
+  return {
+    code: err instanceof SirannonError ? err.code : "INTERNAL_ERROR",
+    message: err instanceof SirannonError ? err.message : "An unexpected error occurred"
+  };
+}
+var BackupRestoreRuns = class {
+  runs = /* @__PURE__ */ new Map();
+  /**
+   * Marks a restore of one database as under way, unless one is already running.
+   *
+   * @param databaseId - Identifier of the database being rebuilt.
+   * @param moment - Epoch milliseconds the caller asked to be taken back to.
+   * @returns True where this call claimed the database, false where a restore already has it.
+   */
+  claim(databaseId, moment) {
+    if (this.runs.get(databaseId)?.state === "running") return false;
+    this.runs.set(databaseId, { state: "running", moment, startedAt: Date.now() });
+    return true;
+  }
+  /**
+   * Records how far the restore of one database has got.
+   *
+   * @param databaseId - Identifier of the database being rebuilt.
+   * @param progress - Pieces fetched, bytes fetched, and change pieces replayed.
+   */
+  progressed(databaseId, progress) {
+    const run = this.runs.get(databaseId);
+    if (run?.state === "running") run.progress = progress;
+  }
+  /**
+   * Records a restore that rebuilt the database.
+   *
+   * A reopen that failed is reported beside the report, and the state stays
+   * `done`, because Sirannon replaced the data either way and an operator shown
+   * only the failure would believe their database untouched.
+   *
+   * @param databaseId - Identifier of the database that was rebuilt.
+   * @param report - What the restore produced.
+   * @param reopenFailure - What stopped the database opening again, where anything did.
+   */
+  finished(databaseId, report, reopenFailure) {
+    this.runs.set(databaseId, {
+      state: "done",
+      moment: this.runs.get(databaseId)?.moment ?? report.restoresTo,
+      startedAt: report.startedAt,
+      finishedAt: report.finishedAt,
+      report,
+      ...reopenFailure === void 0 ? {} : { reopenError: describeFailure(reopenFailure) }
+    });
+  }
+  /**
+   * Records a restore that stopped, under the code it stopped with.
+   *
+   * Only a `SirannonError` passes its message through. Anything else reports
+   * the same sentence the HTTP layer sends for an unexpected failure, since a
+   * runtime error names the paths and the internals of the machine serving the
+   * request.
+   *
+   * @param databaseId - Identifier of the database it was rebuilding.
+   * @param err - What stopped it.
+   */
+  failed(databaseId, err) {
+    const previous = this.runs.get(databaseId);
+    this.runs.set(databaseId, {
+      state: "failed",
+      ...previous?.moment === void 0 ? {} : { moment: previous.moment },
+      ...previous?.startedAt === void 0 ? {} : { startedAt: previous.startedAt },
+      finishedAt: Date.now(),
+      error: describeFailure(err)
+    });
+  }
+  /**
+   * Reads where one database's restore stands.
+   *
+   * @param databaseId - Identifier of the database to report on.
+   * @returns The restore, or an idle answer where none has run.
+   */
+  read(databaseId) {
+    return this.runs.get(databaseId) ?? { state: "idle" };
+  }
+};
+
 // src/server/http-common.ts
 var SQL_NOT_ACCEPTED_MESSAGE = "This server does not accept SQL statements over the wire; call a registered operation by name";
 function initAbortHandler(res) {
@@ -200,17 +291,23 @@ function parseBody(res, raw) {
     sendError(res, 400, "EMPTY_BODY", "Request body is empty");
     return null;
   }
+  let parsed;
   try {
-    return JSON.parse(raw.toString("utf-8"));
+    parsed = JSON.parse(raw.toString("utf-8"));
   } catch {
     sendError(res, 400, "INVALID_JSON", "Request body is not valid JSON");
     return null;
   }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    sendError(res, 400, "INVALID_REQUEST", "Request body must be a JSON object");
+    return null;
+  }
+  return parsed;
 }
-function sendJson(res, data) {
+function sendJson(res, data, status = "200 OK") {
   const payload = JSON.stringify(data);
   res.cork(() => {
-    res.writeStatus("200 OK").writeHeader("Content-Type", "application/json").end(payload);
+    res.writeStatus(status).writeHeader("Content-Type", "application/json").end(payload);
   });
 }
 function sendError(res, status, code, message, details, headers) {
@@ -244,6 +341,12 @@ function httpStatusForError(err) {
       return 409;
     case "HOOK_DENIED":
       return 403;
+    case "BACKUP_CHAIN_BROKEN":
+      return 409;
+    case "BACKUP_UNSUPPORTED":
+      return 501;
+    case "BACKUP_DESTINATION_ERROR":
+      return 502;
     case "DATABASE_CLOSED":
     case "SHUTDOWN":
     case "READ_CONCERN_ERROR":
@@ -430,6 +533,230 @@ function readinessStatusForReplication(replication, current) {
   return current;
 }
 
+// src/server/backup-protocol.ts
+var BACKUP_RESTORE_NOT_ACCEPTED_MESSAGE = "This server does not restore databases over the wire; turn on acceptBackupRestore to open the route";
+function wholeNumberError(field, value, atLeast, atMost) {
+  if (value === void 0) return null;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < atLeast) {
+    return `Field "${field}" must be a whole number of at least ${atLeast}`;
+  }
+  if (atMost !== void 0 && value > atMost) {
+    return `Field "${field}" must be a whole number of at most ${atMost}`;
+  }
+  return null;
+}
+function verifyNameValidationError(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return 'Field "name" is required and must be the name a chain record states';
+  }
+  return null;
+}
+function restorableFromValidationError(value) {
+  return wholeNumberError("restorableFrom", value, 0);
+}
+function restoreRequestValidationError(body) {
+  return wholeNumberError("moment", body.moment, 0) ?? wholeNumberError("batchSize", body.batchSize, 1, MAX_RESTORE_BATCH_SIZE);
+}
+
+// src/server/http-backups.ts
+function parseOptionalBody(res, rawBody) {
+  if (rawBody.length === 0) return {};
+  return parseBody(res, rawBody);
+}
+async function resolveBackupDatabase(res, abort, sirannon, dbId) {
+  let database;
+  try {
+    database = await sirannon.resolve(dbId);
+  } catch (err) {
+    sendCaughtError(res, abort, err);
+    return null;
+  }
+  if (abort.aborted) return null;
+  if (!database) {
+    sendError(res, 404, "DATABASE_NOT_FOUND", `Database '${dbId}' not found`);
+    return null;
+  }
+  return database;
+}
+function refusedOnTheFirstTick(turn) {
+  const settled = turn.then(
+    () => void 0,
+    (err) => err ?? new SirannonError("The backup turn failed", "BACKUP_ERROR")
+  );
+  const tick = new Promise((resolve) => {
+    setImmediate(() => resolve(void 0));
+  });
+  return Promise.race([settled, tick]);
+}
+function readStatus(res, abort, database) {
+  try {
+    return database.backupStatus();
+  } catch (err) {
+    sendCaughtError(res, abort, err);
+    return null;
+  }
+}
+function handleBackupTrigger(sirannon) {
+  return async (res, dbId, _rawBody, abort) => {
+    const database = await resolveBackupDatabase(res, abort, sirannon, dbId);
+    if (!database) return;
+    if (!readStatus(res, abort, database)) return;
+    const refusal = await refusedOnTheFirstTick(database.captureBackupChanges());
+    if (refusal !== void 0) {
+      sendCaughtError(res, abort, refusal);
+      return;
+    }
+    if (abort.aborted) return;
+    sendJson(res, { started: true }, "202 Accepted");
+  };
+}
+function handleBackupStatus(sirannon) {
+  return async (res, dbId, _ctx, abort) => {
+    const database = await resolveBackupDatabase(res, abort, sirannon, dbId);
+    if (!database) return;
+    const status = readStatus(res, abort, database);
+    if (!status || abort.aborted) return;
+    sendJson(res, status);
+  };
+}
+function handleBackupChain(sirannon) {
+  return async (res, dbId, _ctx, abort) => {
+    const database = await resolveBackupDatabase(res, abort, sirannon, dbId);
+    if (!database) return;
+    try {
+      const chains = await database.backupChain();
+      if (abort.aborted) return;
+      const body = { chains };
+      sendJson(res, body);
+    } catch (err) {
+      sendCaughtError(res, abort, err);
+    }
+  };
+}
+function handleBackupVerify(sirannon) {
+  return async (res, dbId, rawBody, abort) => {
+    const body = parseOptionalBody(res, rawBody);
+    if (!body) return;
+    const nameError = verifyNameValidationError(body.name);
+    if (nameError !== null) {
+      sendError(res, 400, "INVALID_REQUEST", nameError);
+      return;
+    }
+    const database = await resolveBackupDatabase(res, abort, sirannon, dbId);
+    if (!database) return;
+    try {
+      const result = await database.verifyBackup(body.name);
+      if (abort.aborted) return;
+      sendJson(res, result);
+    } catch (err) {
+      sendCaughtError(res, abort, err);
+    }
+  };
+}
+function handleBackupSafeToDelete(sirannon) {
+  return async (res, dbId, rawBody, abort) => {
+    const body = parseOptionalBody(res, rawBody);
+    if (!body) return;
+    const restorableFromError = restorableFromValidationError(body.restorableFrom);
+    if (restorableFromError !== null) {
+      sendError(res, 400, "INVALID_REQUEST", restorableFromError);
+      return;
+    }
+    const database = await resolveBackupDatabase(res, abort, sirannon, dbId);
+    if (!database) return;
+    try {
+      const records = await database.backupPiecesSafeToDelete(
+        body.restorableFrom === void 0 ? void 0 : { restorableFrom: body.restorableFrom }
+      );
+      if (abort.aborted) return;
+      const answer = { records };
+      sendJson(res, answer);
+    } catch (err) {
+      sendCaughtError(res, abort, err);
+    }
+  };
+}
+
+// src/server/http-backup-restore.ts
+function restoreAlreadyRunning(databaseId) {
+  return `A restore of database '${databaseId}' is already under way, and it keeps that file to itself until it finishes`;
+}
+async function rebuildDatabase(request) {
+  const { sirannon, runs, databaseId, location } = request;
+  try {
+    const outcome = await sirannon.withDatabaseOffline(databaseId, async (destPath) => {
+      await discardStagedChain(location.stagingDir);
+      return restoreBackup({
+        destination: location.destination,
+        chainName: location.chainName,
+        driver: sirannon.driver,
+        destPath,
+        replaceExisting: true,
+        moment: request.moment,
+        ...location.destinationTimeoutMs === void 0 ? {} : { destinationTimeoutMs: location.destinationTimeoutMs },
+        ...request.batchSize === void 0 ? {} : { batchSize: request.batchSize },
+        onProgress: (progress) => runs.progressed(databaseId, progress)
+      });
+    });
+    if (!outcome.ok) {
+      runs.failed(databaseId, outcome.failure);
+      return;
+    }
+    runs.finished(databaseId, outcome.value, outcome.reopenFailure);
+  } catch (err) {
+    runs.failed(databaseId, err);
+  }
+}
+function handleBackupRestore(sirannon, accepted, runs) {
+  return async (res, dbId, rawBody, abort) => {
+    if (!accepted) {
+      sendError(res, 403, "BACKUP_RESTORE_NOT_ACCEPTED", BACKUP_RESTORE_NOT_ACCEPTED_MESSAGE);
+      return;
+    }
+    const body = parseOptionalBody(res, rawBody);
+    if (!body) return;
+    const validationError = restoreRequestValidationError(body);
+    if (validationError !== null) {
+      sendError(res, 400, "INVALID_REQUEST", validationError);
+      return;
+    }
+    if (runs.read(dbId).state === "running") {
+      sendError(res, 409, "BACKUP_RESTORE_IN_PROGRESS", restoreAlreadyRunning(dbId));
+      return;
+    }
+    const database = await resolveBackupDatabase(res, abort, sirannon, dbId);
+    if (!database) return;
+    let location;
+    try {
+      location = database.backupLocation();
+    } catch (err) {
+      sendCaughtError(res, abort, err);
+      return;
+    }
+    const moment = body.moment === void 0 ? Date.now() : body.moment;
+    if (!runs.claim(dbId, moment)) {
+      sendError(res, 409, "BACKUP_RESTORE_IN_PROGRESS", restoreAlreadyRunning(dbId));
+      return;
+    }
+    void rebuildDatabase({
+      sirannon,
+      runs,
+      databaseId: dbId,
+      location,
+      moment,
+      ...body.batchSize === void 0 ? {} : { batchSize: body.batchSize }
+    });
+    if (abort.aborted) return;
+    sendJson(res, { started: true }, "202 Accepted");
+  };
+}
+function handleBackupRestoreStatus(runs) {
+  return async (res, dbId, _ctx, abort) => {
+    if (abort.aborted) return;
+    sendJson(res, runs.read(dbId));
+  };
+}
+
 // src/server/sync-protocol.ts
 var MAX_SYNC_BATCH_CHANGES = 1e3;
 var NODE_ID_RE = /^[0-9a-f]{32}$/;
@@ -1170,6 +1497,14 @@ function handleSnapshotPage(sirannon) {
 var DEFAULT_MAX_BODY_BYTES = 1048576;
 var DEFAULT_WS_BACKPRESSURE_BYTES = 16 * 1048576;
 var UWS_MAX_LIMIT_BYTES = 4294967295;
+function assertBackupRestoreAuthenticated(acceptBackupRestore, hasAuthenticate) {
+  if (acceptBackupRestore && !hasAuthenticate) {
+    throw new SirannonError(
+      "ServerOptions.acceptBackupRestore opens a route that replaces a running database, so it needs an authenticate hook to name the caller",
+      "INVALID_BACKUP_RESTORE"
+    );
+  }
+}
 function resolveMaxBodyBytes(value) {
   if (value === void 0) return DEFAULT_MAX_BODY_BYTES;
   if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
@@ -2968,6 +3303,8 @@ var SirannonServer = class {
   cors;
   authenticateHook;
   acceptSql;
+  acceptBackupRestore;
+  restoreRuns = new BackupRestoreRuns();
   operations;
   registryDigest;
   resolveExecutionTarget;
@@ -2985,6 +3322,8 @@ var SirannonServer = class {
     this.cors = resolveCors(options?.cors);
     this.authenticateHook = options?.authenticate;
     this.acceptSql = options?.acceptSql === true;
+    this.acceptBackupRestore = options?.acceptBackupRestore === true;
+    assertBackupRestoreAuthenticated(this.acceptBackupRestore, this.authenticateHook !== void 0);
     this.operations = options?.operations;
     this.registryDigest = operationRegistryDigest(options?.operations);
     this.resolveExecutionTarget = options?.resolveExecutionTarget;
@@ -3087,6 +3426,7 @@ var SirannonServer = class {
       "/db/:id/execute/:name",
       this.wrapOperationRoute(handleOperationExecute(this.sirannon, this.operations, this.resolveExecutionTarget))
     );
+    this.registerBackupRoutes();
     this.app.post("/db/:id/changes", this.wrapDbRoute(handleChanges(this.sirannon, this.resolveExecutionTarget)));
     this.app.post("/db/:id/migrations", this.wrapDbRoute(handleMigrationList(this.sirannon)));
     this.app.post("/db/:id/snapshot", this.wrapDbRoute(handleSnapshotManifest(this.sirannon)));
@@ -3096,6 +3436,18 @@ var SirannonServer = class {
       sendError(res, 404, "NOT_FOUND", "Route not found");
     });
   }
+  registerBackupRoutes() {
+    this.app.post("/db/:id/backup", this.wrapDbRoute(handleBackupTrigger(this.sirannon)));
+    this.app.get("/db/:id/backup", this.wrapDbGetRoute(handleBackupStatus(this.sirannon)));
+    this.app.get("/db/:id/backup/chain", this.wrapDbGetRoute(handleBackupChain(this.sirannon)));
+    this.app.post("/db/:id/backup/verify", this.wrapDbRoute(handleBackupVerify(this.sirannon)));
+    this.app.post("/db/:id/backup/safe-to-delete", this.wrapDbRoute(handleBackupSafeToDelete(this.sirannon)));
+    this.app.post(
+      "/db/:id/backup/restore",
+      this.wrapDbRoute(handleBackupRestore(this.sirannon, this.acceptBackupRestore, this.restoreRuns))
+    );
+    this.app.get("/db/:id/backup/restore", this.wrapDbGetRoute(handleBackupRestoreStatus(this.restoreRuns)));
+  }
   registerWebSocketRoute() {
     registerWebSocketRoute({
       app: this.app,

package/dist/{server-options-D4VmfTHw.d.ts → server-options-DeK6ZG8u.d.ts}

@@ -1,6 +1,6 @@
 import { a as OperationRegistry } from './operation-registry-C1FmwQWR.js';
 import { R as ReplicationBatch, C as ConflictResolver, A as ApplyResult } from './types-CjhxcjhA.js';
-import { N as NodeHealth, T as Transaction, C as ClusterStatusInfo } from './types-Xb0L3o3w.js';
+import { N as NodeHealth, T as Transaction, H as ClusterStatusInfo } from './types-DApb7dvw.js';
 import { P as Params, Q as QueryOptions, E as ExecuteResult } from './query-types-Cv8N7pXj.js';
 
 interface AppliedMigrationRow {
@@ -165,6 +165,13 @@ interface ServerOptions<Identity = unknown> {
     operations?: OperationRegistry<Identity>;
     /** Opens the five statement routes and their WebSocket messages. Default: false. */
     acceptSql?: boolean;
+    /**
+     * Opens the route that rebuilds a database from its backups. A restore
+     * replaces the database that is serving traffic, so the route stays shut
+     * until you open it here, and a server that opens it without an
+     * `authenticate` hook refuses to start. Default: false.
+     */
+    acceptBackupRestore?: boolean;
     /** Finds what the server runs a database's statements against. */
     resolveExecutionTarget?: ServerExecutionTargetResolver;
     /** Supplies the replication figures the readiness endpoint reports. */

package/dist/{sirannon-DaGUawHs.d.ts → sirannon-C9cTgFrw.d.ts}

@@ -1,5 +1,24 @@
-import { D as Database } from './database-955qag_W.js';
-import { S as SirannonOptions, a as SQLiteDriver, D as DatabaseOptions, M as Migration, B as BeforeQueryHook, A as AfterQueryHook, b as BeforeConnectHook, c as DatabaseOpenHook, d as DatabaseCloseHook } from './types-Xb0L3o3w.js';
+import { D as Database } from './database-BlhUdJAO.js';
+import { a as SirannonOptions, S as SQLiteDriver, D as DatabaseOptions, M as Migration, b as BeforeQueryHook, A as AfterQueryHook, c as BeforeConnectHook, d as DatabaseOpenHook, e as DatabaseCloseHook } from './types-DApb7dvw.js';
+
+/** What one database taken out of service produced.
+ * @internal
+ */
+type OfflineOutcome<T> = {
+    /** True where the action returned. */
+    ok: true;
+    /** What the action produced. */
+    value: T;
+    /** What the reopen threw, where it threw. The action's own result still stands. */
+    reopenFailure?: unknown;
+} | {
+    /** False where the action threw. */
+    ok: false;
+    /** What the action threw. */
+    failure: unknown;
+    /** What the reopen threw, where it threw. */
+    reopenFailure?: unknown;
+};
 
 /**
  * A registry of open SQLite databases, keyed by identifier.
@@ -10,14 +29,17 @@ import { S as SirannonOptions, a as SQLiteDriver, D as DatabaseOptions, M as Mig
  */
 declare class Sirannon {
     private readonly dbs;
+    private readonly openedWith;
+    private readonly offline;
+    private readonly offlineWork;
     private readonly opening;
     private readonly resolving;
-    private migrationSet;
     private _shutdown;
     private readonly _driver;
     private readonly hookRegistry;
     private readonly metricsCollector;
     private readonly lifecycleManager;
+    private readonly migrations;
     /** The driver, hooks, metrics, lifecycle, migrations, and writer-worker default this registry was built with. */
     readonly options: SirannonOptions;
     /**
@@ -45,6 +67,24 @@ declare class Sirannon {
      * @param id - Identifier of the database to close.
      */
     close(id: string): Promise<void>;
+    /**
+     * Closes one database, calls an action against the file behind it, and then
+     * opens that database again under the same identifier with the settings it
+     * had before.
+     *
+     * A restore rebuilds a database at the path it already occupies, so no
+     * connection may be open on that file while Sirannon replaces its bytes. The
+     * identifier answers nothing until that database is open again, though an
+     * action that failed still leaves a database open at the end.
+     *
+     * @param id - Identifier of the database to take offline.
+     * @param action - Runs with the database closed, and receives its file path.
+     * @returns Whether the action returned, what it produced or threw, and what a failed reopen threw.
+     * @throws When no database is open under the identifier, when it refuses writes, or when the close fails.
+     *
+     * @internal
+     */
+    withDatabaseOffline<T>(id: string, action: (path: string) => Promise<T>): Promise<OfflineOutcome<T>>;
     /**
      * Returns an already-open database.
      *
@@ -56,8 +96,6 @@ declare class Sirannon {
     resolve(id: string): Promise<Database | undefined>;
     /** @internal */
     registryMigrations(): Promise<Migration[]>;
-    private applyRegistryMigrations;
-    private loadMigrationSet;
     /**
      * Reports whether a database is open under an identifier.
      *
@@ -73,6 +111,10 @@ declare class Sirannon {
     databases(): Map<string, Database>;
     /**
      * Closes every open database and stops the lifecycle timers.
+     *
+     * A database whose file Sirannon is replacing delays the shutdown until that
+     * work finishes, since a process that exits part-way through would leave the
+     * path with no database on it at all.
      */
     shutdown(): Promise<void>;
     /**
@@ -106,6 +148,7 @@ declare class Sirannon {
      */
     onDatabaseClose(hook: DatabaseCloseHook): void;
     private ensureRunning;
+    private ensureOpenAllowed;
 }
 
 export { Sirannon as S };

package/dist/transport/grpc.d.ts

@@ -1,10 +1,10 @@
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import { Client, ClientDuplexStream, CallOptions, Metadata, ServiceError, ClientUnaryCall, ChannelCredentials, ClientOptions, ServerDuplexStream, Server } from '@grpc/grpc-js';
 import { HealthImplementation } from 'grpc-health-check';
-import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, N as NodeInfo, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, e as ReplicationTransport, f as TopologyRole, T as TransportConfig } from '../types-BEjS69rs.js';
+import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, N as NodeInfo, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, e as ReplicationTransport, f as TopologyRole, T as TransportConfig } from '../types-C1yBGTdx.js';
 import { R as ReplicationBatch } from '../types-CjhxcjhA.js';
-import '../change-tracker-DXHPFe9J.js';
-import '../types-Xb0L3o3w.js';
+import '../change-tracker-uG9gWvsY.js';
+import '../types-DApb7dvw.js';
 import '../query-types-Cv8N7pXj.js';
 import '../types-CMBcFPhb.js';
 

package/dist/transport/memory.d.ts

@@ -1,7 +1,7 @@
-import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-BEjS69rs.js';
+import { R as ReplicationAck, F as ForwardedTransaction, a as ForwardedTransactionResult, S as SyncRequest, b as SyncBatch, c as SyncComplete, d as SyncAck, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-C1yBGTdx.js';
 import { R as ReplicationBatch } from '../types-CjhxcjhA.js';
-import '../change-tracker-DXHPFe9J.js';
-import '../types-Xb0L3o3w.js';
+import '../change-tracker-uG9gWvsY.js';
+import '../types-DApb7dvw.js';
 import '../query-types-Cv8N7pXj.js';
 import '../types-CMBcFPhb.js';
 

package/dist/{types-BEjS69rs.d.ts → types-C1yBGTdx.d.ts}

@@ -1,5 +1,5 @@
-import { C as ChangeTracker } from './change-tracker-DXHPFe9J.js';
-import { i as SQLiteConnection, N as NodeHealth } from './types-Xb0L3o3w.js';
+import { C as ChangeTracker } from './change-tracker-uG9gWvsY.js';
+import { I as SQLiteConnection, N as NodeHealth } from './types-DApb7dvw.js';
 import { S as SyncTableManifest, R as ReplicationBatch, C as ConflictResolver } from './types-CjhxcjhA.js';
 import { C as ClusterCoordinator, j as CoordinatorCompatibilityMetadata, c as ReplicationGroupState } from './types-CMBcFPhb.js';