@lossless.org/nosqldb 8.0.0

package/ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@lossless.org/nosqldb',
+  version: '8.0.0',
+  description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
+}

package/ts/index.ts

@@ -0,0 +1,85 @@
+import { commitinfo } from './00_commitinfo_data.js';
+
+// Export core NoSQLDB module
+export * from './ts_nosqldb/index.js';
+
+// Export LocalNoSqlDb
+export { LocalNoSqlDb } from './ts_local/index.js';
+export type {
+  ILocalNoSqlDbOptions,
+  ILocalNoSqlDbConnectionInfo,
+  ILocalNoSqlDbOfflineInspectionLimits,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspection,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult,
+  ILocalNoSqlDbOfflineStringValueInspection,
+  TLocalNoSqlDbOfflineStringValueInspectionResult,
+  ILocalNoSqlDbStoppedStorageRootRelocationInput,
+  ILocalNoSqlDbStoppedStorageRootRelocationReceipt,
+  TLocalNoSqlDbStorageRootRelocationErrorCode,
+} from './ts_local/index.js';
+export {
+  LocalNoSqlDbStorageRootRelocationError,
+  localNoSqlDbStorageRootRelocationErrorCodes,
+} from './ts_local/index.js';
+
+// Export commitinfo
+export { commitinfo };
+
+// Re-export oplog / debug types for convenience
+export type {
+  IOpLogEntry,
+  IOpLogResult,
+  IOpLogStats,
+  IRevertResult,
+  ICollectionInfo,
+  IDocumentsResult,
+  INoSqlDbMetrics,
+  INoSqlDbHealth,
+  INoSqlDbResourceFence,
+  INoSqlDbResourceFenceReceipt,
+  INoSqlDbHeldPublicationReceipt,
+  INoSqlDbCommitDatabasePublicationInput,
+  INoSqlDbManagementOperationOptions,
+  INoSqlDbDatabaseResourceFenceState,
+  INoSqlDbDatabaseAllocationIdentity,
+  INoSqlDbDatabaseAllocationLifecycle,
+  INoSqlDbDatabaseAllocationReadAccessGrantIdentity,
+  INoSqlDbIssueDatabaseAllocationReadAccessGrantInput,
+  INoSqlDbIssueDatabaseAllocationReadAccessGrantResult,
+  INoSqlDbRevokeDatabaseAllocationReadAccessGrantInput,
+  INoSqlDbRevokeDatabaseAllocationReadAccessGrantResult,
+  TNoSqlDbCommitDatabasePublicationResult,
+  TNoSqlDbResourceFenceErrorCode,
+  TNoSqlDbAllocationReadAccessGrantErrorCode,
+  INoSqlDbDatabaseTenantInput,
+  INoSqlDbAttestDatabaseTenantInput,
+  INoSqlDbAttestDatabaseTenantResult,
+  INoSqlDbEnsureDatabaseTenantInput,
+  INoSqlDbEnsureDatabaseTenantResult,
+  INoSqlDbAllocateDatabaseTenantInput,
+  INoSqlDbAllocateDatabaseTenantResult,
+  INoSqlDbDeleteDatabaseTenantInput,
+  INoSqlDbRotateDatabaseTenantPasswordInput,
+  INoSqlDbDatabaseTenantDescriptor,
+  INoSqlDbDeleteDatabaseTenantResult,
+  INoSqlDbDatabaseExportCollection,
+  INoSqlDbDatabaseExport,
+  INoSqlDbDatabaseExportLimits,
+  INoSqlDbExportDatabaseInput,
+  INoSqlDbDatabaseContentDigestLimits,
+  INoSqlDbGetDatabaseContentDigestInput,
+  INoSqlDbDatabaseContentDigest,
+  INoSqlDbImportDatabaseInput,
+  INoSqlDbImportDatabaseResult,
+  TNoSqlDbEffectivePayloadInputV1,
+} from './ts_nosqldb/index.js';
+export {
+  NoSqlDbAllocationReadAccessGrantError,
+  normalizeNoSqlDbAllocationReadAccessGrantError,
+  noSqlDbAllocationReadAccessGrantErrorCodes,
+  NoSqlDbResourceFenceError,
+  normalizeNoSqlDbResourceFenceError,
+  noSqlDbResourceFenceErrorCodes,
+  createNoSqlDbEffectivePayloadSha256V1,
+} from './ts_nosqldb/index.js';

