@zenfs/core 2.3.9 → 2.3.11

package/dist/backends/backend.js

@@ -21,6 +21,13 @@ export function _fnOpt(name, fn) {
         Object.defineProperty(fn, 'name', { value: name });
     return fn;
 }
+function _isClass(func) {
+    if (!(func && func.constructor === Function) || func.prototype === undefined)
+        return false;
+    if (Function.prototype !== Object.getPrototypeOf(func))
+        return true;
+    return Object.getOwnPropertyNames(func.prototype).length > 1;
+}
 /**
  * Checks that `options` object is valid for the file system options.
  * @category Backends and Configuration
@@ -41,7 +48,7 @@ export function checkOptions(backend, options) {
             throw err(withErrno('EINVAL', 'Missing required option: ' + optName));
         }
         const isType = (type, _ = value) => typeof type == 'function'
-            ? Symbol.hasInstance in type && type.prototype
+            ? _isClass(type)
                 ? value instanceof type
                 : type(value)
             : typeof value === type || value?.constructor?.name === type;

package/dist/backends/port.d.ts

@@ -33,11 +33,6 @@ export declare class PortFS<T extends RPC.Channel = RPC.Channel> extends PortFS_
     readonly channel: T;
     readonly timeout: number;
     readonly port: RPC.Port<T>;
-    /**
-     * A map of outstanding RPC requests
-     * @internal @hidden
-     */
-    readonly _executors: Map<string, RPC.Executor>;
     /**
      * @hidden
      */

package/dist/backends/port.js

