@push.rocks/smartdb 3.0.0 → 3.0.2

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartdb',
-    version: '3.0.0',
+    version: '3.0.2',
     description: 'A MongoDB-compatible embedded database server with wire protocol support, backed by a high-performance Rust engine.'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxxQkFBcUI7SUFDM0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFIQUFxSDtDQUNuSSxDQUFBIn0=

package/dist_ts/ts_migration/classes.authmetadatamigrationrunner.d.ts

@@ -1,8 +1,9 @@
 import { type IAuthMetadataPermissionMigrationBridge, type TAuthMetadataPermissionMigrationStatus } from './migrators/v1_auth_metadata_permissions.js';
+import type { ISmartDbManagementOperationOptions } from '../ts_smartdb/service-types.js';
 export type TAuthMetadataMigrationRunnerStatus = TAuthMetadataPermissionMigrationStatus | 'not-applicable';
 export declare class AuthMetadataMigrationRunner {
     private readonly usersPath;
     constructor(usersPath: string);
-    run(bridgeArg: IAuthMetadataPermissionMigrationBridge): Promise<TAuthMetadataMigrationRunnerStatus>;
+    run(bridgeArg: IAuthMetadataPermissionMigrationBridge, optionsArg?: ISmartDbManagementOperationOptions): Promise<TAuthMetadataMigrationRunnerStatus>;
 }
 export type { IAuthMetadataPermissionMigrationBridge };

package/dist_ts/ts_migration/classes.authmetadatamigrationrunner.js