package/ts/ts_local/classes.localnosqldb.ts

@@ -0,0 +1,500 @@
+import * as crypto from 'crypto';
+import * as fs from 'fs/promises';
+import * as net from 'net';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  NoSqlDbServer,
+  type INoSqlDbAuthOptions,
+  type ILocalNoSqlDbOfflinePhysicalNamespaceInspection,
+  type ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult,
+  type ILocalNoSqlDbStoppedStorageRootRelocationInput,
+  type ILocalNoSqlDbStoppedStorageRootRelocationReceipt,
+  type ILocalNoSqlDbOfflineStringValueInspection,
+  type INoSqlDbManagementOperationOptions,
+  type TLocalNoSqlDbOfflineStringValueInspectionResult,
+} from '../ts_nosqldb/index.js';
+import {
+  RustDbBridge,
+  rustDbBridgeStorageRootRelocation,
+} from '../ts_nosqldb/rust-db-bridge.js';
+import { validateNoSqlDbStorageRehearsalStartup } from '../ts_nosqldb/storage-rehearsal.js';
+import {
+  type TNoSqlDbFileStorageStartup,
+} from '../ts_nosqldb/file-storage-startup.js';
+import {
+  normalizeNoSqlDbFileStorageOptions,
+} from '../ts_nosqldb/file-storage-options.js';
+import {
+  normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput,
+  normalizeLocalNoSqlDbOfflineInspectionInput,
+  validateNoSqlDbManagementOperationOptions,
+} from '../ts_nosqldb/offline-inspection.js';
+import {
+  assertNoLocalNoSqlDbStorageRootRelocationWorkspace,
+  isLocalNoSqlDbStorageRootRelocationErrorCode,
+  LocalNoSqlDbStorageRootRelocationError,
+  normalizeLocalNoSqlDbStoppedStorageRootRelocationInput,
+  normalizeLocalNoSqlDbStoppedStorageRootRelocationReceipt,
+} from '../ts_nosqldb/storage-root-relocation.js';
+
+/**
+ * Connection information returned by LocalNoSqlDb.start()
+ */
+export interface ILocalNoSqlDbConnectionInfo {
+  /** The Unix socket file path */
+  socketPath: string;
+  /** Connection URI (mongodb:// scheme) ready for MongoClient */
+  connectionUri: string;
+}
+
+export interface ILocalNoSqlDbOptions {
+  /** Persisted authentication, including the source-verbatim credentials of a rehearsal destination. */
+  auth?: INoSqlDbAuthOptions;
+  /** Exact rehearsal operation ID; requires current-format-only startup and an explicit private socket. */
+  storageRehearsalId?: string;
+  /** Exact engine executable. Invalid explicit paths reject without chmod or discovery fallback. Omit for normal discovery. */
+  binaryPath?: string;
+  /** Default: current-format-only. Native ownership precedes all file-root initialization. */
+  fileStorageStartup?: TNoSqlDbFileStorageStartup;
+  /** Required: where to store data */
+  folderPath: string;
+  /** Optional: custom socket path (default: auto-generated in /tmp) */
+  socketPath?: string;
+}
+
+/**
+ * LocalNoSqlDb - Lightweight local MongoDB-compatible database using Unix sockets
+ *
+ * This class wraps NoSqlDbServer and provides a simple interface for
+ * starting a local file-based database server. Returns connection
+ * info that you can use with any compatible driver instance.
+ *
+ * @example
+ * ```typescript
+ * import { LocalNoSqlDb } from '@lossless.org/nosqldb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const db = new LocalNoSqlDb({ folderPath: './data' });
+ * const { connectionUri } = await db.start();
+ *
+ * // Connect with the driver
+ * const client = new MongoClient(connectionUri, { directConnection: true });
+ * await client.connect();
+ *
+ * // Use the client
+ * const collection = client.db('mydb').collection('users');
+ * await collection.insertOne({ name: 'Alice' });
+ *
+ * // When done
+ * await client.close();
+ * await db.stop();
+ * ```
+ */
+export class LocalNoSqlDb {
+  private static storageRootRelocationGate: Promise<void> = Promise.resolve();
+  private static storageRootRelocationBridge: RustDbBridge | undefined;
+  private options: ILocalNoSqlDbOptions;
+  private server: NoSqlDbServer | null = null;
+  private generatedSocketPath: string | null = null;
+
+  constructor(options: ILocalNoSqlDbOptions) {
+    validateNoSqlDbStorageRehearsalStartup({ ...options, storage: 'file', storagePath: options.folderPath });
+    this.options = {
+      ...options,
+      ...normalizeNoSqlDbFileStorageOptions({ ...options, storage: 'file' }),
+    };
+  }
+
+  private static createOfflineInspectionBridge(): RustDbBridge {
+    return new RustDbBridge();
+  }
+
+  private static createStorageRootRelocationBridge(): RustDbBridge {
+    return new RustDbBridge();
+  }
+
+  private static async withStorageRootRelocationGate<TResult>(
+    operationArg: () => Promise<TResult>,
+  ): Promise<TResult> {
+    const previous = LocalNoSqlDb.storageRootRelocationGate;
+    let release!: () => void;
+    LocalNoSqlDb.storageRootRelocationGate = new Promise<void>((resolveArg) => {
+      release = resolveArg;
+    });
+    await previous;
+    try {
+      return await operationArg();
+    } finally {
+      release();
+    }
+  }
+
+  private static remainingManagementTimeout(
+    deadlineArg: number | undefined,
+  ): number | undefined {
+    if (deadlineArg === undefined) return undefined;
+    const remaining = deadlineArg - Date.now();
+    if (remaining <= 0) {
+      throw new LocalNoSqlDbStorageRootRelocationError('IO');
+    }
+    return remaining;
+  }
+
+  /**
+   * Relocate one stopped current native file root, including authenticated
+   * roots, under continuous ownership. Preserve the returned source receipt;
+   * interrupted operations require the identical request to finish recovery.
+   */
+  public static async relocateStoppedStorageRoot(
+    inputArg: ILocalNoSqlDbStoppedStorageRootRelocationInput,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<ILocalNoSqlDbStoppedStorageRootRelocationReceipt> {
+    let input: ILocalNoSqlDbStoppedStorageRootRelocationInput;
+    try {
+      input = normalizeLocalNoSqlDbStoppedStorageRootRelocationInput(inputArg);
+      validateNoSqlDbManagementOperationOptions(optionsArg);
+    } catch (error) {
+      if (error instanceof LocalNoSqlDbStorageRootRelocationError) throw error;
+      throw new LocalNoSqlDbStorageRootRelocationError('INVALID_REQUEST');
+    }
+    if (optionsArg?.signal?.aborted) {
+      throw new LocalNoSqlDbStorageRootRelocationError('IO');
+    }
+    if (process.platform !== 'linux' && process.platform !== 'darwin') {
+      throw new LocalNoSqlDbStorageRootRelocationError('UNSUPPORTED');
+    }
+    const deadline = optionsArg?.timeoutMs === undefined
+      ? undefined
+      : Date.now() + optionsArg.timeoutMs;
+
+    return LocalNoSqlDb.withStorageRootRelocationGate(async () => {
+      const retainedBridge = LocalNoSqlDb.storageRootRelocationBridge;
+      if (retainedBridge) {
+        try {
+          await retainedBridge.terminate({ gracePeriodMs: 0 });
+        } catch {
+          throw new LocalNoSqlDbStorageRootRelocationError('RECOVERY_REQUIRED');
+        }
+        if (!retainedBridge.ownershipReleased) {
+          throw new LocalNoSqlDbStorageRootRelocationError('RECOVERY_REQUIRED');
+        }
+        if (LocalNoSqlDb.storageRootRelocationBridge === retainedBridge) {
+          LocalNoSqlDb.storageRootRelocationBridge = undefined;
+        }
+      }
+
+      let bridge: RustDbBridge | undefined;
+      let receipt: ILocalNoSqlDbStoppedStorageRootRelocationReceipt | undefined;
+      let operationError: LocalNoSqlDbStorageRootRelocationError | undefined;
+      try {
+        bridge = LocalNoSqlDb.createStorageRootRelocationBridge();
+        LocalNoSqlDb.storageRootRelocationBridge = bridge;
+        const spawnTimeout = LocalNoSqlDb.remainingManagementTimeout(deadline);
+        const spawned = await bridge.spawn({
+          ...(optionsArg?.signal ? { signal: optionsArg.signal } : {}),
+          ...(spawnTimeout === undefined ? {} : { timeoutMs: spawnTimeout }),
+        });
+        if (!spawned) {
+          throw new LocalNoSqlDbStorageRootRelocationError('IO');
+        }
+        const commandTimeout = LocalNoSqlDb.remainingManagementTimeout(deadline);
+        const result = await bridge[rustDbBridgeStorageRootRelocation](input, {
+          ...(optionsArg?.signal ? { signal: optionsArg.signal } : {}),
+          ...(commandTimeout === undefined ? {} : { timeoutMs: commandTimeout }),
+        });
+        receipt = normalizeLocalNoSqlDbStoppedStorageRootRelocationReceipt(result, input);
+      } catch (error) {
+        if (error instanceof LocalNoSqlDbStorageRootRelocationError) {
+          operationError = error;
+        } else {
+          const requestWasDispatched = error instanceof Error
+            && 'requestId' in error
+            && typeof error.requestId === 'string';
+          if (
+            requestWasDispatched
+            && error instanceof Error
+            && 'responseErrorCode' in error
+            && isLocalNoSqlDbStorageRootRelocationErrorCode(error.responseErrorCode)
+          ) {
+            operationError = new LocalNoSqlDbStorageRootRelocationError(error.responseErrorCode);
+          } else {
+            operationError = new LocalNoSqlDbStorageRootRelocationError(
+              requestWasDispatched ? 'RECOVERY_REQUIRED' : 'IO',
+            );
+          }
+        }
+      }
+
+      if (bridge) {
+        try {
+          await bridge.terminate({ gracePeriodMs: 0 });
+          if (!bridge.ownershipReleased) {
+            throw new Error('termination was not confirmed');
+          }
+          if (LocalNoSqlDb.storageRootRelocationBridge === bridge) {
+            LocalNoSqlDb.storageRootRelocationBridge = undefined;
+          }
+        } catch {
+          operationError = new LocalNoSqlDbStorageRootRelocationError('RECOVERY_REQUIRED');
+        }
+      }
+      if (operationError) throw operationError;
+      if (!receipt) {
+        throw new LocalNoSqlDbStorageRootRelocationError('RECOVERY_REQUIRED');
+      }
+      return receipt;
+    });
+  }
+
+  private static async runOfflineInspection<
+    TInput extends { folderPath: string },
+    TResult,
+  >(
+    inputArg: TInput,
+    optionsArg: INoSqlDbManagementOperationOptions | undefined,
+    normalizeInputArg: (inputArg: TInput) => TInput,
+    inspectArg: (
+      bridgeArg: RustDbBridge,
+      inputArg: TInput,
+      optionsArg?: INoSqlDbManagementOperationOptions,
+    ) => Promise<TResult>,
+  ): Promise<TResult> {
+    const validatedInput = normalizeInputArg(inputArg);
+    validateNoSqlDbManagementOperationOptions(optionsArg);
+    optionsArg?.signal?.throwIfAborted();
+
+    const input = normalizeInputArg({
+      ...validatedInput,
+      folderPath: path.resolve(validatedInput.folderPath),
+    });
+    const deadline = optionsArg?.timeoutMs === undefined
+      ? undefined
+      : Date.now() + optionsArg.timeoutMs;
+    const bridge = LocalNoSqlDb.createOfflineInspectionBridge();
+    let operationFailed = false;
+    let operationError: unknown;
+    let result: TResult | undefined;
+    try {
+      let spawnOptions = optionsArg;
+      if (deadline !== undefined) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+          throw new Error('NoSQLDB offline inspection timed out before sidecar spawn');
+        }
+        spawnOptions = {
+          signal: optionsArg?.signal,
+          timeoutMs: remainingMs,
+        };
+      }
+      if (!await bridge.spawn(spawnOptions)) {
+        throw new Error(
+          'nosqldb Rust binary not found. Set NOSQLDB_RUST_BINARY env var, ' +
+          'install the platform package, or build locally with `tsrust`.',
+        );
+      }
+      let commandOptions = optionsArg;
+      if (deadline !== undefined) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+          throw new Error('NoSQLDB offline inspection timed out while starting the sidecar');
+        }
+        commandOptions = {
+          signal: optionsArg?.signal,
+          timeoutMs: remainingMs,
+        };
+      }
+      result = await inspectArg(bridge, input, commandOptions);
+    } catch (error) {
+      operationFailed = true;
+      operationError = error;
+    }
+
+    try {
+      await bridge.terminate({ gracePeriodMs: 0 });
+    } catch (terminationError) {
+      if (operationFailed) {
+        throw new AggregateError(
+          [operationError, terminationError],
+          'NoSQLDB offline inspection failed and sidecar termination was incomplete',
+          { cause: operationError },
+        );
+      }
+      throw terminationError;
+    }
+    if (operationFailed) {
+      throw operationError;
+    }
+    return result as TResult;
+  }
+
+  /**
+   * Inspect physical database and collection names while the owning engine is stopped.
+   * This starts only the Rust management sidecar and never initializes storage.
+   */
+  public static async inspectOfflinePhysicalNamespaces(
+    inputArg: ILocalNoSqlDbOfflinePhysicalNamespaceInspection,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult> {
+    return LocalNoSqlDb.runOfflineInspection(
+      inputArg,
+      optionsArg,
+      normalizeLocalNoSqlDbOfflinePhysicalNamespaceInspectionInput,
+      (bridgeArg, input, commandOptions) =>
+        bridgeArg.inspectOfflinePhysicalNamespaces(input, commandOptions),
+    );
+  }
+
+  /**
+   * Inspect one exact string value while the owning LocalNoSqlDb engine is stopped.
+   * This starts only the Rust management sidecar and never initializes storage.
+   */
+  public static async inspectOfflineStringValue(
+    inputArg: ILocalNoSqlDbOfflineStringValueInspection,
+    optionsArg?: INoSqlDbManagementOperationOptions,
+  ): Promise<TLocalNoSqlDbOfflineStringValueInspectionResult> {
+    return LocalNoSqlDb.runOfflineInspection(
+      inputArg,
+      optionsArg,
+      normalizeLocalNoSqlDbOfflineInspectionInput,
+      (bridgeArg, input, commandOptions) =>
+        bridgeArg.inspectOfflineStringValue(input, commandOptions),
+    );
+  }
+
+  /**
+   * Generate a unique socket path in /tmp
+   */
+  private generateSocketPath(): string {
+    const randomId = crypto.randomBytes(8).toString('hex');
+    return path.join(os.tmpdir(), `nosqldb-${randomId}.sock`);
+  }
+
+  /**
+   * Check if a Unix socket is alive by attempting to connect.
+   */
+  private static isSocketAlive(socketPath: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const client = net.createConnection({ path: socketPath }, () => {
+        client.destroy();
+        resolve(true);
+      });
+      client.on('error', () => {
+        resolve(false);
+      });
+      client.setTimeout(500, () => {
+        client.destroy();
+        resolve(false);
+      });
+    });
+  }
+
+  /**
+   * Remove stale nosqldb-*.sock files from /tmp.
+   * A socket is considered stale if connecting to it fails.
+   */
+  private static async cleanStaleSockets(): Promise<void> {
+    const tmpDir = os.tmpdir();
+    let entries: string[];
+    try {
+      entries = await fs.readdir(tmpDir);
+    } catch {
+      return;
+    }
+    const socketFiles = entries.filter(
+      (f) => f.startsWith('nosqldb-') && f.endsWith('.sock')
+    );
+    for (const name of socketFiles) {
+      const fullPath = path.join(tmpDir, name);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (!stat.isSocket()) continue;
+        const alive = await LocalNoSqlDb.isSocketAlive(fullPath);
+        if (!alive) {
+          await fs.unlink(fullPath);
+        }
+      } catch {
+        // File may have been removed already; ignore
+      }
+    }
+  }
+
+  /**
+   * Start the local NoSQLDB server and return connection info
+   */
+  async start(): Promise<ILocalNoSqlDbConnectionInfo> {
+    if (this.server) {
+      throw new Error('LocalNoSqlDb is already running');
+    }
+
+    // Use provided socket path or generate one
+    this.generatedSocketPath = this.options.socketPath ?? this.generateSocketPath();
+
+    this.server = new NoSqlDbServer({
+      binaryPath: this.options.binaryPath,
+      storageRehearsalId: this.options.storageRehearsalId,
+      auth: this.options.auth,
+      fileStorageStartup: this.options.fileStorageStartup,
+      socketPath: this.generatedSocketPath,
+      storage: 'file',
+      storagePath: this.options.folderPath,
+    });
+    await this.server.start();
+
+    return {
+      socketPath: this.generatedSocketPath,
+      connectionUri: this.server.getConnectionUri(),
+    };
+  }
+
+  /**
+   * Get connection info (throws if not started)
+   */
+  getConnectionInfo(): ILocalNoSqlDbConnectionInfo {
+    if (!this.server || !this.generatedSocketPath) {
+      throw new Error('LocalNoSqlDb is not running. Call start() first.');
+    }
+    return {
+      socketPath: this.generatedSocketPath,
+      connectionUri: this.server.getConnectionUri(),
+    };
+  }
+
+  /**
+   * Get the underlying NoSqlDbServer instance (throws if not started)
+   */
+  getServer(): NoSqlDbServer {
+    if (!this.server) {
+      throw new Error('LocalNoSqlDb is not running. Call start() first.');
+    }
+    return this.server;
+  }
+
+  /**
+   * Get the connection URI
+   */
+  getConnectionUri(): string {
+    if (!this.server) {
+      throw new Error('LocalNoSqlDb is not running. Call start() first.');
+    }
+    return this.server.getConnectionUri();
+  }
+
+  /**
+   * Check if the server is running
+   */
+  get running(): boolean {
+    return this.server !== null && this.server.running;
+  }
+
+  /**
+   * Stop the local NoSQLDB server
+   */
+  async stop(): Promise<void> {
+    if (this.server) {
+      await this.server.stop();
+      this.server = null;
+      this.generatedSocketPath = null;
+    }
+  }
+}

