@lossless.org/nosqldb 8.0.0

package/dist_ts/ts_local/classes.localnosqldb.js

@@ -0,0 +1,386 @@
+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, } from '../ts_nosqldb/index.js';
+import { RustDbBridge, rustDbBridgeStorageRootRelocation, } from '../ts_nosqldb/rust-db-bridge.js';
+import { validateNoSqlDbStorageRehearsalStartup } from '../ts_nosqldb/storage-rehearsal.js';
+import {} 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';
+/**
+ * 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 {
+    static { this.storageRootRelocationGate = Promise.resolve(); }
+    constructor(options) {
+        this.server = null;
+        this.generatedSocketPath = null;
+        validateNoSqlDbStorageRehearsalStartup({ ...options, storage: 'file', storagePath: options.folderPath });
+        this.options = {
+            ...options,
+            ...normalizeNoSqlDbFileStorageOptions({ ...options, storage: 'file' }),
+        };
+    }
+    static createOfflineInspectionBridge() {
+        return new RustDbBridge();
+    }
+    static createStorageRootRelocationBridge() {
+        return new RustDbBridge();
+    }
+    static async withStorageRootRelocationGate(operationArg) {
+        const previous = LocalNoSqlDb.storageRootRelocationGate;
+        let release;
+        LocalNoSqlDb.storageRootRelocationGate = new Promise((resolveArg) => {
+            release = resolveArg;
+        });
+        await previous;
+        try {
+            return await operationArg();
+        }
+        finally {
+            release();
+        }
+    }
+    static remainingManagementTimeout(deadlineArg) {
+        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.
+     */
+    static async relocateStoppedStorageRoot(inputArg, optionsArg) {
+        let input;
+        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;
+            let receipt;
+            let operationError;
+            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;
+        });
+    }
+    static async runOfflineInspection(inputArg, optionsArg, normalizeInputArg, inspectArg) {
+        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;
+        let result;
+        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;
+    }
+    /**
+     * Inspect physical database and collection names while the owning engine is stopped.
+     * This starts only the Rust management sidecar and never initializes storage.
+     */
+    static async inspectOfflinePhysicalNamespaces(inputArg, optionsArg) {
+        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.
+     */
+    static async inspectOfflineStringValue(inputArg, optionsArg) {
+        return LocalNoSqlDb.runOfflineInspection(inputArg, optionsArg, normalizeLocalNoSqlDbOfflineInspectionInput, (bridgeArg, input, commandOptions) => bridgeArg.inspectOfflineStringValue(input, commandOptions));
+    }
+    /**
+     * Generate a unique socket path in /tmp
+     */
+    generateSocketPath() {
+        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.
+     */
+    static isSocketAlive(socketPath) {
+        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.
+     */
+    static async cleanStaleSockets() {
+        const tmpDir = os.tmpdir();
+        let entries;
+        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() {
+        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() {
+        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() {
+        if (!this.server) {
+            throw new Error('LocalNoSqlDb is not running. Call start() first.');
+        }
+        return this.server;
+    }
+    /**
+     * Get the connection URI
+     */
+    getConnectionUri() {
+        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() {
+        return this.server !== null && this.server.running;
+    }
+    /**
+     * Stop the local NoSQLDB server
+     */
+    async stop() {
+        if (this.server) {
+            await this.server.stop();
+            this.server = null;
+            this.generatedSocketPath = null;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.localnosqldb.js","sourceRoot":"","sources":["../../ts/ts_local/classes.localnosqldb.ts"],"names":[],"mappings":"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"}

package/dist_ts/ts_local/index.d.ts

@@ -0,0 +1,5 @@
+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/dist_ts/ts_local/index.js

@@ -0,0 +1,3 @@
+export { LocalNoSqlDb } from './classes.localnosqldb.js';
+export { LocalNoSqlDbStorageRootRelocationError, localNoSqlDbStorageRootRelocationErrorCodes, } from '../ts_nosqldb/storage-root-relocation.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19sb2NhbC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFlekQsT0FBTyxFQUNMLHNDQUFzQyxFQUN0QywyQ0FBMkMsR0FDNUMsTUFBTSwwQ0FBMEMsQ0FBQyJ9

package/dist_ts/ts_local/plugins.d.ts

@@ -0,0 +1 @@
+export {};

package/dist_ts/ts_local/plugins.js

@@ -0,0 +1,3 @@
+export {};
+// Local module plugins - currently no external dependencies needed
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3RzX2xvY2FsL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLG1FQUFtRSJ9

package/dist_ts/ts_nosqldb/classes.storagerehearsal.d.ts

@@ -0,0 +1,19 @@
+import type { INoSqlDbManagementOperationOptions } from './service-types.js';
+import { type INoSqlDbStorageRehearsalInput, type INoSqlDbStorageRehearsalOptions, type INoSqlDbStorageRehearsalReceipt } from './storage-rehearsal.js';
+/** Owns one offline rehearsal sidecar at a time. Separate instances are independent;
+ * native root ownership excludes concurrent use of a source or destination. */
+export declare class NoSqlDbStorageRehearsal {
+    private readonly binaryPath;
+    private bridge;
+    private cancellation;
+    private completion;
+    constructor(options?: INoSqlDbStorageRehearsalOptions);
+    /** Create or exactly retry a rehearsal. The default deadline is one hour,
+     * including spawn and the operation; maximum 24 hours. Cleanup confirms exit
+     * before this method settles. Retry the identical request after interruption. */
+    createDestination(inputArg: INoSqlDbStorageRehearsalInput, optionsArg?: INoSqlDbManagementOperationOptions): Promise<INoSqlDbStorageRehearsalReceipt>;
+    /** Cancel active work and confirm sidecar exit. Retry this method if cleanup
+     * reports RECOVERY_REQUIRED; the instance retains unconfirmed ownership. */
+    stop(): Promise<void>;
+    private terminateBridge;
+}

package/dist_ts/ts_nosqldb/classes.storagerehearsal.js

@@ -0,0 +1,122 @@
+import { RustDbBridge, rustDbBridgeStorageRehearsal } from './rust-db-bridge.js';
+import { normalizeNoSqlDbStorageRehearsalInput, normalizeNoSqlDbStorageRehearsalReceipt, normalizeNoSqlDbStorageRehearsalOptions, normalizeNoSqlDbStorageRehearsalOperationOptions, NoSqlDbStorageRehearsalError, noSqlDbStorageRehearsalErrorCodes, } from './storage-rehearsal.js';
+/** Owns one offline rehearsal sidecar at a time. Separate instances are independent;
+ * native root ownership excludes concurrent use of a source or destination. */
+export class NoSqlDbStorageRehearsal {
+    constructor(options = {}) {
+        this.binaryPath = normalizeNoSqlDbStorageRehearsalOptions(options).binaryPath;
+    }
+    /** Create or exactly retry a rehearsal. The default deadline is one hour,
+     * including spawn and the operation; maximum 24 hours. Cleanup confirms exit
+     * before this method settles. Retry the identical request after interruption. */
+    async createDestination(inputArg, optionsArg) {
+        let input;
+        try {
+            input = normalizeNoSqlDbStorageRehearsalInput(inputArg);
+        }
+        catch {
+            throw new NoSqlDbStorageRehearsalError('INVALID_REQUEST');
+        }
+        const options = normalizeNoSqlDbStorageRehearsalOperationOptions(optionsArg);
+        const { timeoutMs } = options;
+        if (options.signal?.aborted)
+            throw new NoSqlDbStorageRehearsalError('CANCELLED');
+        if (process.platform !== 'linux' && process.platform !== 'darwin')
+            throw new NoSqlDbStorageRehearsalError('UNSUPPORTED');
+        if (this.completion)
+            throw new NoSqlDbStorageRehearsalError('BUSY');
+        const deadline = performance.now() + timeoutMs;
+        const controller = new AbortController();
+        this.cancellation = controller;
+        const cancel = () => controller.abort();
+        options.signal?.addEventListener('abort', cancel, { once: true });
+        let complete;
+        this.completion = new Promise((resolve) => { complete = resolve; });
+        let dispatched = false;
+        let receipt;
+        let failure;
+        const remaining = () => {
+            const timeout = Math.ceil(deadline - performance.now());
+            if (timeout <= 0 || controller.signal.aborted)
+                throw new NoSqlDbStorageRehearsalError(dispatched ? 'RECOVERY_REQUIRED' : 'CANCELLED');
+            return timeout;
+        };
+        try {
+            // A failed previous cleanup keeps its bridge here until exit is confirmed.
+            await this.terminateBridge();
+            remaining();
+            const bridge = new RustDbBridge({ binaryPath: this.binaryPath });
+            this.bridge = bridge;
+            if (!await bridge.spawn({ timeoutMs: remaining(), signal: controller.signal })) {
+                throw new NoSqlDbStorageRehearsalError('BINARY_UNAVAILABLE');
+            }
+            const commandTimeout = remaining();
+            dispatched = true;
+            const result = await bridge[rustDbBridgeStorageRehearsal](input, {
+                timeoutMs: commandTimeout, signal: controller.signal,
+            });
+            receipt = normalizeNoSqlDbStorageRehearsalReceipt(result, input);
+        }
+        catch (error) {
+            if (error instanceof NoSqlDbStorageRehearsalError)
+                failure = error;
+            else {
+                const nativeCode = error instanceof Error && 'responseErrorCode' in error ? error.responseErrorCode : undefined;
+                const code = typeof nativeCode === 'string'
+                    && noSqlDbStorageRehearsalErrorCodes.includes(nativeCode)
+                    ? nativeCode
+                    : dispatched ? 'RECOVERY_REQUIRED' : controller.signal.aborted || performance.now() >= deadline ? 'CANCELLED' : 'BINARY_UNAVAILABLE';
+                failure = new NoSqlDbStorageRehearsalError(code);
+            }
+        }
+        finally {
+            try {
+                await this.terminateBridge();
+            }
+            catch {
+                failure = new NoSqlDbStorageRehearsalError('RECOVERY_REQUIRED');
+            }
+            options.signal?.removeEventListener('abort', cancel);
+            this.cancellation = undefined;
+            this.completion = undefined;
+            complete();
+        }
+        if (failure)
+            throw failure;
+        if (!receipt)
+            throw new NoSqlDbStorageRehearsalError('RECOVERY_REQUIRED');
+        return receipt;
+    }
+    /** Cancel active work and confirm sidecar exit. Retry this method if cleanup
+     * reports RECOVERY_REQUIRED; the instance retains unconfirmed ownership. */
+    async stop() {
+        const completion = this.completion;
+        this.cancellation?.abort();
+        let failure;
+        try {
+            await this.terminateBridge();
+        }
+        catch (error) {
+            failure = error;
+        }
+        await completion;
+        if (failure)
+            throw new NoSqlDbStorageRehearsalError('RECOVERY_REQUIRED');
+    }
+    async terminateBridge() {
+        const bridge = this.bridge;
+        if (!bridge)
+            return;
+        try {
+            await bridge.terminate({ gracePeriodMs: 0 });
+            if (!bridge.ownershipReleased)
+                throw new NoSqlDbStorageRehearsalError('RECOVERY_REQUIRED');
+            if (this.bridge === bridge)
+                this.bridge = undefined;
+        }
+        catch {
+            throw new NoSqlDbStorageRehearsalError('RECOVERY_REQUIRED');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_nosqldb/file-storage-options.d.ts

@@ -0,0 +1,13 @@
+import { type TNoSqlDbFileStorageStartup } from './file-storage-startup.js';
+interface IFileStorageOptions {
+    storage?: string;
+    fileStorageStartup?: unknown;
+    auth?: {
+        users?: unknown;
+    };
+}
+/** Pure, instance-local admission for the sole native serving engine. */
+export declare const normalizeNoSqlDbFileStorageOptions: (optionsArg: IFileStorageOptions) => {
+    fileStorageStartup: TNoSqlDbFileStorageStartup | undefined;
+};
+export {};

package/dist_ts/ts_nosqldb/file-storage-options.js

@@ -0,0 +1,24 @@
+import { normalizeNoSqlDbFileStorageStartup, } from './file-storage-startup.js';
+/** Pure, instance-local admission for the sole native serving engine. */
+export const normalizeNoSqlDbFileStorageOptions = (optionsArg) => {
+    for (const removed of ['fileStorageEngine', 'persistPath', 'persistIntervalMs']) {
+        if (removed in optionsArg)
+            throw new TypeError(`NoSQLDB ${removed} has been removed; native memory and file storage are selected by storage`);
+    }
+    if (optionsArg.auth && 'usersPath' in optionsArg.auth) {
+        throw new TypeError('NoSQLDB auth.usersPath has been removed; authentication is stored in the native database');
+    }
+    const storage = optionsArg.storage ?? 'memory';
+    if (storage !== 'file' && storage !== 'memory')
+        throw new TypeError('NoSQLDB storage must be "memory" or "file"');
+    if (process.platform !== 'linux' && process.platform !== 'darwin') {
+        throw new TypeError('NoSQLDB native storage requires Linux or macOS');
+    }
+    if (optionsArg.fileStorageStartup !== undefined && storage !== 'file') {
+        throw new TypeError('NoSQLDB fileStorageStartup requires storage: "file"');
+    }
+    return {
+        fileStorageStartup: storage === 'file' ? normalizeNoSqlDbFileStorageStartup(optionsArg.fileStorageStartup) : undefined,
+    };
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1zdG9yYWdlLW9wdGlvbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19ub3NxbGRiL2ZpbGUtc3RvcmFnZS1vcHRpb25zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxrQ0FBa0MsR0FFbkMsTUFBTSwyQkFBMkIsQ0FBQztBQVFuQyx5RUFBeUU7QUFDekUsTUFBTSxDQUFDLE1BQU0sa0NBQWtDLEdBQUcsQ0FBQyxVQUErQixFQUVoRixFQUFFO0lBQ0YsS0FBSyxNQUFNLE9BQU8sSUFBSSxDQUFDLG1CQUFtQixFQUFFLGFBQWEsRUFBRSxtQkFBbUIsQ0FBQyxFQUFFLENBQUM7UUFDaEYsSUFBSSxPQUFPLElBQUksVUFBVTtZQUFFLE1BQU0sSUFBSSxTQUFTLENBQUMsV0FBVyxPQUFPLDJFQUEyRSxDQUFDLENBQUM7SUFDaEosQ0FBQztJQUNELElBQUksVUFBVSxDQUFDLElBQUksSUFBSSxXQUFXLElBQUksVUFBVSxDQUFDLElBQUksRUFBRSxDQUFDO1FBQ3RELE1BQU0sSUFBSSxTQUFTLENBQUMsMEZBQTBGLENBQUMsQ0FBQztJQUNsSCxDQUFDO0lBQ0QsTUFBTSxPQUFPLEdBQUcsVUFBVSxDQUFDLE9BQU8sSUFBSSxRQUFRLENBQUM7SUFDL0MsSUFBSSxPQUFPLEtBQUssTUFBTSxJQUFJLE9BQU8sS0FBSyxRQUFRO1FBQUUsTUFBTSxJQUFJLFNBQVMsQ0FBQyw0Q0FBNEMsQ0FBQyxDQUFDO0lBQ2xILElBQUksT0FBTyxDQUFDLFFBQVEsS0FBSyxPQUFPLElBQUksT0FBTyxDQUFDLFFBQVEsS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUNsRSxNQUFNLElBQUksU0FBUyxDQUFDLGdEQUFnRCxDQUFDLENBQUM7SUFDeEUsQ0FBQztJQUNELElBQUksVUFBVSxDQUFDLGtCQUFrQixLQUFLLFNBQVMsSUFBSSxPQUFPLEtBQUssTUFBTSxFQUFFLENBQUM7UUFDdEUsTUFBTSxJQUFJLFNBQVMsQ0FBQyxxREFBcUQsQ0FBQyxDQUFDO0lBQzdFLENBQUM7SUFDRCxPQUFPO1FBQ0wsa0JBQWtCLEVBQUUsT0FBTyxLQUFLLE1BQU0sQ0FBQyxDQUFDLENBQUMsa0NBQWtDLENBQUMsVUFBVSxDQUFDLGtCQUFrQixDQUFDLENBQUMsQ0FBQyxDQUFDLFNBQVM7S0FDdkgsQ0FBQztBQUNKLENBQUMsQ0FBQyJ9

package/dist_ts/ts_nosqldb/file-storage-startup.d.ts

@@ -0,0 +1,3 @@
+/** Native format admission is read-only until the engine owns the file root. */
+export type TNoSqlDbFileStorageStartup = 'current-format-only';
+export declare const normalizeNoSqlDbFileStorageStartup: (valueArg: unknown) => TNoSqlDbFileStorageStartup;

package/dist_ts/ts_nosqldb/file-storage-startup.js

@@ -0,0 +1,6 @@
+export const normalizeNoSqlDbFileStorageStartup = (valueArg) => {
+    if (valueArg === undefined || valueArg === 'current-format-only')
+        return 'current-format-only';
+    throw new TypeError('NoSQLDB fileStorageStartup must be "current-format-only"; automatic storage conversion has been removed');
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS1zdG9yYWdlLXN0YXJ0dXAuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19ub3NxbGRiL2ZpbGUtc3RvcmFnZS1zdGFydHVwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sQ0FBQyxNQUFNLGtDQUFrQyxHQUFHLENBQ2hELFFBQWlCLEVBQ1csRUFBRTtJQUM5QixJQUFJLFFBQVEsS0FBSyxTQUFTLElBQUksUUFBUSxLQUFLLHFCQUFxQjtRQUFFLE9BQU8scUJBQXFCLENBQUM7SUFDL0YsTUFBTSxJQUFJLFNBQVMsQ0FBQyx5R0FBeUcsQ0FBQyxDQUFDO0FBQ2pJLENBQUMsQ0FBQyJ9