@zenfs/core 2.5.7 → 2.6.0

package/dist/node/promises.js

@@ -55,14 +55,15 @@ import { Exception, rethrow, UV } from 'kerium';
 import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
-import { join, matchesGlob } from '../path.js';
+import { dirname, join, matchesGlob } from '../path.js';
 import '../polyfills.js';
-import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
 import * as _async from '../vfs/async.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
 import * as flags from '../vfs/flags.js';
 import { _statfs, resolveMount } from '../vfs/shared.js';
+import { cacheOf, lockPath } from '../vfs/vcache.js';
 import { emitChange, FSWatcher } from '../vfs/watchers.js';
 import { Dir, Dirent } from './dir.js';
 import { createInterface } from './readline.js';
@@ -133,11 +134,15 @@ async function* applyTransform(source, transform, signal) {
 }
 export class FileHandle {
     context;
-    fd;
     vfs;
+    _fd;
+    /** The file descriptor, or -1 once the handle has been closed */
+    get fd() {
+        return this._fd;
+    }
     constructor(context, fd) {
         this.context = context;
-        this.fd = fd;
+        this._fd = fd;
         this.vfs = fromFD(context, fd);
     }
     _emitChange() {
@@ -250,7 +255,7 @@ export class FileHandle {
     readableWebStream(options = {}) {
         if (this.vfs.isClosed)
             throw UV('EBADF', 'readableWebStream', this.vfs.path);
-        return this.vfs.fs.streamRead(this.vfs.internalPath, options);
+        return this.vfs.streamRead(options);
     }
     /**
      * Not part of the Node.js API!
@@ -264,7 +269,7 @@ export class FileHandle {
             throw UV('EBADF', 'writableWebStream', this.vfs.path);
         if (this.vfs.inode.flags & InodeFlags.Immutable)
             throw UV('EPERM', 'writableWebStream', this.vfs.path);
-        return this.vfs.fs.streamWrite(this.vfs.internalPath, options);
+        return this.vfs.streamWrite(options);
     }
     /**
      * Creates a readline Interface object that allows reading the file line by line
@@ -340,7 +345,9 @@ export class FileHandle {
      */
     async close() {
         await this.vfs.close();
-        deleteFD(this.context, this.fd);
+        deleteFD(this.context, this._fd);
+        // Like Node, the descriptor is invalidated so later use fails validation
+        this._fd = -1;
     }
     /**
      * Asynchronous `writev`. Writes from multiple buffers.
@@ -377,6 +384,7 @@ export class FileHandle {
      * @param options Options for the readable stream
      */
     createReadStream(options = {}) {
+        validateFD(this._fd);
         if (this.vfs.isClosed || this.vfs.flag & constants.O_WRONLY)
             throw UV('EBADF', 'createReadStream', this.vfs.path);
         return new ReadStream(options, this);
@@ -386,6 +394,7 @@ export class FileHandle {
      * @param options Options for the writeable stream.
      */
     createWriteStream(options = {}) {
+        validateFD(this._fd);
         if (this.vfs.isClosed)
             throw UV('EBADF', 'createWriteStream', this.vfs.path);
         if (this.vfs.inode.flags & InodeFlags.Immutable)
@@ -559,14 +568,26 @@ export async function truncate(path, len = 0) {
 }
 truncate;
 export async function unlink(path) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path, this);
-    const $ex = { syscall: 'unlink', path };
-    const stats = await fs.stat(resolved).catch(rethrow($ex));
-    if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-        throw UV('EACCES', $ex);
-    await fs.unlink(resolved).catch(rethrow($ex));
-    emitChange(this, 'rename', path.toString());
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath(path);
+        const { fs, path: resolved } = resolveMount(path, this);
+        const $ex = { syscall: 'unlink', path };
+        const stats = await fs.stat(resolved).catch(rethrow($ex));
+        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
+            throw UV('EACCES', $ex);
+        const _ = __addDisposableResource(env_2, await lockPath(fs, dirname(resolved), 'rw'), false);
+        await fs.unlink(resolved).catch(rethrow($ex));
+        cacheOf(fs).remove(resolved);
+        emitChange(this, 'rename', path.toString());
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
 }
 unlink;
 /**
@@ -581,18 +602,18 @@ export async function open(path, flag = 'r', mode = 0o644) {
 }
 open;
 export async function readFile(path, _options) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
+    const env_3 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, null, 'r', 0o444);
-        const handle = __addDisposableResource(env_2, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
+        const handle = __addDisposableResource(env_3, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
         return await handle.readFile(options);
     }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
     }
     finally {
-        const result_2 = __disposeResources(env_2);
+        const result_2 = __disposeResources(env_3);
         if (result_2)
             await result_2;
     }
@@ -607,21 +628,21 @@ readFile;
  * @option flag Defaults to `'w'`.
  */
 export async function writeFile(path, data, _options) {
-    const env_3 = { stack: [], error: void 0, hasError: false };
+    const env_4 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'w+', 0o644);
-        const handle = __addDisposableResource(env_3, path instanceof FileHandle ? path : await open.call(this, path.toString(), options.flag, options.mode), true);
+        const handle = __addDisposableResource(env_4, path instanceof FileHandle ? path : await open.call(this, path.toString(), options.flag, options.mode), true);
         const _data = typeof data == 'string' ? data : data instanceof DataView ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : data;
         if (typeof _data != 'string' && !(_data instanceof Uint8Array))
             throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data);
         await handle.writeFile(_data, options);
     }
-    catch (e_3) {
-        env_3.error = e_3;
-        env_3.hasError = true;
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
     }
     finally {
-        const result_3 = __disposeResources(env_3);
+        const result_3 = __disposeResources(env_4);
         if (result_3)
             await result_3;
     }
@@ -634,41 +655,55 @@ writeFile;
  * @option flag Defaults to `'a'`.
  */
 export async function appendFile(path, data, _options) {
-    const env_4 = { stack: [], error: void 0, hasError: false };
+    const env_5 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
         const flag = flags.parse(options.flag);
         const $ex = { syscall: 'write', path: path instanceof FileHandle ? path['vfs'].path : path.toString() };
         if (!(flag & constants.O_APPEND))
             throw UV('EBADF', $ex);
+        if (typeof data != 'string' && !ArrayBuffer.isView(data))
+            throw new TypeError('The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data);
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
-        const handle = __addDisposableResource(env_4, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
+        const handle = __addDisposableResource(env_5, typeof path == 'object' && 'fd' in path ? path : await open.call(this, path, options.flag, options.mode), true);
         await handle.appendFile(encodedData, options);
     }
-    catch (e_4) {
-        env_4.error = e_4;
-        env_4.hasError = true;
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
     }
     finally {
-        const result_4 = __disposeResources(env_4);
+        const result_4 = __disposeResources(env_5);
         if (result_4)
             await result_4;
     }
 }
 appendFile;
 export async function rmdir(path) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = await _async.resolve(this, path);
-    const $ex = { syscall: 'rmdir', path };
-    const stats = await fs.stat(resolved).catch(rethrow($ex));
-    if (!stats)
-        throw UV('ENOENT', $ex);
-    if (!isDirectory(stats))
-        throw UV('ENOTDIR', $ex);
-    if (checkAccess && !hasAccess(this, stats, constants.W_OK))
-        throw UV('EACCES', $ex);
-    await fs.rmdir(resolved).catch(rethrow($ex));
-    emitChange(this, 'rename', path.toString());
+    const env_6 = { stack: [], error: void 0, hasError: false };
+    try {
+        path = normalizePath(path);
+        const { fs, path: resolved } = await _async.resolve(this, path);
+        const $ex = { syscall: 'rmdir', path };
+        const stats = await fs.stat(resolved).catch(rethrow($ex));
+        if (!stats)
+            throw UV('ENOENT', $ex);
+        if (!isDirectory(stats))
+            throw UV('ENOTDIR', $ex);
+        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
+            throw UV('EACCES', $ex);
+        const _ = __addDisposableResource(env_6, await lockPath(fs, dirname(resolved), 'rw'), false);
+        await fs.rmdir(resolved).catch(rethrow($ex));
+        cacheOf(fs).remove(resolved);
+        emitChange(this, 'rename', path.toString());
+    }
+    catch (e_6) {
+        env_6.error = e_6;
+        env_6.hasError = true;
+    }
+    finally {
+        __disposeResources(env_6);
+    }
 }
 rmdir;
 export async function mkdir(path, options) {
@@ -684,7 +719,7 @@ export async function readdir(path, options) {
     const values = [];
     for (const entry of rawEntries) {
         if (opt.withFileTypes) {
-            values.push(Dirent.from(entry, opt.encoding));
+            values.push(Dirent.from(entry, opt.encoding, path));
         }
         else if (opt.encoding == 'buffer') {
             values.push(Buffer.from(entry.path));
@@ -707,24 +742,24 @@ link;
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
 export async function symlink(dest, path, type = 'file') {
-    const env_5 = { stack: [], error: void 0, hasError: false };
+    const env_7 = { stack: [], error: void 0, hasError: false };
     try {
         if (!['file', 'dir', 'junction'].includes(type))
             throw new TypeError('Invalid symlink type: ' + type);
         path = normalizePath(path);
         if (await exists.call(this, path))
             throw UV('EEXIST', 'symlink', path);
-        const handle = __addDisposableResource(env_5, await _async.open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
+        const handle = __addDisposableResource(env_7, await _async.open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
         const encoded = encodeUTF8(normalizePath(dest, true));
         await handle.write(encoded, 0, encoded.length, 0);
         await handle.chmod(constants.S_IFLNK);
     }
-    catch (e_5) {
-        env_5.error = e_5;
-        env_5.hasError = true;
+    catch (e_7) {
+        env_7.error = e_7;
+        env_7.hasError = true;
     }
     finally {
-        const result_5 = __disposeResources(env_5);
+        const result_5 = __disposeResources(env_7);
         if (result_5)
             await result_5;
     }
@@ -739,26 +774,26 @@ export async function readlink(path, options) {
 }
 readlink;
 export async function chown(path, uid, gid) {
-    const env_6 = { stack: [], error: void 0, hasError: false };
+    const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_6, await open.call(this, path, 'r+'), true);
+        const handle = __addDisposableResource(env_8, await open.call(this, path, 'r+'), true);
         await handle.chown(uid, gid);
     }
-    catch (e_6) {
-        env_6.error = e_6;
-        env_6.hasError = true;
+    catch (e_8) {
+        env_8.error = e_8;
+        env_8.hasError = true;
     }
     finally {
-        const result_6 = __disposeResources(env_6);
+        const result_6 = __disposeResources(env_8);
         if (result_6)
             await result_6;
     }
 }
 chown;
 export async function lchown(path, uid, gid) {
-    const env_7 = { stack: [], error: void 0, hasError: false };
+    const env_9 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_7, await _async.open(this, path, {
+        const handle = __addDisposableResource(env_9, await _async.open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -766,39 +801,39 @@ export async function lchown(path, uid, gid) {
         }), true);
         await handle.chown(uid, gid);
     }
-    catch (e_7) {
-        env_7.error = e_7;
-        env_7.hasError = true;
+    catch (e_9) {
+        env_9.error = e_9;
+        env_9.hasError = true;
     }
     finally {
-        const result_7 = __disposeResources(env_7);
+        const result_7 = __disposeResources(env_9);
         if (result_7)
             await result_7;
     }
 }
 lchown;
 export async function chmod(path, mode) {
-    const env_8 = { stack: [], error: void 0, hasError: false };
+    const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_8, await open.call(this, path, 'r+'), true);
+        const handle = __addDisposableResource(env_10, await open.call(this, path, 'r+').catch(rethrow({ syscall: 'chmod', path: normalizePath(path) })), true);
         await handle.chmod(mode);
     }
-    catch (e_8) {
-        env_8.error = e_8;
-        env_8.hasError = true;
+    catch (e_10) {
+        env_10.error = e_10;
+        env_10.hasError = true;
     }
     finally {
-        const result_8 = __disposeResources(env_8);
+        const result_8 = __disposeResources(env_10);
         if (result_8)
             await result_8;
     }
 }
 chmod;
 export async function lchmod(path, mode) {
-    const env_9 = { stack: [], error: void 0, hasError: false };
+    const env_11 = { stack: [], error: void 0, hasError: false };
     try {
         mode = normalizeMode(mode);
-        const handle = __addDisposableResource(env_9, await _async.open(this, path, {
+        const handle = __addDisposableResource(env_11, await _async.open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -806,12 +841,12 @@ export async function lchmod(path, mode) {
         }), true);
         await handle.chmod(mode);
     }
-    catch (e_9) {
-        env_9.error = e_9;
-        env_9.hasError = true;
+    catch (e_11) {
+        env_11.error = e_11;
+        env_11.hasError = true;
     }
     finally {
-        const result_9 = __disposeResources(env_9);
+        const result_9 = __disposeResources(env_11);
         if (result_9)
             await result_9;
     }
@@ -821,20 +856,20 @@ lchmod;
  * Change file timestamps of the file referenced by the supplied path.
  */
 export async function utimes(path, atime, mtime) {
-    const env_10 = { stack: [], error: void 0, hasError: false };
+    const env_12 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await _async.open(this, path, {
+        const handle = __addDisposableResource(env_12, await _async.open(this, path, {
             flag: 'r+',
             allowDirectory: true,
         }), true);
         await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
     }
-    catch (e_10) {
-        env_10.error = e_10;
-        env_10.hasError = true;
+    catch (e_12) {
+        env_12.error = e_12;
+        env_12.hasError = true;
     }
     finally {
-        const result_10 = __disposeResources(env_10);
+        const result_10 = __disposeResources(env_12);
         if (result_10)
             await result_10;
     }
@@ -844,9 +879,9 @@ utimes;
  * Change file timestamps of the file referenced by the supplied path.
  */
 export async function lutimes(path, atime, mtime) {
-    const env_11 = { stack: [], error: void 0, hasError: false };
+    const env_13 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_11, await _async.open(this, path, {
+        const handle = __addDisposableResource(env_13, await _async.open(this, path, {
             flag: 'r+',
             mode: 0o644,
             preserveSymlinks: true,
@@ -854,12 +889,12 @@ export async function lutimes(path, atime, mtime) {
         }), true);
         await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
     }
-    catch (e_11) {
-        env_11.error = e_11;
-        env_11.hasError = true;
+    catch (e_13) {
+        env_13.error = e_13;
+        env_13.hasError = true;
     }
     finally {
-        const result_11 = __disposeResources(env_11);
+        const result_11 = __disposeResources(env_13);
         if (result_11)
             await result_11;
     }
@@ -878,7 +913,8 @@ export async function realpath(path, options) {
 }
 realpath;
 export function watch(filename, options = {}) {
-    const watcher = new FSWatcher(this, filename.toString(), typeof options !== 'string' ? options : { encoding: options });
+    const opts = typeof options !== 'string' ? options : { encoding: options };
+    const watcher = new FSWatcher(this, filename.toString(), opts);
     // A queue to hold change events, since we need to resolve them in the async iterator
     const eventQueue = [];
     let done = false;
@@ -888,12 +924,17 @@ export function watch(filename, options = {}) {
     function cleanup() {
         done = true;
         watcher.close();
+        opts.signal?.removeEventListener('abort', cleanup);
         for (const resolve of eventQueue) {
             resolve({ value: null, done });
         }
         eventQueue.length = 0; // Clear the queue
         return Promise.resolve({ value: undefined, done: true });
     }
+    if (opts.signal?.aborted)
+        void cleanup();
+    else
+        opts.signal?.addEventListener('abort', cleanup, { once: true });
     return {
         async next() {
             if (done)

package/dist/node/streams.d.ts

@@ -51,6 +51,10 @@ export declare class ReadStream extends Readable implements fs.ReadStream {
     private ready;
     constructor(opts: CreateReadStreamOptions | undefined, handleOrPromise: FileHandle | Promise<FileHandle>);
     _read(): Promise<void>;
+    /**
+     * Like Node, the callback is invoked once the stream is closed.
+     * Closing before the stream has finished reports `ERR_STREAM_PREMATURE_CLOSE`.
+     */
     close(callback?: Callback<[void]>): void;
     get path(): string;
     get bytesRead(): number;

package/dist/node/streams.js

@@ -1,6 +1,6 @@
 import { Errno, Exception, UV } from 'kerium';
 import { warn } from 'kerium/log';
-import { Readable, Writable } from 'readable-stream';
+import { finished, Readable, Writable } from 'readable-stream';
 /**
  * A ReadStream implementation that wraps an underlying global ReadableStream.
  */
@@ -15,7 +15,8 @@ export class ReadStream extends Readable {
         this.ready = Promise.resolve(handleOrPromise)
             .then(handle => {
             this._path = handle['vfs'].path;
-            const internal = handle.readableWebStream({ start: opts.start, end: opts.end });
+            // `end` is inclusive for streams, but the internal range is not
+            const internal = handle.readableWebStream({ start: opts.start, end: opts.end === undefined ? undefined : opts.end + 1 });
             this.reader = internal.getReader();
             this.pending = false;
         })
@@ -40,15 +41,13 @@ export class ReadStream extends Readable {
             this.destroy(new Exception(Errno.EIO, err.toString()));
         }
     }
+    /**
+     * Like Node, the callback is invoked once the stream is closed.
+     * Closing before the stream has finished reports `ERR_STREAM_PREMATURE_CLOSE`.
+     */
     close(callback = () => null) {
-        try {
-            this.destroy();
-            this.emit('close');
-            callback(null);
-        }
-        catch (err) {
-            callback(new Exception(Errno.EIO, err.toString()));
-        }
+        finished(this, error => callback(error ?? null));
+        this.destroy();
     }
     get path() {
         return this._path;