@zenfs/core 1.2.2 → 1.2.4

package/dist/backends/store/simple.d.ts

@@ -4,6 +4,7 @@ import { SyncTransaction, type Store } from './store.js';
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
+    keys(): Iterable<Ino>;
     get(ino: Ino): Uint8Array | undefined;
     set(ino: Ino, data: Uint8Array): void;
     delete(ino: Ino): void;
@@ -17,6 +18,7 @@ export declare abstract class SimpleAsyncStore implements SimpleSyncStore {
     protected cache: Map<Ino, Uint8Array>;
     protected queue: Set<Promise<unknown>>;
     protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
+    keys(): Iterable<Ino>;
     get(ino: Ino): Uint8Array | undefined;
     set(ino: Ino, data: Uint8Array): void;
     protected abstract _set(ino: Ino, data: Uint8Array): Promise<void>;
@@ -43,6 +45,7 @@ export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore>
      */
     protected modifiedKeys: Set<Ino>;
     protected store: SimpleSyncStore;
+    keysSync(): Iterable<Ino>;
     getSync(ino: Ino): Uint8Array;
     setSync(ino: Ino, data: Uint8Array): void;
     removeSync(ino: Ino): void;

package/dist/backends/store/simple.js

@@ -8,6 +8,9 @@ export class SimpleAsyncStore {
         this.cache = new Map();
         this.queue = new Set();
     }
+    keys() {
+        return this.cache.keys();
+    }
     get(ino) {
         return this.cache.get(ino);
     }
@@ -55,6 +58,9 @@ export class SimpleTransaction extends SyncTransaction {
          */
         this.modifiedKeys = new Set();
     }
+    keysSync() {
+        return this.store.keys();
+    }
     getSync(ino) {
         const val = this.store.get(ino);
         this.stashOldValue(ino, val);

package/dist/backends/store/store.d.ts

@@ -32,9 +32,17 @@ export declare abstract class Transaction<T extends Store = Store> {
     protected store: T;
     constructor(store: T);
     /**
-     * Whether the transaction was commited or aborted
+     * Whether the transaction was committed or aborted
      */
     protected done: boolean;
+    /**
+     * Gets all of the keys
+     */
+    abstract keys(): Promise<Iterable<Ino>>;
+    /**
+     * Gets all of the keys
+     */
+    abstract keysSync(): Iterable<Ino>;
     /**
      * Retrieves the data at `ino`.
      * @param ino The key to look under for data.
@@ -92,6 +100,7 @@ export declare abstract class Transaction<T extends Store = Store> {
  * Transaction that implements asynchronous operations with synchronous ones
  */
 export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
+    keys(): Promise<Iterable<Ino>>;
     get(ino: Ino): Promise<Uint8Array>;
     set(ino: bigint, data: Uint8Array): Promise<void>;
     remove(ino: Ino): Promise<void>;
@@ -102,9 +111,10 @@ export declare abstract class SyncTransaction<T extends Store = Store> extends T
  * Transaction that only supports asynchronous operations
  */
 export declare abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
-    getSync(): Uint8Array;
-    setSync(): void;
-    removeSync(): void;
-    commitSync(): void;
-    abortSync(): void;
+    keysSync(): never;
+    getSync(): never;
+    setSync(): never;
+    removeSync(): never;
+    commitSync(): never;
+    abortSync(): never;
 }

package/dist/backends/store/store.js

@@ -7,7 +7,7 @@ export class Transaction {
     constructor(store) {
         this.store = store;
         /**
-         * Whether the transaction was commited or aborted
+         * Whether the transaction was committed or aborted
          */
         this.done = false;
     }
@@ -29,6 +29,9 @@ export class Transaction {
  */
 export class SyncTransaction extends Transaction {
     /* eslint-disable @typescript-eslint/require-await */
+    async keys() {
+        return this.keysSync();
+    }
     async get(ino) {
         return this.getSync(ino);
     }
@@ -49,6 +52,9 @@ export class SyncTransaction extends Transaction {
  * Transaction that only supports asynchronous operations
  */
 export class AsyncTransaction extends Transaction {
+    keysSync() {
+        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.keysSync');
+    }
     getSync() {
         throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
     }

package/dist/config.d.ts

@@ -54,13 +54,13 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      */
     disableAccessChecks: boolean;
     /**
-     * If true, disables `read` and `readSync` from immediately syncing the updated atime to the file system.
+     * If true, disables `read` and `readSync` from updating the atime.
      *
      * This can increase performance.
      * @experimental
      * @default false
      */
-    disableSyncOnRead: boolean;
+    disableUpdateOnRead: boolean;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -70,7 +70,7 @@ export async function configure(configuration) {
     Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
     cache.setEnabled(configuration.cacheStats ?? false);
     config.checkAccess = !configuration.disableAccessChecks;
-    config.syncOnRead = !configuration.disableSyncOnRead;
+    config.updateOnRead = !configuration.disableUpdateOnRead;
     if (configuration.addDevices) {
         const devfs = new DeviceFS();
         devfs.createDevice('/null', nullDevice);

package/dist/emulation/config.d.ts

@@ -6,5 +6,5 @@ export declare const config: {
     /**
      * Whether to sync atime updates immediately when reading from a file
      */
-    syncOnRead: boolean;
+    updateOnRead: boolean;
 };

package/dist/emulation/config.js

@@ -6,5 +6,5 @@ export const config = {
     /**
      * Whether to sync atime updates immediately when reading from a file
      */
-    syncOnRead: true,
+    updateOnRead: true,
 };

package/dist/file.js

@@ -358,13 +358,15 @@ export class PreloadFile extends File {
         if (!isReadable(this.flag)) {
             throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
         }
-        this.dirty = true;
+        if (config.updateOnRead) {
+            this.dirty = true;
+            this.stats.atimeMs = Date.now();
+        }
         position ?? (position = this.position);
         let end = position + length;
         if (end > this.stats.size) {
             end = position + Math.max(this.stats.size - position, 0);
         }
-        this.stats.atimeMs = Date.now();
         this._position = end;
         const bytesRead = end - position;
         if (bytesRead == 0) {
@@ -384,8 +386,7 @@ export class PreloadFile extends File {
      */
     async read(buffer, offset, length, position) {
         const bytesRead = this._read(buffer, offset, length, position);
-        if (config.syncOnRead)
-            await this.sync();
+        await this.sync();
         return { bytesRead, buffer };
     }
     /**
@@ -399,8 +400,7 @@ export class PreloadFile extends File {
      */
     readSync(buffer, offset, length, position) {
         const bytesRead = this._read(buffer, offset, length, position);
-        if (config.syncOnRead)
-            this.syncSync();
+        this.syncSync();
         return bytesRead;
     }
     async chmod(mode) {

package/dist/mixins/async.js

@@ -45,6 +45,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { StoreFS } from '../backends/store/fs.js';
 import { join } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { parseFlag, PreloadFile } from '../file.js';
@@ -84,6 +85,18 @@ export function Async(FS) {
             }
             this.checkSync();
             await this._sync.ready();
+            // optimization: for 2 storeFS', we copy at a lower abstraction level.
+            if (this._sync instanceof StoreFS && this instanceof StoreFS) {
+                const sync = this._sync['store'].transaction();
+                const async = this['store'].transaction();
+                const promises = [];
+                for (const key of sync.keysSync()) {
+                    promises.push(async.set(key, sync.getSync(key)));
+                }
+                await Promise.all(promises);
+                this._isInitialized = true;
+                return;
+            }
             try {
                 await this.crossCopy('/');
                 this._isInitialized = true;
@@ -187,10 +200,11 @@ export function Async(FS) {
                 const stats = await this.stat(path);
                 this._sync.mkdirSync(path, stats.mode);
             }
-            const files = await this.readdir(path);
-            for (const file of files) {
-                await this.crossCopy(join(path, file));
+            const promises = [];
+            for (const file of await this.readdir(path)) {
+                promises.push(this.crossCopy(join(path, file)));
             }
+            await Promise.all(promises);
         }
         /**
          * @internal

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.2.2",
+	"version": "1.2.4",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/src/backends/store/simple.ts

@@ -5,6 +5,7 @@ import { SyncTransaction, type Store } from './store.js';
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
+	keys(): Iterable<Ino>;
 	get(ino: Ino): Uint8Array | undefined;
 	set(ino: Ino, data: Uint8Array): void;
 	delete(ino: Ino): void;
@@ -23,6 +24,10 @@ export abstract class SimpleAsyncStore implements SimpleSyncStore {
 
 	protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
 
+	public keys(): Iterable<Ino> {
+		return this.cache.keys();
+	}
+
 	public get(ino: Ino): Uint8Array | undefined {
 		return this.cache.get(ino);
 	}
@@ -82,6 +87,10 @@ export class SimpleTransaction extends SyncTransaction<SimpleSyncStore> {
 
 	protected declare store: SimpleSyncStore;
 
+	public keysSync(): Iterable<Ino> {
+		return this.store.keys();
+	}
+
 	public getSync(ino: Ino): Uint8Array {
 		const val = this.store.get(ino);
 		this.stashOldValue(ino, val);

package/src/backends/store/store.ts

@@ -39,10 +39,20 @@ export abstract class Transaction<T extends Store = Store> {
 	public constructor(protected store: T) {}
 
 	/**
-	 * Whether the transaction was commited or aborted
+	 * Whether the transaction was committed or aborted
 	 */
 	protected done: boolean = false;
 
+	/**
+	 * Gets all of the keys
+	 */
+	public abstract keys(): Promise<Iterable<Ino>>;
+
+	/**
+	 * Gets all of the keys
+	 */
+	public abstract keysSync(): Iterable<Ino>;
+
 	/**
 	 * Retrieves the data at `ino`.
 	 * @param ino The key to look under for data.
@@ -125,6 +135,9 @@ export abstract class Transaction<T extends Store = Store> {
  */
 export abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
 	/* eslint-disable @typescript-eslint/require-await */
+	public async keys(): Promise<Iterable<Ino>> {
+		return this.keysSync();
+	}
 	public async get(ino: Ino): Promise<Uint8Array> {
 		return this.getSync(ino);
 	}
@@ -151,23 +164,27 @@ export abstract class SyncTransaction<T extends Store = Store> extends Transacti
  * Transaction that only supports asynchronous operations
  */
 export abstract class AsyncTransaction<T extends Store = Store> extends Transaction<T> {
-	public getSync(): Uint8Array {
+	public keysSync(): never {
+		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.keysSync');
+	}
+
+	public getSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
 	}
 
-	public setSync(): void {
+	public setSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.setSync');
 	}
 
-	public removeSync(): void {
+	public removeSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.removeSync');
 	}
 
-	public commitSync(): void {
+	public commitSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.commitSync');
 	}
 
-	public abortSync(): void {
+	public abortSync(): never {
 		throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.abortSync');
 	}
 }

package/src/config.ts

@@ -119,13 +119,13 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
 	disableAccessChecks: boolean;
 
 	/**
-	 * If true, disables `read` and `readSync` from immediately syncing the updated atime to the file system.
+	 * If true, disables `read` and `readSync` from updating the atime.
 	 *
 	 * This can increase performance.
 	 * @experimental
 	 * @default false
 	 */
-	disableSyncOnRead: boolean;
+	disableUpdateOnRead: boolean;
 }
 
 /**
@@ -153,7 +153,7 @@ export async function configure<T extends ConfigMounts>(configuration: Partial<C
 
 	cache.setEnabled(configuration.cacheStats ?? false);
 	config.checkAccess = !configuration.disableAccessChecks;
-	config.syncOnRead = !configuration.disableSyncOnRead;
+	config.updateOnRead = !configuration.disableUpdateOnRead;
 
 	if (configuration.addDevices) {
 		const devfs = new DeviceFS();

package/src/emulation/config.ts

@@ -7,5 +7,5 @@ export const config = {
 	/**
 	 * Whether to sync atime updates immediately when reading from a file
 	 */
-	syncOnRead: true,
+	updateOnRead: true,
 };

package/src/file.ts

@@ -515,13 +515,15 @@ export class PreloadFile<FS extends FileSystem> extends File {
 		if (!isReadable(this.flag)) {
 			throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
 		}
-		this.dirty = true;
+		if (config.updateOnRead) {
+			this.dirty = true;
+			this.stats.atimeMs = Date.now();
+		}
 		position ??= this.position;
 		let end = position + length;
 		if (end > this.stats.size) {
 			end = position + Math.max(this.stats.size - position, 0);
 		}
-		this.stats.atimeMs = Date.now();
 		this._position = end;
 		const bytesRead = end - position;
 		if (bytesRead == 0) {
@@ -542,7 +544,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 */
 	public async read<TBuffer extends ArrayBufferView>(buffer: TBuffer, offset?: number, length?: number, position?: number): Promise<{ bytesRead: number; buffer: TBuffer }> {
 		const bytesRead = this._read(buffer, offset, length, position);
-		if (config.syncOnRead) await this.sync();
+		await this.sync();
 		return { bytesRead, buffer };
 	}
 
@@ -557,7 +559,7 @@ export class PreloadFile<FS extends FileSystem> extends File {
 	 */
 	public readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number {
 		const bytesRead = this._read(buffer, offset, length, position);
-		if (config.syncOnRead) this.syncSync();
+		this.syncSync();
 		return bytesRead;
 	}
 

package/src/mixins/async.ts

@@ -1,3 +1,5 @@
+import { StoreFS } from '../backends/store/fs.js';
+import type { Store } from '../backends/store/store.js';
 import { join } from '../emulation/path.js';
 import { Errno, ErrnoError } from '../error.js';
 import { parseFlag, PreloadFile, type File } from '../file.js';
@@ -72,6 +74,22 @@ export function Async<T extends typeof FileSystem>(
 
 			await this._sync.ready();
 
+			// optimization: for 2 storeFS', we copy at a lower abstraction level.
+			if (this._sync instanceof StoreFS && this instanceof StoreFS) {
+				const sync = (this._sync as StoreFS<Store>)['store'].transaction();
+				const async = (this as StoreFS<Store>)['store'].transaction();
+
+				const promises = [];
+				for (const key of sync.keysSync()) {
+					promises.push(async.set(key, sync.getSync(key)));
+				}
+
+				await Promise.all(promises);
+
+				this._isInitialized = true;
+				return;
+			}
+
 			try {
 				await this.crossCopy('/');
 				this._isInitialized = true;
@@ -175,10 +193,11 @@ export function Async<T extends typeof FileSystem>(
 				const stats = await this.stat(path);
 				this._sync.mkdirSync(path, stats.mode);
 			}
-			const files = await this.readdir(path);
-			for (const file of files) {
-				await this.crossCopy(join(path, file));
+			const promises = [];
+			for (const file of await this.readdir(path)) {
+				promises.push(this.crossCopy(join(path, file)));
 			}
+			await Promise.all(promises);
 		}
 
 		/**