@@ -19,11 +19,6 @@ export class PortFS extends Async(FileSystem) {
     channel;
     timeout;
     port;
-    /**
-     * A map of outstanding RPC requests
-     * @internal @hidden
-     */
-    _executors = new Map();
     /**
      * @hidden
      */
@@ -61,10 +56,8 @@ export class PortFS extends Async(FileSystem) {
         await this.rpc('touch', path, new Uint8Array(inode.buffer, inode.byteOffset, inode.byteLength));
     }
     async sync() {
+        await super.sync();
         await this.rpc('sync');
-        for (const executor of this._executors.values()) {
-            await executor.promise.catch(() => { });
-        }
     }
     async createFile(path, options) {
         if (options instanceof Inode)

package/dist/config.d.ts

@@ -87,3 +87,4 @@ export declare function addDevice(driver: DeviceDriver, options?: object): Devic
  * @see Configuration
  */
 export declare function configure<T extends ConfigMounts>(configuration: Partial<Configuration<T>>): Promise<void>;
+export declare function sync(): Promise<void>;

package/dist/config.js

@@ -65,7 +65,7 @@ export async function resolveMountConfig(configuration, _depth = 0) {
  * @category Backends and Configuration
  */
 export async function configureSingle(configuration) {
-    if (!isBackendConfig(configuration)) {
+    if (!isMountConfig(configuration)) {
         throw new TypeError('Invalid single mount point configuration');
     }
     const resolved = await resolveMountConfig(configuration);
@@ -137,3 +137,7 @@ export async function configure(configuration) {
         await mount('/dev', devfs);
     }
 }
+export async function sync() {
+    for (const fs of mounts.values())
+        await fs.sync();
+}

package/dist/internal/index_fs.d.ts

@@ -30,6 +30,8 @@ export declare abstract class IndexFS extends FileSystem {
     protected create(path: string, options: CreationOptions): Inode;
     createFile(path: string, options: CreationOptions): Promise<InodeLike>;
     createFileSync(path: string, options: CreationOptions): InodeLike;
+    protected _mkdir?(path: string, options: CreationOptions): Promise<void>;
+    protected _mkdirSync?(path: string, options: CreationOptions): void;
     mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
     mkdirSync(path: string, options: CreationOptions): InodeLike;
     link(target: string, link: string): Promise<void>;

package/dist/internal/index_fs.js

@@ -38,31 +38,56 @@ export class IndexFS extends FileSystem {
                 to = to.slice(0, -1);
             toRename.push({ from, to, inode });
         }
+        toRename.sort((a, b) => b.from.length - a.from.length);
         return toRename;
     }
     async rename(oldPath, newPath) {
         if (oldPath == newPath)
             return;
-        for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
+        const toRename = this.pathsForRename(oldPath, newPath);
+        const contents = new Map();
+        for (const { from, to, inode } of toRename) {
             const data = new Uint8Array(inode.size);
             await this.read(from, data, 0, inode.size);
+            contents.set(to, data);
             this.index.delete(from);
+            await this.remove(from);
+            if (this.index.has(to))
+                await this.remove(to);
+        }
+        toRename.reverse();
+        for (const { to, inode } of toRename) {
+            const data = contents.get(to);
             this.index.set(to, inode);
-            await this.write(to, data, 0);
+            if ((inode.mode & S_IFMT) == S_IFDIR)
+                await this._mkdir?.(to, inode);
+            else
+                await this.write(to, data, 0);
         }
-        await this.remove(oldPath);
     }
     renameSync(oldPath, newPath) {
         if (oldPath == newPath)
             return;
-        for (const { from, to, inode } of this.pathsForRename(oldPath, newPath)) {
+        const toRename = this.pathsForRename(oldPath, newPath);
+        const contents = new Map();
+        for (const { from, to, inode } of toRename) {
             const data = new Uint8Array(inode.size);
             this.readSync(from, data, 0, inode.size);
+            contents.set(to, data);
             this.index.delete(from);
+            this.removeSync(from);
+            if (this.index.has(to))
+                this.removeSync(to);
+        }
+        toRename.reverse();
+        for (const { to, inode } of toRename) {
+            const data = contents.get(to);
             this.index.set(to, inode);
-            this.writeSync(to, data, 0);
+            if ((inode.mode & S_IFMT) == S_IFDIR)
+                this._mkdirSync?.(to, inode);
+            else
+                this.writeSync(to, data, 0);
         }
-        this.removeSync(oldPath);
     }
     async stat(path) {
         const inode = this.index.get(path);
@@ -93,9 +118,8 @@ export class IndexFS extends FileSystem {
             throw withErrno('ENOTDIR');
         if (isDir && isUnlink)
             throw withErrno('EISDIR');
-        if (isDir && this.readdirSync(path).length)
-            throw withErrno('ENOTEMPTY');
-        this.index.delete(path);
+        if (!isDir)
+            this.index.delete(path);
     }
     async unlink(path) {
         this._remove(path, true);
@@ -107,10 +131,17 @@ export class IndexFS extends FileSystem {
     }
     async rmdir(path) {
         this._remove(path, false);
+        const entries = await this.readdir(path);
+        if (entries.length)
+            throw withErrno('ENOTEMPTY');
+        this.index.delete(path);
         await this.remove(path);
     }
     rmdirSync(path) {
         this._remove(path, false);
+        if (this.readdirSync(path).length)
+            throw withErrno('ENOTEMPTY');
+        this.index.delete(path);
         this.removeSync(path);
     }
     create(path, options) {
@@ -142,11 +173,15 @@ export class IndexFS extends FileSystem {
     }
     async mkdir(path, options) {
         options.mode |= S_IFDIR;
-        return this.create(path, options);
+        const inode = this.create(path, options);
+        await this._mkdir?.(path, options);
+        return inode;
     }
     mkdirSync(path, options) {
         options.mode |= S_IFDIR;
-        return this.create(path, options);
+        const inode = this.create(path, options);
+        this._mkdirSync?.(path, options);
+        return inode;
     }
     link(target, link) {
         throw withErrno('ENOSYS');

package/dist/internal/rpc.js

@@ -10,14 +10,17 @@ export function isPort(port) {
  * Creates a new RPC port from a `Worker` or `MessagePort` that extends `EventTarget`
  */
 export function fromWeb(port) {
+    const _handlers = new Map();
     return {
         channel: port,
         send: port.postMessage.bind(port),
         addHandler(handler) {
-            port.addEventListener('message', (event) => handler(event.data));
+            const _handler = (event) => handler(event.data);
+            _handlers.set(handler, _handler);
+            port.addEventListener('message', _handler);
         },
         removeHandler(handler) {
-            port.removeEventListener('message', (event) => handler(event.data));
+            port.removeEventListener('message', _handlers.get(handler));
         },
     };
 }
@@ -133,7 +136,6 @@ function disposeExecutors(id) {
         if (typeof executor.timeout == 'object')
             executor.timeout.unref();
     }
-    executor.fs._executors.delete(id);
     executors.delete(id);
 }
 /**
@@ -145,15 +147,14 @@ export function request(request, { port, timeout: ms = 1000, fs }) {
     if (!port)
         throw err(withErrno('EINVAL', 'Can not make an RPC request without a port'));
     const { resolve, reject, promise } = Promise.withResolvers();
-    const id = Math.random().toString(16).slice(10);
+    const id = Math.random().toString(16).slice(5);
     const timeout = setTimeout(() => {
-        const error = err(withErrno('EIO', 'RPC Failed'));
+        const error = err(withErrno('ETIMEDOUT', 'RPC request timed out'));
         error.stack += stack;
         disposeExecutors(id);
         reject(error);
     }, ms);
     const executor = { resolve, reject, promise, fs, timeout };
-    fs._executors.set(id, executor);
     executors.set(id, executor);
     port.send({ ...request, _zenfs: true, id, stack });
     return promise;

package/dist/mixins/async.d.ts

@@ -20,10 +20,8 @@ export interface AsyncMixin extends Pick<FileSystem, Exclude<_SyncFSKeys, 'exist
      * @deprecated Use {@link sync | `sync`} instead
      */
     queueDone(): Promise<void>;
-    /**
-     * @deprecated Use {@link sync | `sync`} instead
-     */
     ready(): Promise<void>;
+    sync(): Promise<void>;
 }
 /**
  * Async() implements synchronous methods on an asynchronous file system

package/dist/mixins/async.js

@@ -29,8 +29,9 @@ export function Async(FS) {
             return this.sync();
         }
         _promise = Promise.resolve();
-        _async(promise) {
-            this._promise = this._promise.then(() => promise);
+        _async(thunk) {
+            // eslint-disable-next-line @typescript-eslint/no-misused-promises
+            this._promise = this._promise.finally(() => thunk());
         }
         _isInitialized = false;
         /** Tracks how many updates to the sync. cache we skipped during initialization */
@@ -41,9 +42,9 @@ export function Async(FS) {
         }
         async ready() {
             await super.ready();
-            await this._promise;
             if (this._isInitialized || this.attributes.has('no_async_preload'))
                 return;
+            await this._promise;
             this.checkSync();
             await this._sync.ready();
             // optimization: for 2 storeFS', we copy at a lower abstraction level.
@@ -79,7 +80,7 @@ export function Async(FS) {
         renameSync(oldPath, newPath) {
             this.checkSync();
             this._sync.renameSync(oldPath, newPath);
-            this._async(this.rename(oldPath, newPath));
+            this._async(() => this.rename(oldPath, newPath));
         }
         statSync(path) {
             this.checkSync();
@@ -88,27 +89,29 @@ export function Async(FS) {
         touchSync(path, metadata) {
             this.checkSync();
             this._sync.touchSync(path, metadata);
-            this._async(this.touch(path, metadata));
+            this._async(() => this.touch(path, metadata));
         }
         createFileSync(path, options) {
             this.checkSync();
-            this._async(this.createFile(path, options));
-            return this._sync.createFileSync(path, options);
+            const result = this._sync.createFileSync(path, options);
+            this._async(() => this.createFile(path, options));
+            return result;
         }
         unlinkSync(path) {
             this.checkSync();
-            this._async(this.unlink(path));
             this._sync.unlinkSync(path);
+            this._async(() => this.unlink(path));
         }
         rmdirSync(path) {
             this.checkSync();
             this._sync.rmdirSync(path);
-            this._async(this.rmdir(path));
+            this._async(() => this.rmdir(path));
         }
         mkdirSync(path, options) {
             this.checkSync();
-            this._async(this.mkdir(path, options));
-            return this._sync.mkdirSync(path, options);
+            const result = this._sync.mkdirSync(path, options);
+            this._async(() => this.mkdir(path, options));
+            return result;
         }
         readdirSync(path) {
             this.checkSync();
@@ -117,12 +120,12 @@ export function Async(FS) {
         linkSync(srcpath, dstpath) {
             this.checkSync();
             this._sync.linkSync(srcpath, dstpath);
-            this._async(this.link(srcpath, dstpath));
+            this._async(() => this.link(srcpath, dstpath));
         }
         async sync() {
             if (!this.attributes.has('no_async_preload') && this._sync)
                 this._sync.syncSync();
-            await this._promise;
+            await this._promise.catch(() => { });
         }
         syncSync() {
             this.checkSync();
@@ -139,7 +142,7 @@ export function Async(FS) {
         writeSync(path, buffer, offset) {
             this.checkSync();
             this._sync.writeSync(path, buffer, offset);
-            this._async(this.write(path, buffer, offset));
+            this._async(() => this.write(path, buffer, offset));
         }
         streamWrite(path, options) {
             this.checkSync();
@@ -186,18 +189,27 @@ export function Async(FS) {
          * Patch all async methods to also call their synchronous counterparts unless called from themselves (either sync or async)
          */
         _patchAsync() {
-            debug(`Async: patched ${_asyncFSKeys.length} methods`);
-            for (const key of _asyncFSKeys) {
+            const noPatch = ['read', 'readdir', 'stat', 'exists'];
+            const toPatch = _asyncFSKeys.filter(key => !noPatch.includes(key));
+            for (const key of toPatch) {
                 // TS does not narrow the union based on the key
                 const originalMethod = this[key].bind(this);
-                this[key] = async (...args) => {
-                    const result = await originalMethod(...args);
-                    const stack = new Error().stack.split('\n').slice(2).join('\n');
+                function isInLoop(depth, error) {
+                    if (!error) {
+                        error = new Error();
+                        Error.captureStackTrace(error, isInLoop);
+                    }
+                    if (!error.stack)
+                        return false;
+                    const stack = error.stack.split('\n').slice(depth).join('\n');
                     // From the async queue
-                    if (!stack
-                        || stack.includes(`at <computed> [as ${key}]`)
+                    return (stack.includes(`at <computed> [as ${key}]`)
                         || stack.includes(`at async <computed> [as ${key}]`)
-                        || stack.includes(`${key}Sync `))
+                        || stack.includes(`${key}Sync `));
+                }
+                this[key] = async (...args) => {
+                    const result = await originalMethod(...args);
+                    if (isInLoop(2))
                         return result;
                     if (!this._isInitialized) {
                         this._skippedCacheUpdates++;
@@ -208,10 +220,7 @@ export function Async(FS) {
                         this._sync?.[`${key}Sync`]?.(...args);
                     }
                     catch (e) {
-                        const stack = e.stack.split('\n').slice(3).join('\n');
-                        if (stack.includes(`at <computed> [as ${key}]`)
-                            || stack.includes(`at async <computed> [as ${key}]`)
-                            || stack.includes(`${key}Sync `))
+                        if (isInLoop(3, e))
                             return result;
                         e.message += ' (Out of sync!)';
                         throw err(e);
@@ -219,6 +228,7 @@ export function Async(FS) {
                     return result;
                 };
             }
+            debug(`Async: patched ${toPatch.length} methods`);
         }
     }
     return AsyncFS;

package/dist/mixins/mutexed.d.ts

@@ -49,7 +49,7 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
      * If the path is currently locked, waits for it to be unlocked.
      * @internal
      */
-    lock(): Promise<MutexLock>;
+    lock(timeout?: number): Promise<MutexLock>;
     /**
      * Locks `path` asynchronously.
      * If the path is currently locked, an error will be thrown

package/dist/mixins/mutexed.js

@@ -135,7 +135,7 @@ export class _MutexedFS {
      * If the path is currently locked, waits for it to be unlocked.
      * @internal
      */
-    async lock() {
+    async lock(timeout = 5000) {
         const previous = this.currentLock;
         const lock = this.addLock();
         const stack = new Error().stack;
@@ -145,7 +145,7 @@ export class _MutexedFS {
                 error.stack += stack?.slice('Error'.length);
                 throw err(error);
             }
-        }, 5000);
+        }, timeout);
         await previous?.done();
         return lock;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.3.9",
+	"version": "2.3.11",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -60,7 +60,7 @@
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
 		"lint": "eslint src tests",
-		"test": "npx zenfs-test --clean; npx zenfs-test -abcfp; tests/fetch/run.sh; npx zenfs-test --report",
+		"test": "npx zenfs-test --clean; npx zenfs-test -abcp; tests/fetch/run.sh; npx zenfs-test --report",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc",
 		"dev": "npm run build -- --watch",

package/tests/backend/port.test.ts

@@ -12,7 +12,7 @@ setupLogs();
 const timeoutChannel = new MessageChannel();
 timeoutChannel.port2.unref();
 
-await suite('Timeout', { timeout: 1000 }, () => {
+await suite('Timeout', () => {
 	test('Misconfiguration', async () => {
 		const configured = configure({
 			mounts: {
@@ -21,13 +21,13 @@ await suite('Timeout', { timeout: 1000 }, () => {
 			},
 		});
 
-		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
+		await assert.rejects(configured, { code: 'ETIMEDOUT' });
 	});
 
 	test('Remote not attached', async () => {
 		const configured = configureSingle({ backend: Port, port: timeoutChannel.port1, timeout: 100 });
 
-		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
+		await assert.rejects(configured, { code: 'ETIMEDOUT' });
 	});
 
 	after(() => {

package/tests/common/mutex.test.ts

@@ -20,11 +20,11 @@ suite('Mutexed FS', () => {
 		let lock1Resolved = false;
 		let lock2Resolved = false;
 
-		const lock1 = fs.lock().then(lock => {
+		const lock1 = fs.lock(100).then(lock => {
 			lock1Resolved = true;
 			lock.unlock();
 		});
-		const lock2 = fs.lock().then(lock => {
+		const lock2 = fs.lock(100).then(lock => {
 			lock2Resolved = true;
 			lock.unlock();
 		});
@@ -50,7 +50,7 @@ suite('Mutexed FS', () => {
 		let x = 1;
 
 		async function foo() {
-			const lock = await fs.lock();
+			const lock = await fs.lock(100);
 			await wait(25);
 			x++;
 			lock.unlock();

package/tests/common.ts

@@ -1,12 +1,17 @@
 import { join, resolve } from 'node:path';
 import { fs as defaultFS } from '../dist/index.js';
 import { setupLogs } from './logs.js';
+import { styleText } from 'node:util';
 export type * from '../dist/index.js';
 
 setupLogs();
 
 const setupPath = resolve(process.env.SETUP || join(import.meta.dirname, 'setup/memory.ts'));
 
+process.on('unhandledRejection', (reason: Error) => {
+	console.error('Unhandled rejection:', styleText('red', reason.stack || reason.message));
+});
+
 const setup = await import(setupPath).catch(error => {
 	console.log('Failed to import test setup:');
 	throw error;

package/tests/fs/read.test.ts

@@ -3,7 +3,8 @@ import assert from 'node:assert/strict';
 import type { OpenMode, PathLike } from 'node:fs';
 import { suite, test } from 'node:test';
 import { promisify } from 'node:util';
-import { fs, type Callback } from '../common.js';
+import { sync } from '../../dist/config.js';
+import { fs } from '../common.js';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
@@ -73,6 +74,8 @@ suite('read', () => {
 		const path = '/text.txt';
 
 		fs.writeFileSync(path, 'hello world');
+		await sync();
+
 		const fd: number = (await promisify<PathLike, OpenMode, number | string>(fs.open)(path, 0, 0)) as any;
 
 		const read = promisify(fs.read);

package/tests/fs/scaling.test.ts

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
+import { sync } from '../../dist/config.js';
 import { fs } from '../common.js';
 
 const n_files = 130;
@@ -14,6 +15,7 @@ suite('Scaling', () => {
 			fs.writeFileSync('/n/' + i, i.toString(16));
 		}
 
+		await sync();
 		assert.equal(fs.readdirSync('/n').length, n_files);
 
 		const results = [];

package/tests/setup/port.ts

@@ -1,6 +1,6 @@
-import { after } from 'node:test';
+import { after, afterEach } from 'node:test';
 import { MessageChannel } from 'node:worker_threads';
-import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount } from '../../dist/index.js';
+import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount, sync } from '../../dist/index.js';
 import { copySync, data } from '../setup.js';
 
 const { port1: localPort, port2: remotePort } = new MessageChannel();
@@ -15,6 +15,8 @@ await resolveRemoteMount(remotePort, tmpfs);
 
 await configureSingle({ backend: Port, port: localPort });
 
+afterEach(sync);
+
 after(() => {
 	localPort.close();
 	remotePort.close();