package/ts/ts_local/index.ts

@@ -0,0 +1,19 @@
+export { LocalNoSqlDb } from './classes.localnosqldb.js';
+export type { ILocalNoSqlDbOptions, ILocalNoSqlDbConnectionInfo } from './classes.localnosqldb.js';
+export type {
+  ILocalNoSqlDbOfflineInspectionLimits,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspectionLimits,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspection,
+  ILocalNoSqlDbOfflinePhysicalNamespaceInspectionResult,
+  ILocalNoSqlDbOfflineStringValueInspection,
+  TLocalNoSqlDbOfflineStringValueInspectionResult,
+} from '../ts_nosqldb/service-types.js';
+export type {
+  ILocalNoSqlDbStoppedStorageRootRelocationInput,
+  ILocalNoSqlDbStoppedStorageRootRelocationReceipt,
+  TLocalNoSqlDbStorageRootRelocationErrorCode,
+} from '../ts_nosqldb/storage-root-relocation.js';
+export {
+  LocalNoSqlDbStorageRootRelocationError,
+  localNoSqlDbStorageRootRelocationErrorCodes,
+} from '../ts_nosqldb/storage-root-relocation.js';

package/ts/ts_local/plugins.ts

@@ -0,0 +1 @@
+// Local module plugins - currently no external dependencies needed