@lossless.org/nosqldb 10.11.0 → 11.0.0

package/ts/ts_nosqldb/rust-db-bridge.ts

@@ -0,0 +1,1309 @@
+import { normalizeStoppedStorageRootAlignmentInput, type ILocalNoSqlDbStoppedStorageRootAlignmentInput, type TLocalNoSqlDbStoppedStorageRootAlignmentResult, type ILocalNoSqlDbStoppedStorageRootAlignmentAbortResult } from './storage-root-alignment.js';
+import { normalizeStoppedStorageRootInspectionInput, normalizeStoppedOperationUnknownMethod, type ILocalNoSqlDbStoppedStorageRootInspectionInput, type TLocalNoSqlDbStoppedStorageRootInspection } from './stopped-storage.js';
+import * as plugins from './plugins.js';
+import type { INoSqlDbGetCommittedWritesInput, INoSqlDbCommittedWritesPage } from './committed-writes.js';
+import { normalizeNoSqlDbFileStorageOptions } from './file-storage-options.js';
+import type { TNoSqlDbFileStorageStartup } from './file-storage-startup.js';
+import * as path from 'node:path';
+import * as url from 'node:url';
+import type { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import {
+  normalizeNoSqlDbStorageRehearsalInput,
+  type INoSqlDbStorageRehearsalInput,
+  type INoSqlDbStorageRehearsalReceipt,
+  type TNormalizedNoSqlDbStorageRehearsalInput,
+} from './storage-rehearsal.js';
+import {
+  normalizeNoSqlDbAllocationReadAccessGrantError,
+  normalizeNoSqlDbResourceFenceError,
+} from './service-types.js';
+import {
+  normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput,
+  normalizeLocalNoSqlDbOfflineInspectionInput,
+  validateNoSqlDbManagementOperationOptions,
+} from './offline-inspection.js';
+import {
+  normalizeLocalNoSqlDbStoppedStorageRootRelocationInput,
+  type ILocalNoSqlDbStoppedStorageRootRelocationInput,
+  type ILocalNoSqlDbStoppedStorageRootRelocationReceipt,
+} from './storage-root-relocation.js';
+import type {
+  INoSqlDbHealth,
+  INoSqlDbDatabaseTenantInput,
+  INoSqlDbAttestDatabaseTenantInput,
+  INoSqlDbAttestDatabaseTenantResult,
+  INoSqlDbEnsureDatabaseTenantInput,
+  INoSqlDbEnsureDatabaseTenantResult,
+  INoSqlDbAllocateDatabaseTenantInput,
+  INoSqlDbAllocateDatabaseTenantResult,
+  INoSqlDbDeleteDatabaseTenantInput,
+  INoSqlDbRotateDatabaseTenantPasswordInput,
+  INoSqlDbDatabaseTenantDescriptor,
+  INoSqlDbDeleteDatabaseTenantResult,
+  INoSqlDbIssueDatabaseAllocationReadAccessGrantInput,
+  INoSqlDbIssueDatabaseAllocationReadAccessGrantResult,
+  INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput,
+  INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult,
+  INoSqlDbDatabaseExport,
+  INoSqlDbExportDatabaseInput,
+  INoSqlDbExportHeldDatabaseInput,
+  INoSqlDbDatabaseContentDigest,
+  INoSqlDbGetDatabaseContentDigestInput,
+  INoSqlDbImportDatabaseInput,
+  INoSqlDbImportDatabaseResult,
+  INoSqlDbCommitDatabasePublicationInput,
+  INoSqlDbManagementOperationOptions,
+  INoSqlDbDatabaseResourceFenceState,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspection,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult,
+  ILocalNoSqlDbOfflineStringValueInspection,
+  TLocalNoSqlDbOfflineStringValueInspectionResult,
+  TNoSqlDbCommitDatabasePublicationResult,
+} from './service-types.js';
+
+export type {
+  INoSqlDbHealth,
+  INoSqlDbDatabaseTenantInput,
+  INoSqlDbAttestDatabaseTenantInput,
+  INoSqlDbAttestDatabaseTenantResult,
+  INoSqlDbEnsureDatabaseTenantInput,
+  INoSqlDbEnsureDatabaseTenantResult,
+  INoSqlDbAllocateDatabaseTenantInput,
+  INoSqlDbAllocateDatabaseTenantResult,
+  INoSqlDbDeleteDatabaseTenantInput,
+  INoSqlDbRotateDatabaseTenantPasswordInput,
+  INoSqlDbDatabaseTenantDescriptor,
+  INoSqlDbDeleteDatabaseTenantResult,
+  INoSqlDbDatabaseAllocationReadAccessGrantIdentity,
+  INoSqlDbIssueDatabaseAllocationReadAccessGrantInput,
+  INoSqlDbIssueDatabaseAllocationReadAccessGrantResult,
+  INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput,
+  INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult,
+  INoSqlDbDatabaseExportCollection,
+  INoSqlDbDatabaseExport,
+  INoSqlDbImportDatabaseInput,
+  INoSqlDbImportDatabaseResult,
+  INoSqlDbHeldPublicationReceipt,
+  INoSqlDbCommitDatabasePublicationInput,
+  INoSqlDbManagementOperationOptions,
+  INoSqlDbDatabaseResourceFenceState,
+  ILocalNoSqlDbOfflineInspectionLimits,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspection,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult,
+  ILocalNoSqlDbOfflineStringValueInspection,
+  TLocalNoSqlDbOfflineStringValueInspectionResult,
+  TNoSqlDbCommitDatabasePublicationResult,
+} from './service-types.js';
+
+/**
+ * A single oplog entry returned from the Rust engine.
+ */
+export interface IOpLogEntry {
+  seq: number;
+  timestampMs: number;
+  op: 'insert' | 'update' | 'delete';
+  db: string;
+  collection: string;
+  documentId: string;
+  document: Record<string, any> | null;
+  previousDocument: Record<string, any> | null;
+}
+
+/**
+ * Aggregate oplog statistics.
+ */
+export interface IOpLogStats {
+  currentSeq: number;
+  totalEntries: number;
+  oldestSeq: number;
+  /** Approximate retained bytes: the in-memory oplog entries and the table holding them. */
+  approxBytes: number;
+  entriesByOp: {
+    insert: number;
+    update: number;
+    delete: number;
+  };
+}
+
+/**
+ * Result of a getOpLog query.
+ */
+export interface IOpLogResult {
+  entries: IOpLogEntry[];
+  currentSeq: number;
+  totalEntries: number;
+}
+
+/**
+ * Result of a revertToSeq command.
+ */
+export interface IRevertResult {
+  dryRun: boolean;
+  reverted: number;
+  targetSeq?: number;
+  entries?: IOpLogEntry[];
+  errors?: string[];
+}
+
+/**
+ * A collection info entry.
+ */
+export interface ICollectionInfo {
+  db: string;
+  name: string;
+  count: number;
+}
+
+/**
+ * Result of a getDocuments query.
+ */
+export interface IDocumentsResult {
+  documents: Record<string, any>[];
+  total: number;
+}
+
+/**
+ * Bounds of the engine standard-error tail that start failures, unexpected
+ * engine exits and failed management calls carry: the engine's last 64 lines.
+ * A longer line keeps its first 1,024 characters, followed by
+ * ` [<n> more characters]`.
+ */
+export const noSqlDbEngineStderrTailLimits = Object.freeze({ lines: 64, lineCharacters: 1024 });
+
+/**
+ * Attach the engine's last standard-error lines to an error as its own field
+ * `engineStderrTail`, leaving its message and cause unchanged. Values that
+ * cannot carry a field (primitives, frozen objects) are left as they are.
+ */
+export function attachNoSqlDbEngineStderrTail(errorArg: unknown, tailArg: readonly string[]): void {
+  if (errorArg === null || (typeof errorArg !== 'object' && typeof errorArg !== 'function')) return;
+  if (!Object.isExtensible(errorArg) && !Object.prototype.hasOwnProperty.call(errorArg, 'engineStderrTail')) return;
+  try {
+    Object.defineProperty(errorArg, 'engineStderrTail', {
+      value: Object.freeze([...tailArg]),
+      enumerable: true,
+      configurable: true,
+      writable: false,
+    });
+  } catch {
+    // A non-configurable field of the same name stays as the caller made it.
+  }
+}
+
+/**
+ * The engine process exited with a non-zero status or by a signal while its
+ * server was running and no stop was in progress. `engineStderrTail` holds
+ * its last standard-error lines.
+ */
+export class NoSqlDbEngineExitError extends Error {
+  public readonly engineStderrTail: readonly string[];
+
+  constructor(
+    public readonly exitCode: number | null,
+    public readonly signal: string | null,
+    engineStderrTailArg: readonly string[],
+  ) {
+    super(`nosqldb Rust process exited unexpectedly (code=${exitCode}, signal=${signal})`);
+    this.name = 'NoSqlDbEngineExitError';
+    this.engineStderrTail = Object.freeze([...engineStderrTailArg]);
+  }
+}
+
+/**
+ * A start that the engine refused because the storage root, or a feature it
+ * carries, comes from a later NoSQLDB release than this one: the engine's
+ * management reply carried the code `UNKNOWN_ROOT`. The engine wrote nothing
+ * into the root (storage-root-names-and-start.md, "Roots of later releases";
+ * requirements A300 and A319). `code` holds the code, and `cause` the
+ * management error that carried it.
+ */
+export class NoSqlDbUnknownRootError extends Error {
+  public readonly code = 'UNKNOWN_ROOT' as const;
+  public readonly responseErrorCode = 'UNKNOWN_ROOT' as const;
+
+  constructor(options?: { cause?: unknown }) {
+    super('NoSQLDB refuses this storage root: the root, or a feature it carries, comes from a later NoSQLDB release than this one', options);
+    this.name = 'NoSqlDbUnknownRootError';
+  }
+}
+
+/** The bounded record of one engine process's last standard-error lines. */
+class EngineStderrTail {
+  private lines: string[] = [];
+
+  public add(lineArg: string): void {
+    const limit = noSqlDbEngineStderrTailLimits.lineCharacters;
+    this.lines.push(lineArg.length > limit
+      ? `${lineArg.slice(0, limit)} [${lineArg.length - limit} more characters]`
+      : lineArg);
+    if (this.lines.length > noSqlDbEngineStderrTailLimits.lines) this.lines.shift();
+  }
+
+  public clear(): void {
+    this.lines = [];
+  }
+
+  public snapshot(): string[] {
+    return [...this.lines];
+  }
+}
+
+export class NoSqlDbManagementOperationTerminationError extends AggregateError {
+  constructor(operationErrorArg: unknown, terminationErrorArg: unknown) {
+    super(
+      [operationErrorArg, terminationErrorArg],
+      'NoSQLDB management operation failed and Rust engine termination was incomplete',
+      { cause: operationErrorArg },
+    );
+    this.name = 'NoSqlDbManagementOperationTerminationError';
+  }
+}
+
+/**
+ * Server metrics.
+ */
+export interface INoSqlDbMetrics {
+  databases: number;
+  collections: number;
+  oplogEnabled: boolean;
+  /** Null when the oplog is disabled. */
+  oplogEntries: number | null;
+  /** Null when the oplog is disabled. */
+  oplogCurrentSeq: number | null;
+  sessions: number;
+  activeTransactions: number;
+  authEnabled: boolean;
+  authUsers: number;
+  uptimeSeconds: number;
+}
+
+/**
+ * Type-safe command definitions for the RustDb IPC protocol.
+ */
+type TOfflinePhysicalNamespaceInspectionCommandParams = {
+  folderPath: string;
+  timeoutMs?: number;
+} & ILocalNoSqlDbOfflinePhysicalNamespaceInspection['limits'];
+
+export const rustDbBridgeStorageRootAlignment = Symbol('storageRootAlignment');
+export const rustDbBridgeStorageRootAlignmentAbort = Symbol('storageRootAlignmentAbort');
+
+type TNoSqlDbCommands = {
+  alignStoppedStorageRoot: { params: ILocalNoSqlDbStoppedStorageRootAlignmentInput & { timeoutMs?: number }; result: TLocalNoSqlDbStoppedStorageRootAlignmentResult };
+  abortStoppedStorageRootAlignment: { params: ILocalNoSqlDbStoppedStorageRootAlignmentInput & { timeoutMs?: number }; result: ILocalNoSqlDbStoppedStorageRootAlignmentAbortResult };
+  inspectStoppedStorageRoot: {
+    params: ILocalNoSqlDbStoppedStorageRootInspectionInput & { timeoutMs?: number };
+    result: TLocalNoSqlDbStoppedStorageRootInspection;
+  };
+  createStoppedStorageRehearsal: {
+    params: { request: TNormalizedNoSqlDbStorageRehearsalInput; timeoutMs: number };
+    result: INoSqlDbStorageRehearsalReceipt;
+  };
+  relocateStoppedStorageRoot: {
+    params: ILocalNoSqlDbStoppedStorageRootRelocationInput & { timeoutMs?: number };
+    result: ILocalNoSqlDbStoppedStorageRootRelocationReceipt;
+  };
+  inspectOfflinePhysicalNamespaces: {
+    params: TOfflinePhysicalNamespaceInspectionCommandParams;
+    result: ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult;
+  };
+  inspectOfflineStringValue: {
+    params: ILocalNoSqlDbOfflineStringValueInspection & { timeoutMs?: number };
+    result: TLocalNoSqlDbOfflineStringValueInspectionResult;
+  };
+  start: { params: { config: INoSqlDbRustConfig; timeoutMs?: number }; result: { connectionUri: string } };
+  stop: { params: Record<string, never>; result: void };
+  getStatus: { params: Record<string, never>; result: { running: boolean } };
+  getHealth: { params: Record<string, never>; result: INoSqlDbHealth };
+  getMetrics: { params: Record<string, never>; result: INoSqlDbMetrics };
+  createDatabaseTenant: {
+    params: INoSqlDbDatabaseTenantInput;
+    result: INoSqlDbDatabaseTenantDescriptor;
+  };
+  allocateDatabaseTenant: {
+    params: INoSqlDbAllocateDatabaseTenantInput;
+    result: INoSqlDbAllocateDatabaseTenantResult;
+  };
+  ensureDatabaseTenant: {
+    params: INoSqlDbEnsureDatabaseTenantInput;
+    result: INoSqlDbEnsureDatabaseTenantResult;
+  };
+  attestDatabaseTenant: {
+    params: INoSqlDbAttestDatabaseTenantInput;
+    result: INoSqlDbAttestDatabaseTenantResult;
+  };
+  deleteDatabaseTenant: {
+    params: INoSqlDbDeleteDatabaseTenantInput;
+    result: INoSqlDbDeleteDatabaseTenantResult;
+  };
+  issueDatabaseAllocationReadAccessGrant: {
+    params: INoSqlDbIssueDatabaseAllocationReadAccessGrantInput;
+    result: INoSqlDbIssueDatabaseAllocationReadAccessGrantResult;
+  };
+  revokeDatabaseAllocationReadAccessGrant: {
+    params: INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput;
+    result: INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult;
+  };
+  rotateDatabaseTenantPassword: {
+    params: INoSqlDbRotateDatabaseTenantPasswordInput;
+    result: INoSqlDbDatabaseTenantDescriptor;
+  };
+  listDatabaseTenants: {
+    params: Record<string, never>;
+    result: { tenants: INoSqlDbDatabaseTenantDescriptor[] };
+  };
+  getDatabaseTenantDescriptor: {
+    params: { databaseName: string; username: string };
+    result: INoSqlDbDatabaseTenantDescriptor;
+  };
+  getDatabaseResourceFenceState: {
+    params: { databaseName: string };
+    result: INoSqlDbDatabaseResourceFenceState | null;
+  };
+  exportDatabase: {
+    params: INoSqlDbExportDatabaseInput;
+    result: INoSqlDbDatabaseExport;
+  };
+  exportHeldDatabase: {
+    params: INoSqlDbExportHeldDatabaseInput;
+    result: INoSqlDbDatabaseExport;
+  };
+  getDatabaseContentDigest: {
+    params: INoSqlDbGetDatabaseContentDigestInput;
+    result: INoSqlDbDatabaseContentDigest;
+  };
+  importDatabase: {
+    params: INoSqlDbImportDatabaseInput & { timeoutMs?: number };
+    result: INoSqlDbImportDatabaseResult;
+  };
+  commitDatabasePublication: {
+    params: INoSqlDbCommitDatabasePublicationInput;
+    result: TNoSqlDbCommitDatabasePublicationResult;
+  };
+  getOpLog: {
+    params: { sinceSeq?: number; limit?: number; db?: string; collection?: string };
+    result: IOpLogResult;
+  };
+  getCommittedWrites: {
+    params: INoSqlDbGetCommittedWritesInput;
+    result: INoSqlDbCommittedWritesPage;
+  };
+  getOpLogStats: { params: Record<string, never>; result: IOpLogStats };
+  revertToSeq: {
+    params: { seq: number; dryRun?: boolean };
+    result: IRevertResult;
+  };
+  getCollections: {
+    params: { db?: string };
+    result: { collections: ICollectionInfo[] };
+  };
+  getDocuments: {
+    params: { db: string; collection: string; limit?: number; skip?: number };
+    result: IDocumentsResult;
+  };
+};
+
+export const rustDbBridgeStorageRootRelocation = Symbol(
+  'nosqldb.internal.storage-root-relocation',
+);
+export const rustDbBridgeStorageRehearsal = Symbol('nosqldb.internal.storage-rehearsal');
+
+/**
+ * Configuration sent to the Rust binary on start.
+ */
+export interface INoSqlDbQueryOptions {
+  /** Target encoded bytes per in-memory sort run (default: 4 MiB). */
+  sortBufferBytes?: number;
+  /** Shared temporary sort-file budget, including merge output (default: 4 GiB). */
+  maxSortSpillBytes?: number;
+  /** Concurrent sort builders (default: 4). */
+  maxConcurrentSorts?: number;
+}
+
+/**
+ * Memory budgets the server's connections share for received requests, and
+ * the rate a frame larger than the 8 KiB receive buffer must arrive at while
+ * others need the encoded budget. An unset budget is sized from the process's
+ * cgroup memory limit, or physical memory. Each set budget must be 64 MiB to
+ * 1 TiB.
+ */
+export interface INoSqlDbInboundOptions {
+  /** Encoded bytes of received frames until they are decoded (default: a sixteenth of the memory limit, 64–256 MiB). */
+  encodedBytes?: number;
+  /** Memory of decoded requests; a request that needs more is refused (default: a quarter of the memory limit, 64 MiB–1 GiB). */
+  decodedBytes?: number;
+  /** Milliseconds a large frame has, once its encoded budget is held, before its rate counts (default: 10000; 1 to 300000). */
+  frameGraceMs?: number;
+  /** Slowest average rate a large frame may arrive at after its grace while another connection waits for the encoded budget or more than seven eighths of it are held; the slowest frame below it then closes its connection (default: 1048576; at least 1). */
+  minFrameBytesPerSecond?: number;
+}
+
+interface INoSqlDbRustConfig {
+  fileStorageStartup?: TNoSqlDbFileStorageStartup;
+  storageRehearsalId?: string;
+  port?: number;
+  host?: string;
+  socketPath?: string;
+  storage: 'memory' | 'file';
+  storagePath?: string;
+  query?: INoSqlDbQueryOptions;
+  inbound?: INoSqlDbInboundOptions;
+  storageBudgetBytes?: number;
+  auth?: {
+    enabled?: boolean;
+    users?: Array<{
+      username: string;
+      password: string;
+      database?: string;
+      roles?: string[];
+    }>;
+    scramIterations?: number;
+  };
+  tls?: {
+    enabled?: boolean;
+    certPath?: string;
+    keyPath?: string;
+    caPath?: string;
+    requireClientCert?: boolean;
+  };
+  oplog?: {
+    enabled?: boolean;
+    maxEntries?: number;
+    maxBytes?: number;
+  };
+}
+
+/**
+ * Get the package root directory using import.meta.url.
+ * This file is at ts/ts_nosqldb/, so package root is 2 levels up.
+ */
+function getPackageRoot(): string {
+  const thisDir = path.dirname(url.fileURLToPath(import.meta.url));
+  return path.resolve(thisDir, '..', '..');
+}
+
+/**
+ * Map Node.js process.platform/process.arch to rsrepo's friendly name suffix.
+ * rsrepo names cross-compiled binaries as: rustdb_linux_amd64, rustdb_linux_arm64, etc.
+ */
+function getTsrustPlatformSuffix(): string | null {
+  const archMap: Record<string, string> = { x64: 'amd64', arm64: 'arm64' };
+  const osMap: Record<string, string> = { linux: 'linux', darwin: 'macos' };
+  const os = osMap[process.platform];
+  const arch = archMap[process.arch];
+  if (os && arch) {
+    // Static musl runs on both Alpine and glibc hosts without probing host libc.
+    return `${os}_${arch}${os === 'linux' ? '_musl' : ''}`;
+  }
+  return null;
+}
+
+/**
+ * Build local search paths for the Rust binary, including dist_rust/ candidates
+ * (built by rsrepo) and local development build paths.
+ */
+function buildLocalPaths(): string[] {
+  const packageRoot = getPackageRoot();
+  const suffix = getTsrustPlatformSuffix();
+  const paths: string[] = [];
+
+  // dist_rust/ candidates (rsrepo cross-compiled output)
+  if (suffix) {
+    paths.push(path.join(packageRoot, 'dist_rust', `rustdb_${suffix}`));
+  }
+  paths.push(path.join(packageRoot, 'dist_rust', 'rustdb'));
+
+  // Local dev build paths
+  paths.push(path.resolve(process.cwd(), 'rust', 'target', 'release', 'rustdb'));
+  paths.push(path.resolve(process.cwd(), 'rust', 'target', 'debug', 'rustdb'));
+
+  return paths;
+}
+
+const binaryHelp = 'Set NOSQLDB_RUST_BINARY env var, install the platform package, or build locally with `rsrepo`.';
+
+/**
+ * What a spawn() that returned false after `waitedMs` means, stating only what
+ * is known. Smartrust refuses a `binaryPath` that does not pass its validation
+ * before spawn() can return false, so with one the engine there passed
+ * Smartrust's validation and did not report ready within the bridge's limit,
+ * and its path is given as the caller gave it.
+ * Without one, whatever NOSQLDB_RUST_BINARY holds (one of the places that
+ * Smartrust's search looks), either the search found no engine or the engine
+ * it found did not report ready, and nothing tells which.
+ */
+export function describeRefusedSpawn(binaryPath: string | undefined, waitedMs: number): string {
+  if (binaryPath !== undefined) {
+    return `the nosqldb engine at ${binaryPath} did not report ready within the bridge's limit: it waited ${waitedMs} ms`;
+  }
+  return `the nosqldb engine did not start: spawn() returned false after ${waitedMs} ms, which means either that no nosqldb Rust binary `
+    + `was found (${binaryHelp}) or that the engine found did not report ready within the bridge's limit`;
+}
+
+export interface IRustDbBridgeOptions {
+  /** Exact engine executable, validated by Smartrust without discovery fallback or permission changes. */
+  binaryPath?: string;
+  /**
+   * Receives every line the engine writes to its standard error, in order and
+   * without its line break. Without it, no engine line reaches the host
+   * process's standard error. Either way the bridge keeps the last lines for
+   * errors (`noSqlDbEngineStderrTailLimits`). Each call runs in its own
+   * microtask after the bridge has recorded the line, so an exception it
+   * throws cannot disturb the bridge; it is not caught and reaches the process
+   * as an uncaught exception.
+   */
+  engineLog?: (line: string) => void;
+}
+
+/**
+ * Bridge between TypeScript NoSqlDbServer and the Rust binary.
+ * Wraps @push.rocks/smartrust's RustBridge with type-safe command definitions.
+ */
+export class RustDbBridge extends EventEmitter {
+  private bridge: plugins.smartrust.RustBridge<TNoSqlDbCommands>;
+
+  /**
+   * Operating-system process id of the spawned Rust engine while it runs as a
+   * child process of this Node.js process. Undefined before spawn, after
+   * termination, or when the bridge is connected to an external process.
+   */
+  public get processId(): number | undefined {
+    return this.childProcess?.pid;
+  }
+
+  /** The engine child process of the latest spawn, while the bridge holds it. */
+  private get childProcess(): ChildProcess | undefined {
+    const transport = (this.bridge as unknown as {
+      transport?: { childProcess?: ChildProcess | null };
+    }).transport;
+    return transport?.childProcess ?? undefined;
+  }
+
+  /** How the engine process of the latest spawn exited, once it has. */
+  private engineExit: { code: number | null; signal: string | null } | null = null;
+  private engineExitPromise: Promise<void> | undefined;
+
+  /** Records the exit of the engine process that a spawn has just started. */
+  private watchEngineExit(): void {
+    const child = this.childProcess;
+    if (!child) return;
+    this.engineExitPromise = new Promise((resolveArg) => {
+      const record = (code: number | null, signal: string | null) => {
+        this.engineExit = { code, signal };
+        resolveArg();
+      };
+      if (child.exitCode !== null || child.signalCode !== null) record(child.exitCode, child.signalCode);
+      else child.once('exit', record);
+    });
+  }
+
+  /**
+   * The exit code and signal of the engine process of the latest spawn, as its
+   * process exit reported them, each null where it reported none; or null
+   * while that process has not exited, or no spawn started one.
+   */
+  public get lastEngineExit(): { code: number | null; signal: string | null } | null {
+    return this.engineExit;
+  }
+
+  /** Whether the engine process of the latest spawn exists and has not exited. */
+  public get engineProcessAlive(): boolean {
+    return this.engineExitPromise !== undefined && this.engineExit === null;
+  }
+
+  /** Waits up to `timeoutMs` for the engine process to exit by itself; resolves whether it has. */
+  public async waitForEngineExit(timeoutMs: number): Promise<boolean> {
+    if (!this.engineExitPromise) return false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    await Promise.race([
+      this.engineExitPromise,
+      new Promise<void>((resolveArg) => { timer = setTimeout(resolveArg, timeoutMs); }),
+    ]);
+    if (timer) clearTimeout(timer);
+    return this.engineExit !== null;
+  }
+
+  /**
+   * Closes the engine's management input, the end of the management protocol
+   * after an acknowledged `stop`, on which the engine exits by itself. This is
+   * neither a signal nor a kill. Returns whether there was an input to close.
+   */
+  public endManagementInput(): boolean {
+    const input = this.childProcess?.stdin;
+    if (!input || input.writableEnded) return false;
+    input.end();
+    return true;
+  }
+  private terminationConfirmed = true;
+  private terminationPromise: Promise<void> | undefined;
+  private terminationFailure: unknown;
+  private readonly stderrTail = new EngineStderrTail();
+  /** The `binaryPath` this bridge was given, if any, as given: the bridge's only configured path. */
+  private readonly binaryPath: string | undefined;
+  private spawnRefusal: string | undefined;
+
+  /**
+   * Why Smartrust's spawn() returned false, as far as the bridge knows. Each
+   * spawn() clears it as it starts, and sets it when Smartrust's spawn()
+   * returns false before this spawn()'s own `timeoutMs` or `signal` cuts it
+   * short, before the engine is ended. That spawn() then returns false, or
+   * throws if ending the engine fails. After any other spawn() it is
+   * undefined, including one cut short by its own `timeoutMs` or `signal`.
+   * Smartrust's spawn() returns false both when it finds no engine and when
+   * the engine it starts does not report ready within its limit; a
+   * `binaryPath` tells the two apart, as Smartrust refuses one that does not
+   * pass its validation with RustBinaryLocatorError before spawn() can return
+   * false.
+   */
+  public get spawnFailureMessage(): string | undefined {
+    return this.spawnRefusal;
+  }
+
+  constructor(options: IRustDbBridgeOptions = {}) {
+    super();
+    this.binaryPath = options.binaryPath;
+
+    this.bridge = new plugins.smartrust.RustBridge<TNoSqlDbCommands>({
+      binaryName: 'rustdb',
+      binaryPath: options.binaryPath,
+      envVarName: 'NOSQLDB_RUST_BINARY',
+      platformPackagePrefix: '@lossless.org/nosqldb',
+      localPaths: buildLocalPaths(),
+      maxPayloadSize: 100 * 1024 * 1024, // database exports/imports can be larger than command replies
+    });
+
+    // Smartrust delivers the engine's standard error one line at a time.
+    const engineLog = options.engineLog;
+    this.bridge.on('stderr', (line: string) => {
+      this.stderrTail.add(line);
+      // Microtasks run in order, so the lines keep their order.
+      if (engineLog) queueMicrotask(() => engineLog(line));
+    });
+
+    // Forward events from the inner bridge
+    this.bridge.on('exit', (code: number | null, signal: string | null) => {
+      this.terminationConfirmed = true;
+      this.emit('exit', code, signal);
+    });
+  }
+
+  /**
+   * The last standard-error lines of the running or most recently spawned
+   * engine process, within `noSqlDbEngineStderrTailLimits`.
+   */
+  public get engineStderrTail(): string[] {
+    return this.stderrTail.snapshot();
+  }
+
+  /**
+   * Send one management command. A failure while no engine runs (it exited
+   * or never started) carries the engine's last standard-error lines.
+   */
+  private async send<TMethod extends keyof TNoSqlDbCommands & string>(
+    methodArg: TMethod,
+    paramsArg: TNoSqlDbCommands[TMethod]['params'],
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<TNoSqlDbCommands[TMethod]['result']> {
+    try {
+      return await this.bridge.sendCommand(methodArg, paramsArg, optionsArg);
+    } catch (error) {
+      if (!this.bridge.running) attachNoSqlDbEngineStderrTail(error, this.stderrTail.snapshot());
+      throw error;
+    }
+  }
+
+  /**
+   * Spawn the Rust binary in management mode.
+   * Returns true once the engine reported ready. Returns false when
+   * Smartrust's spawn() returned false: no engine was found, or the one found
+   * did not report ready within the bridge's limit. spawnFailureMessage then
+   * says what that means, as far as the bridge knows, and still says it if
+   * ending that engine fails and this throws instead. After any other
+   * outcome, including a throw on this spawn()'s own `timeoutMs` or `signal`,
+   * spawnFailureMessage is undefined.
+   */
+  public async spawn(optionsArg?: INoSqlDbManagementOperationOptions): Promise<boolean> {
+    this.spawnRefusal = undefined;
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    if (optionsArg?.signal?.aborted) {
+      throw new plugins.smartrust.RustBridgeRequestError(
+        'NoSQLDB Rust sidecar spawn was aborted before it started',
+        {
+          code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+          method: 'spawn',
+          cause: optionsArg.signal.reason,
+        },
+      );
+    }
+
+    this.terminationConfirmed = false;
+    this.terminationFailure = undefined;
+    this.stderrTail.clear();
+    const spawnStartedAt = performance.now();
+    // The previous engine's exit belongs to it, also when this spawn fails.
+    this.engineExit = null;
+    this.engineExitPromise = undefined;
+    const spawnPromise = this.bridge.spawn();
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    let abortHandler: (() => void) | undefined;
+    const cancellationPromise = new Promise<never>((_resolveArg, rejectArg) => {
+      if (optionsArg?.timeoutMs !== undefined) {
+        timeout = setTimeout(() => {
+          rejectArg(new plugins.smartrust.RustBridgeRequestError(
+            `NoSQLDB Rust sidecar spawn timed out after ${optionsArg.timeoutMs}ms`,
+            {
+              code: 'ERR_RUST_BRIDGE_REQUEST_TIMEOUT',
+              method: 'spawn',
+            },
+          ));
+        }, optionsArg.timeoutMs);
+      }
+      if (optionsArg?.signal) {
+        abortHandler = () => {
+          rejectArg(new plugins.smartrust.RustBridgeRequestError(
+            'NoSQLDB Rust sidecar spawn was aborted',
+            {
+              code: 'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+              method: 'spawn',
+              cause: optionsArg.signal!.reason,
+            },
+          ));
+        };
+        optionsArg.signal.addEventListener('abort', abortHandler, { once: true });
+      }
+    });
+
+    try {
+      const spawned = await Promise.race([spawnPromise, cancellationPromise]);
+      if (spawned) this.watchEngineExit();
+      if (!spawned) {
+        this.spawnRefusal = describeRefusedSpawn(this.binaryPath, Math.round(performance.now() - spawnStartedAt));
+        await this.terminate({ gracePeriodMs: 0 });
+      }
+      return spawned;
+    } catch (error) {
+      try {
+        await this.terminate({ gracePeriodMs: 0 });
+      } catch (terminationError) {
+        throw new NoSqlDbManagementOperationTerminationError(error, terminationError);
+      }
+      throw error;
+    } finally {
+      if (timeout) clearTimeout(timeout);
+      if (abortHandler && optionsArg?.signal) {
+        optionsArg.signal.removeEventListener('abort', abortHandler);
+      }
+    }
+  }
+
+  /**
+   * Kill the Rust process and clean up.
+   */
+  public kill(): void {
+    this.bridge.kill();
+  }
+
+  /**
+   * Confirm that the Rust process has exited and all bridge resources are released.
+   */
+  public terminate(
+    optionsArg?: plugins.smartrust.IRustBridgeTerminateOptions,
+  ): Promise<void> {
+    if (this.terminationPromise) {
+      return this.terminationPromise;
+    }
+
+    const terminationPromise = this.bridge.terminate(optionsArg).then(
+      () => {
+        this.terminationConfirmed = true;
+        this.terminationFailure = undefined;
+      },
+      (errorArg: unknown) => {
+        this.terminationFailure = errorArg;
+        throw errorArg;
+      },
+    );
+    this.terminationPromise = terminationPromise;
+    void terminationPromise.then(
+      () => {
+        if (this.terminationPromise === terminationPromise) {
+          this.terminationPromise = undefined;
+        }
+      },
+      () => {
+        if (this.terminationPromise === terminationPromise) {
+          this.terminationPromise = undefined;
+        }
+      },
+    );
+    return terminationPromise;
+  }
+
+  /**
+   * Whether the bridge is currently running.
+   */
+  public get running(): boolean {
+    return this.bridge.running;
+  }
+
+  public get ownershipReleased(): boolean {
+    return this.terminationConfirmed;
+  }
+
+  private async awaitManagementOperationTermination(errorArg: unknown) {
+    const cancellationRequiresTermination =
+      errorArg instanceof plugins.smartrust.RustBridgeRequestError
+      && [
+        'ERR_RUST_BRIDGE_REQUEST_ABORTED',
+        'ERR_RUST_BRIDGE_REQUEST_TIMEOUT',
+      ].includes(errorArg.code);
+    let terminationPromise = this.terminationPromise;
+    if (cancellationRequiresTermination && !terminationPromise) {
+      terminationPromise = this.terminate({ gracePeriodMs: 0 });
+    }
+
+    if (!terminationPromise) {
+      if (!this.terminationConfirmed && this.terminationFailure !== undefined) {
+        throw new NoSqlDbManagementOperationTerminationError(
+          errorArg,
+          this.terminationFailure,
+        );
+      }
+      return;
+    }
+
+    try {
+      await terminationPromise;
+    } catch (terminationError) {
+      throw new NoSqlDbManagementOperationTerminationError(
+        errorArg,
+        terminationError,
+      );
+    }
+  }
+
+  // --- Convenience methods for each management command ---
+
+  public async [rustDbBridgeStorageRehearsal](inputArg: INoSqlDbStorageRehearsalInput,
+    optionsArg: INoSqlDbManagementOperationOptions & { timeoutMs: number }): Promise<INoSqlDbStorageRehearsalReceipt> {
+    const request = normalizeNoSqlDbStorageRehearsalInput(inputArg);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    try {
+      return await this.send('createStoppedStorageRehearsal',
+        { request, timeoutMs: optionsArg.timeoutMs }, optionsArg) as INoSqlDbStorageRehearsalReceipt;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeStoppedOperationUnknownMethod(error, 'createStoppedStorageRehearsal');
+    }
+  }
+
+  public async [rustDbBridgeStorageRootRelocation](
+    inputArg: ILocalNoSqlDbStoppedStorageRootRelocationInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<ILocalNoSqlDbStoppedStorageRootRelocationReceipt> {
+    const input = normalizeLocalNoSqlDbStoppedStorageRootRelocationInput(inputArg);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    try {
+      return await this.send(
+        'relocateStoppedStorageRoot',
+        { ...input, timeoutMs: optionsArg?.timeoutMs },
+        optionsArg,
+      ) as ILocalNoSqlDbStoppedStorageRootRelocationReceipt;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeStoppedOperationUnknownMethod(error, 'relocateStoppedStorageRoot');
+    }
+  }
+
+  public async [rustDbBridgeStorageRootAlignment](inputArg: ILocalNoSqlDbStoppedStorageRootAlignmentInput,
+    optionsArg?: INoSqlDbManagementOperationOptions): Promise<TLocalNoSqlDbStoppedStorageRootAlignmentResult> {
+    return this.stoppedAlignmentCommand('alignStoppedStorageRoot', inputArg, optionsArg) as Promise<TLocalNoSqlDbStoppedStorageRootAlignmentResult>;
+  }
+  public async [rustDbBridgeStorageRootAlignmentAbort](inputArg: ILocalNoSqlDbStoppedStorageRootAlignmentInput,
+    optionsArg?: INoSqlDbManagementOperationOptions): Promise<ILocalNoSqlDbStoppedStorageRootAlignmentAbortResult> {
+    return this.stoppedAlignmentCommand('abortStoppedStorageRootAlignment', inputArg, optionsArg) as Promise<ILocalNoSqlDbStoppedStorageRootAlignmentAbortResult>;
+  }
+  private async stoppedAlignmentCommand(method: 'alignStoppedStorageRoot' | 'abortStoppedStorageRootAlignment',
+    inputArg: ILocalNoSqlDbStoppedStorageRootAlignmentInput, optionsArg?: INoSqlDbManagementOperationOptions) {
+    const input = normalizeStoppedStorageRootAlignmentInput(inputArg);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    try {
+      return await this.send(method, { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg);
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeStoppedOperationUnknownMethod(error, method);
+    }
+  }
+
+  public async inspectStoppedStorageRoot(
+    inputArg: ILocalNoSqlDbStoppedStorageRootInspectionInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<TLocalNoSqlDbStoppedStorageRootInspection> {
+    const input = normalizeStoppedStorageRootInspectionInput(inputArg);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    try {
+      return await this.send('inspectStoppedStorageRoot',
+        { ...input, timeoutMs: optionsArg?.timeoutMs }, optionsArg) as TLocalNoSqlDbStoppedStorageRootInspection;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeStoppedOperationUnknownMethod(error, 'inspectStoppedStorageRoot');
+    }
+  }
+
+  public async inspectOfflinePhysicalNamespaces(
+    inputArg: ILocalNoSqlDbOfflinePhysicalNamespaceInspection,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult> {
+    const input = normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput(inputArg);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    const params: TOfflinePhysicalNamespaceInspectionCommandParams = {
+      folderPath: input.folderPath,
+      ...input.limits,
+      timeoutMs: optionsArg?.timeoutMs,
+    };
+    try {
+      return await this.send(
+        'inspectOfflinePhysicalNamespaces',
+        params,
+        optionsArg,
+      ) as ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeStoppedOperationUnknownMethod(error, 'inspectOfflinePhysicalNamespaces');
+    }
+  }
+
+  public async inspectOfflineStringValue(
+    inputArg: ILocalNoSqlDbOfflineStringValueInspection,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<TLocalNoSqlDbOfflineStringValueInspectionResult> {
+    const input = normalizeLocalNoSqlDbOfflineInspectionInput(inputArg);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    try {
+      return await this.send(
+        'inspectOfflineStringValue',
+        { ...input, timeoutMs: optionsArg?.timeoutMs },
+        optionsArg,
+      ) as TLocalNoSqlDbOfflineStringValueInspectionResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeStoppedOperationUnknownMethod(error, 'inspectOfflineStringValue');
+    }
+  }
+
+  public async startDb(
+    config: INoSqlDbRustConfig,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<{ connectionUri: string }> {
+    normalizeNoSqlDbFileStorageOptions(config);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    try {
+      return await this.send(
+        'start',
+        { config, timeoutMs: optionsArg?.timeoutMs },
+        optionsArg,
+      ) as { connectionUri: string };
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      // The unknown-root refusal is told apart by its code, never by its message.
+      if (error instanceof Error && 'responseErrorCode' in error && error.responseErrorCode === 'UNKNOWN_ROOT') {
+        throw new NoSqlDbUnknownRootError({ cause: error });
+      }
+      throw error;
+    }
+  }
+
+  public async stopDb(): Promise<void> {
+    await this.send('stop', {} as Record<string, never>);
+  }
+
+  public async getStatus(): Promise<{ running: boolean }> {
+    return await this.send('getStatus', {} as Record<string, never>) as { running: boolean };
+  }
+
+  public async getMetrics(): Promise<INoSqlDbMetrics> {
+    return this.send('getMetrics', {} as Record<string, never>) as Promise<INoSqlDbMetrics>;
+  }
+
+  public async getHealth(
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbHealth> {
+    try {
+      return await this.send(
+        'getHealth',
+        {} as Record<string, never>,
+        optionsArg,
+      ) as INoSqlDbHealth;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw error;
+    }
+  }
+
+  public async createDatabaseTenant(
+    params: INoSqlDbDatabaseTenantInput,
+  ): Promise<INoSqlDbDatabaseTenantDescriptor> {
+    try {
+      return await this.send('createDatabaseTenant', params) as INoSqlDbDatabaseTenantDescriptor;
+    } catch (error) {
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async ensureDatabaseTenant(
+    params: INoSqlDbEnsureDatabaseTenantInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbEnsureDatabaseTenantResult> {
+    try {
+      return await this.send(
+        'ensureDatabaseTenant',
+        params,
+        optionsArg,
+      ) as INoSqlDbEnsureDatabaseTenantResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async attestDatabaseTenant(
+    params: INoSqlDbAttestDatabaseTenantInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbAttestDatabaseTenantResult> {
+    try {
+      return await this.send(
+        'attestDatabaseTenant',
+        params,
+        optionsArg,
+      ) as INoSqlDbAttestDatabaseTenantResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async allocateDatabaseTenant(
+    params: INoSqlDbAllocateDatabaseTenantInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbAllocateDatabaseTenantResult> {
+    try {
+      return await this.send(
+        'allocateDatabaseTenant',
+        params,
+        optionsArg,
+      ) as INoSqlDbAllocateDatabaseTenantResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async deleteDatabaseTenant(
+    params: INoSqlDbDeleteDatabaseTenantInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbDeleteDatabaseTenantResult> {
+    try {
+      return await this.send(
+        'deleteDatabaseTenant',
+        params,
+        optionsArg,
+      ) as INoSqlDbDeleteDatabaseTenantResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async issueDatabaseAllocationReadAccessGrant(
+    params: INoSqlDbIssueDatabaseAllocationReadAccessGrantInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbIssueDatabaseAllocationReadAccessGrantResult> {
+    try {
+      return await this.send(
+        'issueDatabaseAllocationReadAccessGrant',
+        params,
+        optionsArg,
+      ) as INoSqlDbIssueDatabaseAllocationReadAccessGrantResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbAllocationReadAccessGrantError(
+        normalizeNoSqlDbResourceFenceError(error),
+        error instanceof plugins.smartrust.RustBridgeRequestError
+          ? error.responseErrorCode
+          : undefined,
+      );
+    }
+  }
+
+  public async revokeDatabaseAllocationReadAccessGrant(
+    params: INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult> {
+    try {
+      return await this.send(
+        'revokeDatabaseAllocationReadAccessGrant',
+        params,
+        optionsArg,
+      ) as INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbAllocationReadAccessGrantError(
+        normalizeNoSqlDbResourceFenceError(error),
+        error instanceof plugins.smartrust.RustBridgeRequestError
+          ? error.responseErrorCode
+          : undefined,
+      );
+    }
+  }
+
+  public async rotateDatabaseTenantPassword(
+    params: INoSqlDbRotateDatabaseTenantPasswordInput,
+  ): Promise<INoSqlDbDatabaseTenantDescriptor> {
+    return this.send('rotateDatabaseTenantPassword', params) as Promise<INoSqlDbDatabaseTenantDescriptor>;
+  }
+
+  public async listDatabaseTenants(): Promise<INoSqlDbDatabaseTenantDescriptor[]> {
+    const result = await this.send('listDatabaseTenants', {} as Record<string, never>) as { tenants: INoSqlDbDatabaseTenantDescriptor[] };
+    return result.tenants;
+  }
+
+  public async getDatabaseTenantDescriptor(params: {
+    databaseName: string;
+    username: string;
+  }): Promise<INoSqlDbDatabaseTenantDescriptor> {
+    return this.send('getDatabaseTenantDescriptor', params) as Promise<INoSqlDbDatabaseTenantDescriptor>;
+  }
+
+  public async getDatabaseResourceFenceState(
+    params: { databaseName: string },
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbDatabaseResourceFenceState | null> {
+    try {
+      return await this.send(
+        'getDatabaseResourceFenceState',
+        params,
+        optionsArg,
+      ) as INoSqlDbDatabaseResourceFenceState | null;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async exportDatabase(
+    params: INoSqlDbExportDatabaseInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbDatabaseExport> {
+    try {
+      return await this.send(
+        'exportDatabase',
+        params,
+        optionsArg,
+      ) as INoSqlDbDatabaseExport;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw error;
+    }
+  }
+
+  public async exportHeldDatabase(
+    params: INoSqlDbExportHeldDatabaseInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbDatabaseExport> {
+    try {
+      return await this.send(
+        'exportHeldDatabase',
+        params,
+        optionsArg,
+      ) as INoSqlDbDatabaseExport;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async getDatabaseContentDigest(
+    params: INoSqlDbGetDatabaseContentDigestInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbDatabaseContentDigest> {
+    try {
+      return await this.send(
+        'getDatabaseContentDigest',
+        params,
+        optionsArg,
+      ) as INoSqlDbDatabaseContentDigest;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw error;
+    }
+  }
+
+  public async importDatabase(
+    params: INoSqlDbImportDatabaseInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<INoSqlDbImportDatabaseResult> {
+    try {
+      return await this.send(
+        'importDatabase',
+        { ...params, timeoutMs: optionsArg?.timeoutMs },
+        optionsArg,
+      ) as INoSqlDbImportDatabaseResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async commitDatabasePublication(
+    params: INoSqlDbCommitDatabasePublicationInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<TNoSqlDbCommitDatabasePublicationResult> {
+    try {
+      return await this.send(
+        'commitDatabasePublication',
+        params,
+        optionsArg,
+      ) as TNoSqlDbCommitDatabasePublicationResult;
+    } catch (error) {
+      await this.awaitManagementOperationTermination(error);
+      throw normalizeNoSqlDbResourceFenceError(error);
+    }
+  }
+
+  public async getOpLog(params: {
+    sinceSeq?: number;
+    limit?: number;
+    db?: string;
+    collection?: string;
+  } = {}): Promise<IOpLogResult> {
+    return this.send('getOpLog', params) as Promise<IOpLogResult>;
+  }
+
+  public async getCommittedWrites(params: INoSqlDbGetCommittedWritesInput): Promise<INoSqlDbCommittedWritesPage> {
+    return this.send('getCommittedWrites', params);
+  }
+
+  public async getOpLogStats(): Promise<IOpLogStats> {
+    return this.send('getOpLogStats', {} as Record<string, never>) as Promise<IOpLogStats>;
+  }
+
+  public async revertToSeq(seq: number, dryRun = false): Promise<IRevertResult> {
+    return this.send('revertToSeq', { seq, dryRun }) as Promise<IRevertResult>;
+  }
+
+  public async getCollections(db?: string): Promise<ICollectionInfo[]> {
+    const result = await this.send('getCollections', db ? { db } : {}) as { collections: ICollectionInfo[] };
+    return result.collections;
+  }
+
+  public async getDocuments(
+    db: string,
+    collection: string,
+    limit = 50,
+    skip = 0,
+  ): Promise<IDocumentsResult> {
+    return this.send('getDocuments', { db, collection, limit, skip }) as Promise<IDocumentsResult>;
+  }
+}