@@ -4,14 +4,14 @@ export class AuthMetadataMigrationRunner {
     constructor(usersPath) {
         this.usersPath = usersPath;
     }
-    async run(bridgeArg) {
+    async run(bridgeArg, optionsArg) {
         if (process.platform !== 'linux')
             return 'not-applicable';
         let status = 'not-present';
         for (const migration of authMetadataMigrations) {
-            status = await migration(bridgeArg, this.usersPath);
+            status = await migration(bridgeArg, this.usersPath, optionsArg);
         }
         return status;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5hdXRobWV0YWRhdGFtaWdyYXRpb25ydW5uZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vY2xhc3Nlcy5hdXRobWV0YWRhdGFtaWdyYXRpb25ydW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLGdDQUFnQyxHQUdqQyxNQUFNLDZDQUE2QyxDQUFDO0FBRXJELE1BQU0sc0JBQXNCLEdBQUcsQ0FBQyxnQ0FBZ0MsQ0FBVSxDQUFDO0FBTTNFLE1BQU0sT0FBTywyQkFBMkI7SUFDdEMsWUFBNkIsU0FBaUI7UUFBakIsY0FBUyxHQUFULFNBQVMsQ0FBUTtJQUFHLENBQUM7SUFFM0MsS0FBSyxDQUFDLEdBQUcsQ0FDZCxTQUFpRDtRQUVqRCxJQUFJLE9BQU8sQ0FBQyxRQUFRLEtBQUssT0FBTztZQUFFLE9BQU8sZ0JBQWdCLENBQUM7UUFDMUQsSUFBSSxNQUFNLEdBQTJDLGFBQWEsQ0FBQztRQUNuRSxLQUFLLE1BQU0sU0FBUyxJQUFJLHNCQUFzQixFQUFFLENBQUM7WUFDL0MsTUFBTSxHQUFHLE1BQU0sU0FBUyxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDdEQsQ0FBQztRQUNELE9BQU8sTUFBTSxDQUFDO0lBQ2hCLENBQUM7Q0FDRiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5hdXRobWV0YWRhdGFtaWdyYXRpb25ydW5uZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vY2xhc3Nlcy5hdXRobWV0YWRhdGFtaWdyYXRpb25ydW5uZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLGdDQUFnQyxHQUdqQyxNQUFNLDZDQUE2QyxDQUFDO0FBR3JELE1BQU0sc0JBQXNCLEdBQUcsQ0FBQyxnQ0FBZ0MsQ0FBVSxDQUFDO0FBTTNFLE1BQU0sT0FBTywyQkFBMkI7SUFDdEMsWUFBNkIsU0FBaUI7UUFBakIsY0FBUyxHQUFULFNBQVMsQ0FBUTtJQUFHLENBQUM7SUFFM0MsS0FBSyxDQUFDLEdBQUcsQ0FDZCxTQUFpRCxFQUNqRCxVQUErQztRQUUvQyxJQUFJLE9BQU8sQ0FBQyxRQUFRLEtBQUssT0FBTztZQUFFLE9BQU8sZ0JBQWdCLENBQUM7UUFDMUQsSUFBSSxNQUFNLEdBQTJDLGFBQWEsQ0FBQztRQUNuRSxLQUFLLE1BQU0sU0FBUyxJQUFJLHNCQUFzQixFQUFFLENBQUM7WUFDL0MsTUFBTSxHQUFHLE1BQU0sU0FBUyxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsU0FBUyxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ2xFLENBQUM7UUFDRCxPQUFPLE1BQU0sQ0FBQztJQUNoQixDQUFDO0NBQ0YifQ==

package/dist_ts/ts_migration/classes.storagemigrator.d.ts

@@ -13,7 +13,7 @@ export declare class StorageMigrator {
     /**
      * Run any needed migrations. Safe to call even if storage is already current.
      */
-    run(): Promise<void>;
+    run(signalArg?: AbortSignal): Promise<void>;
     /**
      * Detect the storage format version by inspecting the directory structure.
      *
@@ -21,4 +21,5 @@ export declare class StorageMigrator {
      * v1: {db}/{coll}/data.rdb directories exist
      */
     private detectVersion;
+    private pathExists;
 }

package/dist_ts/ts_migration/classes.storagemigrator.js

@@ -1,5 +1,5 @@
-import * as fs from 'fs';
-import * as path from 'path';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
 import { migrateV0ToV1 } from './migrators/v0_to_v1.js';
 /**
  * StorageMigrator — runs before the Rust engine starts.
@@ -17,18 +17,21 @@ export class StorageMigrator {
     /**
      * Run any needed migrations. Safe to call even if storage is already current.
      */
-    async run() {
-        if (!fs.existsSync(this.storagePath)) {
+    async run(signalArg) {
+        signalArg?.throwIfAborted();
+        if (!await this.pathExists(this.storagePath)) {
             return; // No data yet — nothing to migrate
         }
-        const version = this.detectVersion();
+        const version = await this.detectVersion(signalArg);
+        signalArg?.throwIfAborted();
         if (version === 1) {
             return; // Already current
         }
         if (version === 0) {
             console.log(`[smartdb] Detected v0 (JSON) storage format at ${this.storagePath}`);
             console.log(`[smartdb] Running migration v0 → v1 (Bitcask binary format)...`);
-            const deletableFiles = await migrateV0ToV1(this.storagePath);
+            const deletableFiles = await migrateV0ToV1(this.storagePath, signalArg);
+            signalArg?.throwIfAborted();
             if (deletableFiles.length > 0) {
                 console.log(`[smartdb] Migration v0 → v1 complete.`);
                 console.log(`[smartdb] The following old files can be safely deleted:`);
@@ -47,33 +50,46 @@ export class StorageMigrator {
      * v0: {db}/{coll}.json files exist
      * v1: {db}/{coll}/data.rdb directories exist
      */
-    detectVersion() {
-        const entries = fs.readdirSync(this.storagePath, { withFileTypes: true });
+    async detectVersion(signalArg) {
+        signalArg?.throwIfAborted();
+        const entries = await fs.readdir(this.storagePath, { withFileTypes: true });
+        let hasLegacyCollections = false;
         for (const entry of entries) {
+            signalArg?.throwIfAborted();
             if (!entry.isDirectory())
                 continue;
             if (entry.name.startsWith('.__rustdb_'))
                 continue;
             const dbDir = path.join(this.storagePath, entry.name);
-            const dbEntries = fs.readdirSync(dbDir, { withFileTypes: true });
+            const dbEntries = await fs.readdir(dbDir, { withFileTypes: true });
             for (const dbEntry of dbEntries) {
+                signalArg?.throwIfAborted();
+                if (dbEntry.isDirectory()
+                    && dbEntry.name.startsWith('.__rustdb_migration_')) {
+                    throw new Error(`SmartDB legacy migration staging is orphaned: ${path.join(dbDir, dbEntry.name)}`);
+                }
                 if (dbEntry.name.startsWith('.__rustdb_'))
                     continue;
-                // v1: subdirectory with data.rdb
-                if (dbEntry.isDirectory()) {
-                    const dataRdb = path.join(dbDir, dbEntry.name, 'data.rdb');
-                    if (fs.existsSync(dataRdb)) {
-                        return 1;
-                    }
-                }
                 // v0: .json file (not .indexes.json)
                 if (dbEntry.isFile() && dbEntry.name.endsWith('.json') && !dbEntry.name.endsWith('.indexes.json')) {
-                    return 0;
+                    hasLegacyCollections = true;
                 }
             }
         }
-        // Empty or unrecognized — treat as v1 (fresh start)
-        return 1;
+        // A mixed layout is an interrupted/resumable migration, not proof that the
+        // complete storage root is already current.
+        return hasLegacyCollections ? 0 : 1;
+    }
+    async pathExists(pathArg) {
+        try {
+            await fs.stat(pathArg);
+            return true;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return false;
+            throw error;
+        }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_migration/index.d.ts

@@ -1,2 +1,3 @@
 export { StorageMigrator } from './classes.storagemigrator.js';
+export { SmartDbStorageMigrationCleanupError } from './migrators/v0_to_v1.js';
 export { AuthMetadataMigrationRunner, type IAuthMetadataPermissionMigrationBridge, type TAuthMetadataMigrationRunnerStatus, } from './classes.authmetadatamigrationrunner.js';

package/dist_ts/ts_migration/index.js

@@ -1,3 +1,4 @@
 export { StorageMigrator } from './classes.storagemigrator.js';
+export { SmartDbStorageMigrationCleanupError } from './migrators/v0_to_v1.js';
 export { AuthMetadataMigrationRunner, } from './classes.authmetadatamigrationrunner.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQy9ELE9BQU8sRUFDTCwyQkFBMkIsR0FHNUIsTUFBTSwwQ0FBMEMsQ0FBQyJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19taWdyYXRpb24vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQy9ELE9BQU8sRUFBRSxtQ0FBbUMsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzlFLE9BQU8sRUFDTCwyQkFBMkIsR0FHNUIsTUFBTSwwQ0FBMEMsQ0FBQyJ9

package/dist_ts/ts_migration/migrators/v0_to_v1.d.ts

@@ -1,3 +1,9 @@
+export declare class SmartDbStorageMigrationCleanupError extends AggregateError {
+    constructor(operationErrorArg: unknown, cleanupErrorsArg: unknown[]);
+}
+export declare const runWithOwnedMigrationFileHandle: <TResult, TFileHandle extends {
+    close(): Promise<void>;
+}>(fileHandleArg: TFileHandle, operationArg: (fileHandleArg: TFileHandle) => Promise<TResult>, signalArg?: AbortSignal) => Promise<TResult>;
 /**
  * Migrate a storage directory from v0 (JSON-per-collection) to v1 (Bitcask binary).
  *
@@ -6,4 +12,4 @@
  * - Returns a list of old files that can be safely deleted.
  * - On failure, cleans up any partial new files and throws.
  */
-export declare function migrateV0ToV1(storagePath: string): Promise<string[]>;
+export declare function migrateV0ToV1(storagePath: string, signalArg?: AbortSignal): Promise<string[]>;

package/dist_ts/ts_migration/migrators/v0_to_v1.js

@@ -1,6 +1,6 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as crypto from 'crypto';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as crypto from 'node:crypto';
 import { BSON } from 'bson';
 // ---------------------------------------------------------------------------
 // Binary format constants (must match Rust: record.rs)
@@ -92,6 +92,97 @@ function crc32(data) {
     }
     return (crc ^ 0xFFFFFFFF) >>> 0;
 }
+const pathExists = async (pathArg) => {
+    try {
+        await fs.stat(pathArg);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+};
+export class SmartDbStorageMigrationCleanupError extends AggregateError {
+    constructor(operationErrorArg, cleanupErrorsArg) {
+        super([operationErrorArg, ...cleanupErrorsArg], 'SmartDB legacy storage migration failed and staging cleanup was incomplete', { cause: operationErrorArg });
+        this.name = 'SmartDbStorageMigrationCleanupError';
+    }
+}
+export const runWithOwnedMigrationFileHandle = async (fileHandleArg, operationArg, signalArg) => {
+    let operationResult;
+    let operationError;
+    let operationCompleted = false;
+    try {
+        operationResult = await operationArg(fileHandleArg);
+        operationCompleted = true;
+    }
+    catch (error) {
+        operationError = error;
+    }
+    try {
+        await fileHandleArg.close();
+    }
+    catch (closeError) {
+        if (operationError !== undefined) {
+            throw new SmartDbStorageMigrationCleanupError(operationError, [closeError]);
+        }
+        if (signalArg?.aborted) {
+            throw new SmartDbStorageMigrationCleanupError(signalArg.reason, [closeError]);
+        }
+        throw closeError;
+    }
+    if (!operationCompleted)
+        throw operationError;
+    return operationResult;
+};
+const withFileHandle = async (filePathArg, flagsArg, operationArg, signalArg) => runWithOwnedMigrationFileHandle(await fs.open(filePathArg, flagsArg), operationArg, signalArg);
+const writeBuffer = async (fileHandleArg, bufferArg, signalArg) => {
+    let offset = 0;
+    while (offset < bufferArg.length) {
+        signalArg?.throwIfAborted();
+        const { bytesWritten } = await fileHandleArg.write(bufferArg, offset, bufferArg.length - offset, null);
+        if (bytesWritten <= 0) {
+            throw new Error('SmartDB storage migration write made no progress');
+        }
+        offset += bytesWritten;
+    }
+    signalArg?.throwIfAborted();
+};
+const syncDirectory = async (directoryPathArg, signalArg) => {
+    try {
+        await withFileHandle(directoryPathArg, 'r', async (directoryHandleArg) => {
+            await directoryHandleArg.sync();
+        }, signalArg);
+    }
+    catch (error) {
+        if (!['EINVAL', 'ENOTSUP'].includes(error.code || '')) {
+            throw error;
+        }
+    }
+};
+const syncFile = async (filePathArg, signalArg) => {
+    await withFileHandle(filePathArg, 'r', async (fileHandleArg) => {
+        await fileHandleArg.sync();
+    }, signalArg);
+};
+const assertPublishedMigrationComplete = async (collectionDirectoryArg) => {
+    for (const fileName of ['data.rdb', 'keydir.hint', 'indexes.json']) {
+        let fileStat;
+        try {
+            fileStat = await fs.lstat(path.join(collectionDirectoryArg, fileName));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`SmartDB legacy migration target is incomplete: ${collectionDirectoryArg}`, { cause: error });
+            }
+            throw error;
+        }
+        if (!fileStat.isFile() || fileStat.isSymbolicLink()) {
+            throw new Error(`SmartDB legacy migration target is incomplete: ${collectionDirectoryArg}`);
+        }
+    }
+};
 /**
  * Migrate a storage directory from v0 (JSON-per-collection) to v1 (Bitcask binary).
  *
@@ -100,19 +191,22 @@ function crc32(data) {
  * - Returns a list of old files that can be safely deleted.
  * - On failure, cleans up any partial new files and throws.
  */
-export async function migrateV0ToV1(storagePath) {
+export async function migrateV0ToV1(storagePath, signalArg) {
     const deletableFiles = [];
-    const createdDirs = [];
+    const stagingDirectories = new Set();
     try {
-        const dbEntries = fs.readdirSync(storagePath, { withFileTypes: true });
+        signalArg?.throwIfAborted();
+        const dbEntries = await fs.readdir(storagePath, { withFileTypes: true });
         for (const dbEntry of dbEntries) {
+            signalArg?.throwIfAborted();
             if (!dbEntry.isDirectory())
                 continue;
             if (dbEntry.name.startsWith('.__rustdb_'))
                 continue;
             const dbDir = path.join(storagePath, dbEntry.name);
-            const collFiles = fs.readdirSync(dbDir, { withFileTypes: true });
+            const collFiles = await fs.readdir(dbDir, { withFileTypes: true });
             for (const collFile of collFiles) {
+                signalArg?.throwIfAborted();
                 if (!collFile.isFile())
                     continue;
                 if (collFile.name.startsWith('.__rustdb_'))
@@ -126,28 +220,38 @@ export async function migrateV0ToV1(storagePath) {
                 const indexJsonPath = path.join(dbDir, `${collName}.indexes.json`);
                 // Target directory
                 const collDir = path.join(dbDir, collName);
-                if (fs.existsSync(collDir)) {
-                    // Already migrated
+                if (await pathExists(collDir)) {
+                    await assertPublishedMigrationComplete(collDir);
+                    if (await pathExists(indexJsonPath))
+                        deletableFiles.push(indexJsonPath);
+                    deletableFiles.push(jsonPath);
                     continue;
                 }
                 console.log(`[smartdb]   Migrating ${dbEntry.name}.${collName}...`);
                 // Read the JSON collection
-                const jsonData = fs.readFileSync(jsonPath, 'utf-8');
+                const jsonData = await fs.readFile(jsonPath, {
+                    encoding: 'utf8',
+                    signal: signalArg,
+                });
+                signalArg?.throwIfAborted();
                 const docs = JSON.parse(jsonData);
-                // Create collection directory
-                fs.mkdirSync(collDir, { recursive: true });
-                createdDirs.push(collDir);
+                // Build the complete collection in a hidden sibling and publish it
+                // atomically so cancellation can never expose partial v1 state.
+                const stagingDir = path.join(dbDir, `.__rustdb_migration_${collName}_${process.pid}_${crypto.randomBytes(8).toString('hex')}`);
+                await fs.mkdir(stagingDir);
+                stagingDirectories.add(stagingDir);
+                signalArg?.throwIfAborted();
                 // Write data.rdb
-                const dataPath = path.join(collDir, 'data.rdb');
-                const fd = fs.openSync(dataPath, 'w');
-                try {
+                const dataPath = path.join(stagingDir, 'data.rdb');
+                await withFileHandle(dataPath, 'wx', async (dataFileHandle) => {
                     // File header
                     const headerBuf = writeFileHeader(FILE_TYPE_DATA);
-                    fs.writeSync(fd, headerBuf);
+                    await writeBuffer(dataFileHandle, headerBuf, signalArg);
                     let currentOffset = BigInt(FILE_HEADER_SIZE);
                     const keydir = new Map();
                     const ts = BigInt(Date.now());
                     for (const doc of docs) {
+                        signalArg?.throwIfAborted();
                         // Extract _id
                         let idHex;
                         if (doc._id && doc._id.$oid) {
@@ -169,7 +273,7 @@ export async function migrateV0ToV1(storagePath) {
                         const keyBuf = Buffer.from(idHex, 'utf-8');
                         const valueBuf = Buffer.from(bsonBytes);
                         const record = encodeDataRecord(ts, keyBuf, valueBuf);
-                        fs.writeSync(fd, record);
+                        await writeBuffer(dataFileHandle, record, signalArg);
                         keydir.set(idHex, {
                             offset: currentOffset,
                             recordLen: record.length,
@@ -178,52 +282,63 @@ export async function migrateV0ToV1(storagePath) {
                         });
                         currentOffset += BigInt(record.length);
                     }
-                    fs.fsyncSync(fd);
-                    fs.closeSync(fd);
+                    await dataFileHandle.sync();
+                    signalArg?.throwIfAborted();
                     // Write keydir.hint
-                    const hintPath = path.join(collDir, 'keydir.hint');
-                    const hintFd = fs.openSync(hintPath, 'w');
-                    fs.writeSync(hintFd, writeFileHeader(FILE_TYPE_HINT));
-                    for (const [key, entry] of keydir) {
-                        fs.writeSync(hintFd, encodeHintEntry(key, entry.offset, entry.recordLen, entry.valueLen, entry.timestamp));
-                    }
-                    fs.fsyncSync(hintFd);
-                    fs.closeSync(hintFd);
-                }
-                catch (writeErr) {
-                    // Clean up on write failure
-                    try {
-                        fs.closeSync(fd);
-                    }
-                    catch { }
-                    throw writeErr;
-                }
+                    const hintPath = path.join(stagingDir, 'keydir.hint');
+                    await withFileHandle(hintPath, 'wx', async (hintFileHandle) => {
+                        await writeBuffer(hintFileHandle, writeFileHeader(FILE_TYPE_HINT), signalArg);
+                        for (const [key, entry] of keydir) {
+                            signalArg?.throwIfAborted();
+                            await writeBuffer(hintFileHandle, encodeHintEntry(key, entry.offset, entry.recordLen, entry.valueLen, entry.timestamp), signalArg);
+                        }
+                        await hintFileHandle.sync();
+                        signalArg?.throwIfAborted();
+                    }, signalArg);
+                }, signalArg);
                 // Copy indexes.json if it exists
-                if (fs.existsSync(indexJsonPath)) {
-                    const destIndexPath = path.join(collDir, 'indexes.json');
-                    fs.copyFileSync(indexJsonPath, destIndexPath);
+                if (await pathExists(indexJsonPath)) {
+                    const destIndexPath = path.join(stagingDir, 'indexes.json');
+                    await fs.copyFile(indexJsonPath, destIndexPath);
+                    await syncFile(destIndexPath, signalArg);
+                    signalArg?.throwIfAborted();
                     deletableFiles.push(indexJsonPath);
                 }
                 else {
                     // Write default _id index
-                    const destIndexPath = path.join(collDir, 'indexes.json');
-                    fs.writeFileSync(destIndexPath, JSON.stringify([{ name: '_id_', key: { _id: 1 } }], null, 2));
+                    const destIndexPath = path.join(stagingDir, 'indexes.json');
+                    await fs.writeFile(destIndexPath, JSON.stringify([{ name: '_id_', key: { _id: 1 } }], null, 2), { signal: signalArg });
+                    await syncFile(destIndexPath, signalArg);
+                    signalArg?.throwIfAborted();
                 }
+                await assertPublishedMigrationComplete(stagingDir);
+                await syncDirectory(stagingDir, signalArg);
+                signalArg?.throwIfAborted();
+                await fs.rename(stagingDir, collDir);
+                stagingDirectories.delete(stagingDir);
+                await syncDirectory(dbDir, signalArg);
+                signalArg?.throwIfAborted();
                 deletableFiles.push(jsonPath);
                 console.log(`[smartdb]   Migrated ${dbEntry.name}.${collName}: ${docs.length} documents`);
             }
         }
     }
     catch (err) {
-        // Clean up any partially created directories
-        for (const dir of createdDirs) {
+        const cleanupErrors = [];
+        for (const dir of Array.from(stagingDirectories).reverse()) {
             try {
-                fs.rmSync(dir, { recursive: true, force: true });
+                await fs.rm(dir, { recursive: true, force: true });
+                await syncDirectory(path.dirname(dir));
+            }
+            catch (cleanupError) {
+                cleanupErrors.push(cleanupError);
             }
-            catch { }
+        }
+        if (cleanupErrors.length > 0) {
+            throw new SmartDbStorageMigrationCleanupError(err, cleanupErrors);
         }
         throw err;
     }
     return deletableFiles;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v0_to_v1.js","sourceRoot":"","sources":["../../../ts/ts_migration/migrators/v0_to_v1.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"v0_to_v1.js","sourceRoot":"","sources":["../../../ts/ts_migration/migrators/v0_to_v1.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACvC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE5B,8EAA8E;AAC9E,uDAAuD;AACvD,8EAA8E;AAE9E,oCAAoC;AACpC,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AACrD,6BAA6B;AAC7B,MAAM,cAAc,GAAG,CAAC,CAAC;AACzB,qBAAqB;AACrB,MAAM,cAAc,GAAG,CAAC,CAAC;AACzB,MAAM,cAAc,GAAG,CAAC,CAAC;AACzB,6BAA6B;AAC7B,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAC5B,uBAAuB;AACvB,MAAM,YAAY,GAAG,MAAM,CAAC;AAC5B,6BAA6B;AAC7B,MAAM,kBAAkB,GAAG,EAAE,CAAC,CAAC,oBAAoB;AAEnD,8EAA8E;AAC9E,0BAA0B;AAC1B,8EAA8E;AAE9E,SAAS,eAAe,CAAC,QAAgB;IACvC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC;IAC9C,UAAU,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IACxB,GAAG,CAAC,aAAa,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC;IACrC,GAAG,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IAC7B,GAAG,CAAC,aAAa,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ;IAClC,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;IAC/B,GAAG,CAAC,gBAAgB,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAC9B,oCAAoC;IACpC,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,gBAAgB,CAAC,SAAiB,EAAE,GAAW,EAAE,KAAa;IACrE,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAC1B,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC5B,MAAM,SAAS,GAAG,kBAAkB,GAAG,MAAM,GAAG,MAAM,CAAC;IACvD,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAEpC,oCAAoC;IACpC,GAAG,CAAC,aAAa,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC;IACnC,GAAG,CAAC,gBAAgB,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;IACnC,GAAG,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC9B,GAAG,CAAC,aAAa,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;IAC9B,qDAAqD;IACrD,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,kBAAkB,CAAC,CAAC;IAClC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,kBAAkB,GAAG,MAAM,CAAC,CAAC;IAE7C,uDAAuD;IACvD,+BAA+B;IAC/B,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC;QAC9B,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,EAAE,CAAC;QACnB,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;KACjB,CAAC,CAAC,CAAC;IACJ,GAAG,CAAC,aAAa,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAE3B,OAAO,GAAG,CAAC;AACb,CAAC;AAED,SAAS,eAAe,CAAC,GAAW,EAAE,MAAc,EAAE,SAAiB,EAAE,QAAgB,EAAE,SAAiB;IAC1G,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5D,IAAI,GAAG,GAAG,CAAC,CAAC;IACZ,GAAG,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAAC,GAAG,IAAI,CAAC,CAAC;IAChD,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAAC,GAAG,IAAI,MAAM,CAAC,MAAM,CAAC;IAC5C,GAAG,CAAC,gBAAgB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAAC,GAAG,IAAI,CAAC,CAAC;IAC5C,GAAG,CAAC,aAAa,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAAC,GAAG,IAAI,CAAC,CAAC;IAC5C,GAAG,CAAC,aAAa,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;IAAC,GAAG,IAAI,CAAC,CAAC;IAC3C,GAAG,CAAC,gBAAgB,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IACrC,OAAO,GAAG,CAAC;AACb,CAAC;AAED,8EAA8E;AAC9E,qCAAqC;AACrC,8EAA8E;AAE9E,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE;IACxB,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,GAAG,CAAC,CAAC;IACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;QAC7B,IAAI,GAAG,GAAG,CAAC,CAAC;QACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;QAC7D,CAAC;QACD,KAAK,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC;IACjB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC,EAAE,CAAC;AAEL,SAAS,KAAK,CAAC,IAAY;IACzB,IAAI,GAAG,GAAG,UAAU,CAAC;IACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,GAAG,GAAG,WAAW,CAAC,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC;IAC1D,CAAC;IACD,OAAO,CAAC,GAAG,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;AAClC,CAAC;AAED,MAAM,UAAU,GAAG,KAAK,EAAE,OAAe,EAAoB,EAAE;IAC7D,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAC;QACrE,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,OAAO,mCAAoC,SAAQ,cAAc;IACrE,YAAY,iBAA0B,EAAE,gBAA2B;QACjE,KAAK,CACH,CAAC,iBAAiB,EAAE,GAAG,gBAAgB,CAAC,EACxC,4EAA4E,EAC5E,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAC7B,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,qCAAqC,CAAC;IACpD,CAAC;CACF;AAED,MAAM,CAAC,MAAM,+BAA+B,GAAG,KAAK,EAIlD,aAA0B,EAC1B,YAEqB,EACrB,SAAuB,EACL,EAAE;IACpB,IAAI,eAAoC,CAAC;IACzC,IAAI,cAAuB,CAAC;IAC5B,IAAI,kBAAkB,GAAG,KAAK,CAAC;IAC/B,IAAI,CAAC;QACH,eAAe,GAAG,MAAM,YAAY,CAAC,aAAa,CAAC,CAAC;QACpD,kBAAkB,GAAG,IAAI,CAAC;IAC5B,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,cAAc,GAAG,KAAK,CAAC;IACzB,CAAC;IACD,IAAI,CAAC;QACH,MAAM,aAAa,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAAC,OAAO,UAAU,EAAE,CAAC;QACpB,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YACjC,MAAM,IAAI,mCAAmC,CAAC,cAAc,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;QAC9E,CAAC;QACD,IAAI,SAAS,EAAE,OAAO,EAAE,CAAC;YACvB,MAAM,IAAI,mCAAmC,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC;QAChF,CAAC;QACD,MAAM,UAAU,CAAC;IACnB,CAAC;IACD,IAAI,CAAC,kBAAkB;QAAE,MAAM,cAAc,CAAC;IAC9C,OAAO,eAA0B,CAAC;AACpC,CAAC,CAAC;AAEF,MAAM,cAAc,GAAG,KAAK,EAC1B,WAAmB,EACnB,QAAoB,EACpB,YAEqB,EACrB,SAAuB,EACL,EAAE,CAAC,+BAA+B,CACpD,MAAM,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,QAAQ,CAAC,EACpC,YAAY,EACZ,SAAS,CACV,CAAC;AAEF,MAAM,WAAW,GAAG,KAAK,EACvB,aAAkD,EAClD,SAAiB,EACjB,SAAuB,EACR,EAAE;IACjB,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,OAAO,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;QACjC,SAAS,EAAE,cAAc,EAAE,CAAC;QAC5B,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,aAAa,CAAC,KAAK,CAChD,SAAS,EACT,MAAM,EACN,SAAS,CAAC,MAAM,GAAG,MAAM,EACzB,IAAI,CACL,CAAC;QACF,IAAI,YAAY,IAAI,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QACD,MAAM,IAAI,YAAY,CAAC;IACzB,CAAC;IACD,SAAS,EAAE,cAAc,EAAE,CAAC;AAC9B,CAAC,CAAC;AAEF,MAAM,aAAa,GAAG,KAAK,EACzB,gBAAwB,EACxB,SAAuB,EACR,EAAE;IACjB,IAAI,CAAC;QACH,MAAM,cAAc,CAAC,gBAAgB,EAAE,GAAG,EAAE,KAAK,EAAE,kBAAkB,EAAE,EAAE;YACvE,MAAM,kBAAkB,CAAC,IAAI,EAAE,CAAC;QAClC,CAAC,EAAE,SAAS,CAAC,CAAC;IAChB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,CAAC,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,QAAQ,CAAE,KAA+B,CAAC,IAAI,IAAI,EAAE,CAAC,EAAE,CAAC;YACjF,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAEF,MAAM,QAAQ,GAAG,KAAK,EAAE,WAAmB,EAAE,SAAuB,EAAiB,EAAE;IACrF,MAAM,cAAc,CAAC,WAAW,EAAE,GAAG,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE;QAC7D,MAAM,aAAa,CAAC,IAAI,EAAE,CAAC;IAC7B,CAAC,EAAE,SAAS,CAAC,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,gCAAgC,GAAG,KAAK,EAC5C,sBAA8B,EACf,EAAE;IACjB,KAAK,MAAM,QAAQ,IAAI,CAAC,UAAU,EAAE,aAAa,EAAE,cAAc,CAAC,EAAE,CAAC;QACnE,IAAI,QAA8C,CAAC;QACnD,IAAI,CAAC;YACH,QAAQ,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,EAAE,QAAQ,CAAC,CAAC,CAAC;QACzE,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;gBACvD,MAAM,IAAI,KAAK,CACb,kDAAkD,sBAAsB,EAAE,EAC1E,EAAE,KAAK,EAAE,KAAK,EAAE,CACjB,CAAC;YACJ,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;QACD,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,IAAI,QAAQ,CAAC,cAAc,EAAE,EAAE,CAAC;YACpD,MAAM,IAAI,KAAK,CACb,kDAAkD,sBAAsB,EAAE,CAC3E,CAAC;QACJ,CAAC;IACH,CAAC;AACH,CAAC,CAAC;AAaF;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CACjC,WAAmB,EACnB,SAAuB;IAEvB,MAAM,cAAc,GAAa,EAAE,CAAC;IACpC,MAAM,kBAAkB,GAAG,IAAI,GAAG,EAAU,CAAC;IAE7C,IAAI,CAAC;QACH,SAAS,EAAE,cAAc,EAAE,CAAC;QAC5B,MAAM,SAAS,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,WAAW,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;QAEzE,KAAK,MAAM,OAAO,IAAI,SAAS,EAAE,CAAC;YAChC,SAAS,EAAE,cAAc,EAAE,CAAC;YAC5B,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE;gBAAE,SAAS;YACrC,IAAI,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;gBAAE,SAAS;YAEpD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;YACnD,MAAM,SAAS,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;YAEnE,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;gBACjC,SAAS,EAAE,cAAc,EAAE,CAAC;gBAC5B,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE;oBAAE,SAAS;gBACjC,IAAI,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,YAAY,CAAC;oBAAE,SAAS;gBACrD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;oBAAE,SAAS;gBAC/C,IAAI,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,eAAe,CAAC;oBAAE,SAAS;gBAEtD,MAAM,QAAQ,GAAG,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;gBACtD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC;gBACjD,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,GAAG,QAAQ,eAAe,CAAC,CAAC;gBAEnE,mBAAmB;gBACnB,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;gBAC3C,IAAI,MAAM,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;oBAC9B,MAAM,gCAAgC,CAAC,OAAO,CAAC,CAAC;oBAChD,IAAI,MAAM,UAAU,CAAC,aAAa,CAAC;wBAAE,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;oBACxE,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;oBAC9B,SAAS;gBACX,CAAC;gBAED,OAAO,CAAC,GAAG,CAAC,yBAAyB,OAAO,CAAC,IAAI,IAAI,QAAQ,KAAK,CAAC,CAAC;gBAEpE,2BAA2B;gBAC3B,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,QAAQ,EAAE;oBAC3C,QAAQ,EAAE,MAAM;oBAChB,MAAM,EAAE,SAAS;iBAClB,CAAC,CAAC;gBACH,SAAS,EAAE,cAAc,EAAE,CAAC;gBAC5B,MAAM,IAAI,GAAU,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;gBAEzC,mEAAmE;gBACnE,gEAAgE;gBAChE,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAC1B,KAAK,EACL,uBAAuB,QAAQ,IAAI,OAAO,CAAC,GAAG,IAAI,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAC1F,CAAC;gBACF,MAAM,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;gBAC3B,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;gBACnC,SAAS,EAAE,cAAc,EAAE,CAAC;gBAE5B,iBAAiB;gBACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC;gBACnD,MAAM,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,EAAE;oBAC5D,cAAc;oBACd,MAAM,SAAS,GAAG,eAAe,CAAC,cAAc,CAAC,CAAC;oBAClD,MAAM,WAAW,CAAC,cAAc,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;oBAExD,IAAI,aAAa,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC;oBAC7C,MAAM,MAAM,GAA8B,IAAI,GAAG,EAAE,CAAC;oBACpD,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC;oBAE9B,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;wBACvB,SAAS,EAAE,cAAc,EAAE,CAAC;wBAC5B,cAAc;wBACd,IAAI,KAAa,CAAC;wBAClB,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;4BAC5B,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC;wBACvB,CAAC;6BAAM,IAAI,OAAO,GAAG,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC;4BACvC,KAAK,GAAG,GAAG,CAAC,GAAG,CAAC;wBAClB,CAAC;6BAAM,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;4BACnB,KAAK,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;wBAC1B,CAAC;6BAAM,CAAC;4BACN,0BAA0B;4BAC1B,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;4BAC/C,GAAG,CAAC,GAAG,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC;wBAC5B,CAAC;wBAED,oBAAoB;wBACpB,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;wBACtC,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;wBAC3C,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;wBAExC,MAAM,MAAM,GAAG,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;wBACtD,MAAM,WAAW,CAAC,cAAc,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC;wBAErD,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE;4BAChB,MAAM,EAAE,aAAa;4BACrB,SAAS,EAAE,MAAM,CAAC,MAAM;4BACxB,QAAQ,EAAE,QAAQ,CAAC,MAAM;4BACzB,SAAS,EAAE,EAAE;yBACd,CAAC,CAAC;wBAEH,aAAa,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;oBACzC,CAAC;oBAED,MAAM,cAAc,CAAC,IAAI,EAAE,CAAC;oBAC5B,SAAS,EAAE,cAAc,EAAE,CAAC;oBAE5B,oBAAoB;oBACpB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,aAAa,CAAC,CAAC;oBACtD,MAAM,cAAc,CAAC,QAAQ,EAAE,IAAI,EAAE,KAAK,EAAE,cAAc,EAAE,EAAE;wBAC5D,MAAM,WAAW,CAAC,cAAc,EAAE,eAAe,CAAC,cAAc,CAAC,EAAE,SAAS,CAAC,CAAC;wBAC9E,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,EAAE,CAAC;4BAClC,SAAS,EAAE,cAAc,EAAE,CAAC;4BAC5B,MAAM,WAAW,CACf,cAAc,EACd,eAAe,CACb,GAAG,EACH,KAAK,CAAC,MAAM,EACZ,KAAK,CAAC,SAAS,EACf,KAAK,CAAC,QAAQ,EACd,KAAK,CAAC,SAAS,CAChB,EACD,SAAS,CACV,CAAC;wBACJ,CAAC;wBACD,MAAM,cAAc,CAAC,IAAI,EAAE,CAAC;wBAC5B,SAAS,EAAE,cAAc,EAAE,CAAC;oBAC9B,CAAC,EAAE,SAAS,CAAC,CAAC;gBAChB,CAAC,EAAE,SAAS,CAAC,CAAC;gBAEd,iCAAiC;gBACjC,IAAI,MAAM,UAAU,CAAC,aAAa,CAAC,EAAE,CAAC;oBACpC,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;oBAC5D,MAAM,EAAE,CAAC,QAAQ,CAAC,aAAa,EAAE,aAAa,CAAC,CAAC;oBAChD,MAAM,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;oBACzC,SAAS,EAAE,cAAc,EAAE,CAAC;oBAC5B,cAAc,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;gBACrC,CAAC;qBAAM,CAAC;oBACN,0BAA0B;oBAC1B,MAAM,aAAa,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC;oBAC5D,MAAM,EAAE,CAAC,SAAS,CAChB,aAAa,EACb,IAAI,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAC5D,EAAE,MAAM,EAAE,SAAS,EAAE,CACtB,CAAC;oBACF,MAAM,QAAQ,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;oBACzC,SAAS,EAAE,cAAc,EAAE,CAAC;gBAC9B,CAAC;gBAED,MAAM,gCAAgC,CAAC,UAAU,CAAC,CAAC;gBACnD,MAAM,aAAa,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;gBAC3C,SAAS,EAAE,cAAc,EAAE,CAAC;gBAC5B,MAAM,EAAE,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBACrC,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;gBACtC,MAAM,aAAa,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;gBACtC,SAAS,EAAE,cAAc,EAAE,CAAC;gBAC5B,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBAE9B,OAAO,CAAC,GAAG,CAAC,wBAAwB,OAAO,CAAC,IAAI,IAAI,QAAQ,KAAK,IAAI,CAAC,MAAM,YAAY,CAAC,CAAC;YAC5F,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,aAAa,GAAc,EAAE,CAAC;QACpC,KAAK,MAAM,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,kBAAkB,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC;YAC3D,IAAI,CAAC;gBACH,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;gBACnD,MAAM,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;YACzC,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBACtB,aAAa,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACnC,CAAC;QACH,CAAC;QACD,IAAI,aAAa,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,mCAAmC,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC;QACpE,CAAC;QACD,MAAM,GAAG,CAAC;IACZ,CAAC;IAED,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/dist_ts/ts_migration/migrators/v1_auth_metadata_permissions.d.ts

@@ -1,6 +1,7 @@
 import type { TAuthMetadataPermissionTransitionStatus } from '../../ts_smartdb/rust-db-bridge.js';
+import type { ISmartDbManagementOperationOptions } from '../../ts_smartdb/service-types.js';
 export interface IAuthMetadataPermissionMigrationBridge {
-    transitionAuthMetadataPermissions(usersPathArg: string, expectedModeArg: number, targetModeArg: number): Promise<TAuthMetadataPermissionTransitionStatus>;
+    transitionAuthMetadataPermissions(usersPathArg: string, expectedModeArg: number, targetModeArg: number, optionsArg?: ISmartDbManagementOperationOptions): Promise<TAuthMetadataPermissionTransitionStatus>;
 }
 export type TAuthMetadataPermissionMigrationStatus = TAuthMetadataPermissionTransitionStatus;
 /**
@@ -8,4 +9,4 @@ export type TAuthMetadataPermissionMigrationStatus = TAuthMetadataPermissionTran
  * process umask and therefore has exact mode 0644 in the supported legacy
  * state. The native primitive retains the descriptor while applying 0600.
  */
-export declare const migrateV1AuthMetadataPermissions: (bridgeArg: IAuthMetadataPermissionMigrationBridge, usersPathArg: string) => Promise<TAuthMetadataPermissionMigrationStatus>;
+export declare const migrateV1AuthMetadataPermissions: (bridgeArg: IAuthMetadataPermissionMigrationBridge, usersPathArg: string, optionsArg?: ISmartDbManagementOperationOptions) => Promise<TAuthMetadataPermissionMigrationStatus>;

package/dist_ts/ts_migration/migrators/v1_auth_metadata_permissions.js

@@ -5,6 +5,6 @@ const privateAuthMetadataMode = 0o600;
  * process umask and therefore has exact mode 0644 in the supported legacy
  * state. The native primitive retains the descriptor while applying 0600.
  */
-export const migrateV1AuthMetadataPermissions = async (bridgeArg, usersPathArg) => bridgeArg
-    .transitionAuthMetadataPermissions(usersPathArg, legacyAuthMetadataMode, privateAuthMetadataMode);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidjFfYXV0aF9tZXRhZGF0YV9wZXJtaXNzaW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3RzX21pZ3JhdGlvbi9taWdyYXRvcnMvdjFfYXV0aF9tZXRhZGF0YV9wZXJtaXNzaW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLHNCQUFzQixHQUFHLEtBQUssQ0FBQztBQUNyQyxNQUFNLHVCQUF1QixHQUFHLEtBQUssQ0FBQztBQWF0Qzs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQUcsS0FBSyxFQUNuRCxTQUFpRCxFQUNqRCxZQUFvQixFQUM2QixFQUFFLENBQUMsU0FBUztLQUM1RCxpQ0FBaUMsQ0FDaEMsWUFBWSxFQUNaLHNCQUFzQixFQUN0Qix1QkFBdUIsQ0FDeEIsQ0FBQyJ9
+export const migrateV1AuthMetadataPermissions = async (bridgeArg, usersPathArg, optionsArg) => bridgeArg
+    .transitionAuthMetadataPermissions(usersPathArg, legacyAuthMetadataMode, privateAuthMetadataMode, optionsArg);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidjFfYXV0aF9tZXRhZGF0YV9wZXJtaXNzaW9ucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3RzX21pZ3JhdGlvbi9taWdyYXRvcnMvdjFfYXV0aF9tZXRhZGF0YV9wZXJtaXNzaW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxNQUFNLHNCQUFzQixHQUFHLEtBQUssQ0FBQztBQUNyQyxNQUFNLHVCQUF1QixHQUFHLEtBQUssQ0FBQztBQWN0Qzs7OztHQUlHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sZ0NBQWdDLEdBQUcsS0FBSyxFQUNuRCxTQUFpRCxFQUNqRCxZQUFvQixFQUNwQixVQUErQyxFQUNFLEVBQUUsQ0FBQyxTQUFTO0tBQzVELGlDQUFpQyxDQUNoQyxZQUFZLEVBQ1osc0JBQXNCLEVBQ3RCLHVCQUF1QixFQUN2QixVQUFVLENBQ1gsQ0FBQyJ9

package/dist_ts/ts_smartdb/rust-db-bridge.d.ts

@@ -146,8 +146,8 @@ export declare class RustDbBridge extends EventEmitter {
     get ownershipReleased(): boolean;
     private awaitManagementOperationTermination;
     inspectOfflineStringValue(inputArg: ILocalSmartDbOfflineStringValueInspection, optionsArg?: ISmartDbManagementOperationOptions): Promise<TLocalSmartDbOfflineStringValueInspectionResult>;
-    transitionAuthMetadataPermissions(usersPathArg: string, expectedModeArg: number, targetModeArg: number): Promise<TAuthMetadataPermissionTransitionStatus>;
-    startDb(config: ISmartDbRustConfig): Promise<{
+    transitionAuthMetadataPermissions(usersPathArg: string, expectedModeArg: number, targetModeArg: number, optionsArg?: ISmartDbManagementOperationOptions): Promise<TAuthMetadataPermissionTransitionStatus>;
+    startDb(config: ISmartDbRustConfig, optionsArg?: ISmartDbManagementOperationOptions): Promise<{
         connectionUri: string;
     }>;
     stopDb(): Promise<void>;