@zenfs/core 2.5.8 → 2.6.0

package/dist/vfs/file.js

@@ -1,371 +1,674 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { UV, withErrno } from 'kerium';
+import { memoize } from 'utilium';
 import * as c from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
 import { _chown, InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
 import '../polyfills.js';
+import { validateFD } from '../utils.js';
+import { cacheOf } from './vcache.js';
+/** The chunk size used when streaming reads and writes */
+const streamChunkSize = 0x1000;
 /**
  * @internal
  */
-export class Handle {
-    context;
-    path;
-    fs;
-    internalPath;
-    flag;
-    inode;
-    _buffer;
-    /**
-     * Current position
-     */
-    _position = 0;
-    /**
-     * Get the current file position.
-     *
-     * We emulate the following bug mentioned in the Node documentation:
-     *
-     * On Linux, positional writes don't work when the file is opened in append mode.
-     * The kernel ignores the position argument and always appends the data to the end of the file.
-     * @returns The current file position.
-     */
-    get position() {
-        return this.flag & c.O_APPEND ? this.inode.size : this._position;
-    }
-    set position(value) {
-        this._position = value;
-    }
-    /**
-     * Whether the file has changes which have not been written to the FS
-     */
-    dirty = false;
-    /**
-     * Whether the file is open or closed
-     */
-    closed = false;
-    get isClosed() {
-        return this.closed;
-    }
-    /**
-     * Creates a file with `path` and, optionally, the given contents.
-     * Note that, if contents is specified, it will be mutated by the file.
-     */
-    constructor(context, path, fs, internalPath, flag, inode) {
-        this.context = context;
-        this.path = path;
-        this.fs = fs;
-        this.internalPath = internalPath;
-        this.flag = flag;
-        this.inode = inode;
-    }
-    get _isSync() {
-        return !!(this.flag & c.O_SYNC || this.inode.flags & InodeFlags.Sync || this.fs.attributes.has('sync'));
-    }
-    [Symbol.dispose]() {
-        this.closeSync();
-    }
-    syncSync() {
-        if (this.closed)
-            throw UV('EBADF', 'sync', this.path);
-        if (!this.dirty)
-            return;
-        if (!this.fs.attributes.has('no_write'))
-            this.fs.touchSync(this.internalPath, this.inode);
-        this.dirty = false;
-    }
-    /**
-     * Default implementation maps to `syncSync`.
-     */
-    datasyncSync() {
-        return this.syncSync();
-    }
-    closeSync() {
-        if (this.closed)
-            throw UV('EBADF', 'close', this.path);
-        this.syncSync();
-        this.disposeSync();
-    }
-    /**
-     * Cleans up. This will *not* sync the file data to the FS
-     */
-    disposeSync(force) {
-        if (this.closed)
-            throw UV('EBADF', 'close', this.path);
-        if (this.dirty && !force)
-            throw UV('EBUSY', 'close', this.path);
-        this.closed = true;
-    }
-    truncateSync(length) {
-        if (length < 0)
-            throw UV('EINVAL', 'truncate', this.path);
-        if (this.closed)
-            throw UV('EBADF', 'truncate', this.path);
-        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
-            throw UV('EBADF', 'truncate', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'truncate', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'truncate', this.path);
-        this.dirty = true;
-        this.inode.mtimeMs = Date.now();
-        this.inode.size = length;
-        this.inode.ctimeMs = Date.now();
-        if (this._isSync)
-            this.syncSync();
-    }
-    /**
-     * Write buffer to the file.
-     * @param buffer Uint8Array containing the data to write to the file.
-     * @param offset Offset in the buffer to start reading data from.
-     * @param length The amount of bytes to write to the file.
-     * @param position Offset from the beginning of the file where this data should be written.
-     * If position is null, the data will be written at  the current position.
-     * @returns bytes written
-     */
-    writeSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        if (this.closed)
-            throw UV('EBADF', 'write', this.path);
-        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
-            throw UV('EBADF', 'write', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'write', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'write', this.path);
-        this.dirty = true;
-        const end = position + length;
-        const slice = buffer.subarray(offset, offset + length);
-        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size)
-            this.inode.size = end;
-        this.inode.mtimeMs = Date.now();
-        this.inode.ctimeMs = Date.now();
-        this._position = position + slice.byteLength;
-        this.fs.writeSync(this.internalPath, slice, position);
-        if (this._isSync)
-            this.syncSync();
-        return slice.byteLength;
-    }
-    /**
-     * Read data from the file.
-     * @param buffer The buffer that the data will be written to.
-     * @param offset The offset within the buffer where writing will start.
-     * @param length An integer specifying the number of bytes to read.
-     * @param position An integer specifying where to begin reading from in the file.
-     * If position is null, data will be read from the current file position.
-     * @returns number of bytes written
-     */
-    readSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        if (this.closed)
-            throw UV('EBADF', 'read', this.path);
-        if (this.flag & c.O_WRONLY)
-            throw UV('EBADF', 'read', this.path);
-        if (!(this.inode.flags & InodeFlags.NoAtime) && !this.fs.attributes.has('no_atime')) {
-            this.dirty = true;
-            this.inode.atimeMs = Date.now();
-        }
-        let end = position + length;
-        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
-            end = position + Math.max(this.inode.size - position, 0);
-        }
-        this._position = end;
-        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        this.fs.readSync(this.internalPath, uint8.subarray(offset, offset + length), position, end);
-        if (this._isSync)
-            this.syncSync();
-        return end - position;
-    }
-    chmodSync(mode) {
-        if (this.closed)
-            throw UV('EBADF', 'chmod', this.path);
-        this.dirty = true;
-        this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
-        if (this._isSync || mode > c.S_IFMT)
-            this.syncSync();
-    }
-    chownSync(uid, gid) {
-        if (this.closed)
-            throw UV('EBADF', 'chmod', this.path);
-        this.dirty = true;
-        _chown(this.inode, uid, gid);
-        if (this._isSync)
-            this.syncSync();
-    }
-    /**
-     * Change the file timestamps of the file.
-     */
-    utimesSync(atime, mtime) {
-        if (this.closed)
-            throw UV('EBADF', 'utimes', this.path);
-        this.dirty = true;
-        this.inode.atimeMs = atime;
-        this.inode.mtimeMs = mtime;
-        if (this._isSync)
+let Handle = (() => {
+    let _instanceExtraInitializers = [];
+    let _get_inode_decorators;
+    let _get_fs_decorators;
+    return class Handle {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(this, null, _get_inode_decorators, { kind: "getter", name: "inode", static: false, private: false, access: { has: obj => "inode" in obj, get: obj => obj.inode }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _get_fs_decorators, { kind: "getter", name: "fs", static: false, private: false, access: { has: obj => "fs" in obj, get: obj => obj.fs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        context = __runInitializers(this, _instanceExtraInitializers);
+        path;
+        internalPath;
+        flag;
+        vnode;
+        /**
+         * Current position
+         */
+        _position = 0;
+        /**
+         * Get the current file position.
+         *
+         * We emulate the following bug mentioned in the Node documentation:
+         *
+         * On Linux, positional writes don't work when the file is opened in append mode.
+         * The kernel ignores the position argument and always appends the data to the end of the file.
+         * @returns The current file position.
+         */
+        get position() {
+            return this.flag & c.O_APPEND ? this.inode.size : this._position;
+        }
+        set position(value) {
+            this._position = value;
+        }
+        /**
+         * The inode for the file. This is shared between all handles for the file via the vnode.
+         */
+        get inode() {
+            return this.vnode.inode;
+        }
+        get fs() {
+            return this.vnode.fs;
+        }
+        /**
+         * Whether the file has changes which have not been written to the FS
+         */
+        get dirty() {
+            return this.vnode.dirty;
+        }
+        /**
+         * Whether the file is open or closed
+         */
+        closed = false;
+        get isClosed() {
+            return this.closed;
+        }
+        /**
+         * Creates a file handle for the vnode.
+         */
+        constructor(context, path, internalPath, flag, vnode) {
+            this.context = context;
+            this.path = path;
+            this.internalPath = internalPath;
+            this.flag = flag;
+            this.vnode = vnode;
+        }
+        get _isSync() {
+            return !!(this.flag & c.O_SYNC || this.inode.flags & InodeFlags.Sync || this.fs.attributes.has('sync'));
+        }
+        [(_get_inode_decorators = [memoize], _get_fs_decorators = [memoize], Symbol.dispose)]() {
+            this.closeSync();
+        }
+        syncSync() {
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'sync', this.path);
+                if (!this.dirty)
+                    return;
+                const _ = __addDisposableResource(env_1, this.vnode.lockSync('ro'), false);
+                this.vnode.syncSync();
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                __disposeResources(env_1);
+            }
+        }
+        /**
+         * Default implementation maps to `syncSync`.
+         */
+        datasyncSync() {
+            return this.syncSync();
+        }
+        closeSync() {
+            if (this.closed)
+                throw UV('EBADF', 'close', this.path);
             this.syncSync();
-    }
-    async [Symbol.asyncDispose]() {
-        await this.close();
-    }
-    async sync() {
-        if (this.closed)
-            throw UV('EBADF', 'sync', this.path);
-        if (!this.dirty)
-            return;
-        if (!this.fs.attributes.has('no_write'))
-            await this.fs.touch(this.internalPath, this.inode);
-        this.dirty = false;
-    }
-    /**
-     * Default implementation maps to `sync`.
-     */
-    datasync() {
-        return this.sync();
-    }
-    async close() {
-        if (this.closed)
-            throw UV('EBADF', 'close', this.path);
-        await this.sync();
-        this.dispose();
-    }
-    /**
-     * Cleans up. This will *not* sync the file data to the FS
-     */
-    dispose(force) {
-        if (this.closed)
-            throw UV('EBADF', 'close', this.path);
-        if (this.dirty && !force)
-            throw UV('EBUSY', 'close', this.path);
-        this.closed = true;
-    }
-    stat() {
-        if (this.closed)
-            throw UV('EBADF', 'stat', this.path);
-        return this.inode;
-    }
-    async truncate(length) {
-        if (length < 0)
-            throw UV('EINVAL', 'truncate', this.path);
-        if (this.closed)
-            throw UV('EBADF', 'truncate', this.path);
-        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
-            throw UV('EBADF', 'truncate', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'truncate', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'truncate', this.path);
-        this.dirty = true;
-        this.inode.mtimeMs = Date.now();
-        this.inode.size = length;
-        this.inode.ctimeMs = Date.now();
-        if (this._isSync)
-            await this.sync();
-    }
-    /**
-     * Write buffer to the file.
-     * @param buffer Uint8Array containing the data to write to the file.
-     * @param offset Offset in the buffer to start reading data from.
-     * @param length The amount of bytes to write to the file.
-     * @param position Offset from the beginning of the file where this data should be written.
-     * If position is null, the data will be written at  the current position.
-     * @returns bytes written
-     */
-    async write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        if (this.closed)
-            throw UV('EBADF', 'write', this.path);
-        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
-            throw UV('EBADF', 'write', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'write', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'write', this.path);
-        this.dirty = true;
-        const end = position + length;
-        const slice = buffer.subarray(offset, offset + length);
-        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size)
-            this.inode.size = end;
-        this.inode.mtimeMs = Date.now();
-        this.inode.ctimeMs = Date.now();
-        this._position = position + slice.byteLength;
-        await this.fs.write(this.internalPath, slice, position);
-        if (this._isSync)
-            await this.sync();
-        return slice.byteLength;
-    }
-    /**
-     * Read data from the file.
-     * @param buffer The buffer that the data will be written to.
-     * @param offset The offset within the buffer where writing will start.
-     * @param length An integer specifying the number of bytes to read.
-     * @param position An integer specifying where to begin reading from in the file.
-     * If position is null, data will be read from the current file position.
-     * @returns number of bytes written
-     */
-    async read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
-        if (this.closed)
-            throw UV('EBADF', 'read', this.path);
-        if (this.flag & c.O_WRONLY)
-            throw UV('EBADF', 'read', this.path);
-        if (!(this.inode.flags & InodeFlags.NoAtime) && !this.fs.attributes.has('no_atime')) {
-            this.dirty = true;
-            this.inode.atimeMs = Date.now();
-        }
-        let end = position + length;
-        if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
-            end = position + Math.max(this.inode.size - position, 0);
-        }
-        this._position = end;
-        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        await this.fs.read(this.internalPath, uint8.subarray(offset, offset + length), position, end);
-        if (this._isSync)
-            await this.sync();
-        return end - position;
-    }
-    async chmod(mode) {
-        if (this.closed)
-            throw UV('EBADF', 'chmod', this.path);
-        this.dirty = true;
-        this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
-        if (this._isSync || mode > c.S_IFMT)
-            await this.sync();
-    }
-    async chown(uid, gid) {
-        if (this.closed)
-            throw UV('EBADF', 'chown', this.path);
-        this.dirty = true;
-        _chown(this.inode, uid, gid);
-        if (this._isSync)
-            await this.sync();
-    }
-    /**
-     * Change the file timestamps of the file.
-     */
-    async utimes(atime, mtime) {
-        if (this.closed)
-            throw UV('EBADF', 'utimes', this.path);
-        this.dirty = true;
-        this.inode.atimeMs = atime;
-        this.inode.mtimeMs = mtime;
-        if (this._isSync)
+            this.disposeSync();
+        }
+        /**
+         * Cleans up. This will *not* sync the file data to the FS
+         */
+        disposeSync(force) {
+            if (this.closed)
+                throw UV('EBADF', 'close', this.path);
+            if (this.dirty && !force)
+                throw UV('EBUSY', 'close', this.path);
+            this.closed = true;
+            cacheOf(this.fs).unref(this.vnode);
+        }
+        truncateSync(length) {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (length < 0)
+                    throw UV('EINVAL', 'truncate', this.path);
+                if (this.closed)
+                    throw UV('EBADF', 'truncate', this.path);
+                if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+                    throw UV('EBADF', 'truncate', this.path);
+                if (this.fs.attributes.has('readonly'))
+                    throw UV('EROFS', 'truncate', this.path);
+                if (this.inode.flags & InodeFlags.Immutable)
+                    throw UV('EPERM', 'truncate', this.path);
+                const _ = __addDisposableResource(env_2, this.vnode.lockSync('rw'), false);
+                this.vnode.truncate(length);
+                if (this._isSync)
+                    this.vnode.syncSync();
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        }
+        /**
+         * Write buffer to the file.
+         * @param buffer Uint8Array containing the data to write to the file.
+         * @param offset Offset in the buffer to start reading data from.
+         * @param length The amount of bytes to write to the file.
+         * @param position Offset from the beginning of the file where this data should be written.
+         * If position is null, the data will be written at  the current position.
+         * @returns bytes written
+         */
+        writeSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'write', this.path);
+                if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+                    throw UV('EBADF', 'write', this.path);
+                if (this.fs.attributes.has('readonly'))
+                    throw UV('EROFS', 'write', this.path);
+                if (this.inode.flags & InodeFlags.Immutable)
+                    throw UV('EPERM', 'write', this.path);
+                const _ = __addDisposableResource(env_3, this.vnode.lockSync('rw'), false);
+                const slice = buffer.subarray(offset, offset + length);
+                this.vnode.writeSync(slice, position);
+                this._position = position + slice.byteLength;
+                if (this._isSync)
+                    this.vnode.syncSync();
+                return slice.byteLength;
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                __disposeResources(env_3);
+            }
+        }
+        /**
+         * Read data from the file.
+         * @param buffer The buffer that the data will be written to.
+         * @param offset The offset within the buffer where writing will start.
+         * @param length An integer specifying the number of bytes to read.
+         * @param position An integer specifying where to begin reading from in the file.
+         * If position is null, data will be read from the current file position.
+         * @returns number of bytes written
+         */
+        readSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+            const env_4 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'read', this.path);
+                if (this.flag & c.O_WRONLY)
+                    throw UV('EBADF', 'read', this.path);
+                const _ = __addDisposableResource(env_4, this.vnode.lockSync('ro'), false);
+                if (!(this.inode.flags & InodeFlags.NoAtime) && !this.fs.attributes.has('no_atime')) {
+                    this.vnode.metadataDirty = true;
+                    this.inode.atimeMs = Date.now();
+                }
+                let end = position + length;
+                if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
+                    end = position + Math.max(this.inode.size - position, 0);
+                }
+                this._position = end;
+                const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+                this.vnode.readSync(uint8.subarray(offset, offset + length), position, end);
+                if (this._isSync)
+                    this.vnode.syncSync();
+                return end - position;
+            }
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
+            }
+            finally {
+                __disposeResources(env_4);
+            }
+        }
+        chmodSync(mode) {
+            const env_5 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'chmod', this.path);
+                const _ = __addDisposableResource(env_5, this.vnode.lockSync('rw'), false);
+                this.vnode.metadataDirty = true;
+                this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+                if (this._isSync || mode > c.S_IFMT)
+                    this.vnode.syncSync();
+            }
+            catch (e_5) {
+                env_5.error = e_5;
+                env_5.hasError = true;
+            }
+            finally {
+                __disposeResources(env_5);
+            }
+        }
+        chownSync(uid, gid) {
+            const env_6 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'chmod', this.path);
+                const _ = __addDisposableResource(env_6, this.vnode.lockSync('rw'), false);
+                this.vnode.metadataDirty = true;
+                _chown(this.inode, uid, gid);
+                if (this._isSync)
+                    this.vnode.syncSync();
+            }
+            catch (e_6) {
+                env_6.error = e_6;
+                env_6.hasError = true;
+            }
+            finally {
+                __disposeResources(env_6);
+            }
+        }
+        /**
+         * Change the file timestamps of the file.
+         */
+        utimesSync(atime, mtime) {
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'utimes', this.path);
+                const _ = __addDisposableResource(env_7, this.vnode.lockSync('rw'), false);
+                this.vnode.metadataDirty = true;
+                this.inode.atimeMs = atime;
+                this.inode.mtimeMs = mtime;
+                if (this._isSync)
+                    this.vnode.syncSync();
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                __disposeResources(env_7);
+            }
+        }
+        async [Symbol.asyncDispose]() {
+            await this.close();
+        }
+        async sync() {
+            const env_8 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'sync', this.path);
+                if (!this.dirty)
+                    return;
+                const _ = __addDisposableResource(env_8, await this.vnode.lock('ro'), false);
+                await this.vnode.sync();
+            }
+            catch (e_8) {
+                env_8.error = e_8;
+                env_8.hasError = true;
+            }
+            finally {
+                __disposeResources(env_8);
+            }
+        }
+        /**
+         * Default implementation maps to `sync`.
+         */
+        datasync() {
+            return this.sync();
+        }
+        async close() {
+            if (this.closed)
+                throw UV('EBADF', 'close', this.path);
             await this.sync();
-    }
-    /**
-     * Create a stream for reading the file.
-     */
-    streamRead(options) {
-        if (this.closed)
-            throw UV('EBADF', 'streamRead', this.path);
-        return this.fs.streamRead(this.internalPath, options);
-    }
-    /**
-     * Create a stream for writing the file.
-     */
-    streamWrite(options) {
-        if (this.closed)
-            throw UV('EBADF', 'write', this.path);
-        if (this.inode.flags & InodeFlags.Immutable)
-            throw UV('EPERM', 'write', this.path);
-        if (this.fs.attributes.has('readonly'))
-            throw UV('EROFS', 'write', this.path);
-        return this.fs.streamWrite(this.internalPath, options);
-    }
-}
+            this.dispose();
+        }
+        /**
+         * Cleans up. This will *not* sync the file data to the FS
+         */
+        dispose(force) {
+            if (this.closed)
+                throw UV('EBADF', 'close', this.path);
+            if (this.dirty && !force)
+                throw UV('EBUSY', 'close', this.path);
+            this.closed = true;
+            cacheOf(this.fs).unref(this.vnode);
+        }
+        stat() {
+            if (this.closed)
+                throw UV('EBADF', 'stat', this.path);
+            return this.inode;
+        }
+        async truncate(length) {
+            const env_9 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (length < 0)
+                    throw UV('EINVAL', 'truncate', this.path);
+                if (this.closed)
+                    throw UV('EBADF', 'truncate', this.path);
+                if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+                    throw UV('EBADF', 'truncate', this.path);
+                if (this.fs.attributes.has('readonly'))
+                    throw UV('EROFS', 'truncate', this.path);
+                if (this.inode.flags & InodeFlags.Immutable)
+                    throw UV('EPERM', 'truncate', this.path);
+                const _ = __addDisposableResource(env_9, await this.vnode.lock('rw'), false);
+                this.vnode.truncate(length);
+                if (this._isSync)
+                    await this.vnode.sync();
+            }
+            catch (e_9) {
+                env_9.error = e_9;
+                env_9.hasError = true;
+            }
+            finally {
+                __disposeResources(env_9);
+            }
+        }
+        /**
+         * Write buffer to the file.
+         * @param buffer Uint8Array containing the data to write to the file.
+         * @param offset Offset in the buffer to start reading data from.
+         * @param length The amount of bytes to write to the file.
+         * @param position Offset from the beginning of the file where this data should be written.
+         * If position is null, the data will be written at  the current position.
+         * @returns bytes written
+         */
+        async write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+            const env_10 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'write', this.path);
+                if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+                    throw UV('EBADF', 'write', this.path);
+                if (this.fs.attributes.has('readonly'))
+                    throw UV('EROFS', 'write', this.path);
+                if (this.inode.flags & InodeFlags.Immutable)
+                    throw UV('EPERM', 'write', this.path);
+                const _ = __addDisposableResource(env_10, await this.vnode.lock('rw'), false);
+                const slice = buffer.subarray(offset, offset + length);
+                await this.vnode.write(slice, position);
+                this._position = position + slice.byteLength;
+                if (this._isSync)
+                    await this.vnode.sync();
+                return slice.byteLength;
+            }
+            catch (e_10) {
+                env_10.error = e_10;
+                env_10.hasError = true;
+            }
+            finally {
+                __disposeResources(env_10);
+            }
+        }
+        /**
+         * Read data from the file.
+         * @param buffer The buffer that the data will be written to.
+         * @param offset The offset within the buffer where writing will start.
+         * @param length An integer specifying the number of bytes to read.
+         * @param position An integer specifying where to begin reading from in the file.
+         * If position is null, data will be read from the current file position.
+         * @returns number of bytes written
+         */
+        async read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+            const env_11 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'read', this.path);
+                if (this.flag & c.O_WRONLY)
+                    throw UV('EBADF', 'read', this.path);
+                const _ = __addDisposableResource(env_11, await this.vnode.lock('ro'), false);
+                if (!(this.inode.flags & InodeFlags.NoAtime) && !this.fs.attributes.has('no_atime')) {
+                    this.vnode.metadataDirty = true;
+                    this.inode.atimeMs = Date.now();
+                }
+                let end = position + length;
+                if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
+                    end = position + Math.max(this.inode.size - position, 0);
+                }
+                this._position = end;
+                const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+                await this.vnode.read(uint8.subarray(offset, offset + length), position, end);
+                if (this._isSync)
+                    await this.vnode.sync();
+                return end - position;
+            }
+            catch (e_11) {
+                env_11.error = e_11;
+                env_11.hasError = true;
+            }
+            finally {
+                __disposeResources(env_11);
+            }
+        }
+        async chmod(mode) {
+            const env_12 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'chmod', this.path);
+                const _ = __addDisposableResource(env_12, await this.vnode.lock('rw'), false);
+                this.vnode.metadataDirty = true;
+                this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+                if (this._isSync || mode > c.S_IFMT)
+                    await this.vnode.sync();
+            }
+            catch (e_12) {
+                env_12.error = e_12;
+                env_12.hasError = true;
+            }
+            finally {
+                __disposeResources(env_12);
+            }
+        }
+        async chown(uid, gid) {
+            const env_13 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'chown', this.path);
+                const _ = __addDisposableResource(env_13, await this.vnode.lock('rw'), false);
+                this.vnode.metadataDirty = true;
+                _chown(this.inode, uid, gid);
+                if (this._isSync)
+                    await this.vnode.sync();
+            }
+            catch (e_13) {
+                env_13.error = e_13;
+                env_13.hasError = true;
+            }
+            finally {
+                __disposeResources(env_13);
+            }
+        }
+        /**
+         * Change the file timestamps of the file.
+         */
+        async utimes(atime, mtime) {
+            const env_14 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (this.closed)
+                    throw UV('EBADF', 'utimes', this.path);
+                const _ = __addDisposableResource(env_14, await this.vnode.lock('rw'), false);
+                this.vnode.metadataDirty = true;
+                this.inode.atimeMs = atime;
+                this.inode.mtimeMs = mtime;
+                if (this._isSync)
+                    await this.vnode.sync();
+            }
+            catch (e_14) {
+                env_14.error = e_14;
+                env_14.hasError = true;
+            }
+            finally {
+                __disposeResources(env_14);
+            }
+        }
+        /**
+         * Create a stream for reading the file.
+         * @todo Don't repeat ourselves with the implementation in `FileSystem`
+         */
+        streamRead(options) {
+            if (this.closed)
+                throw UV('EBADF', 'streamRead', this.path);
+            const { vnode } = this;
+            return new ReadableStream({
+                async start(controller) {
+                    const env_15 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const _ = __addDisposableResource(env_15, await vnode.lock('ro'), false);
+                        const { start = 0, end = vnode.inode.size } = options;
+                        for (let offset = start; offset < end; offset += streamChunkSize) {
+                            const bytesRead = offset + streamChunkSize > end ? end - offset : streamChunkSize;
+                            const buffer = new Uint8Array(bytesRead);
+                            await vnode.read(buffer, offset, offset + bytesRead).catch(controller.error.bind(controller));
+                            controller.enqueue(buffer);
+                        }
+                        controller.close();
+                    }
+                    catch (e_15) {
+                        env_15.error = e_15;
+                        env_15.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_15);
+                    }
+                },
+                type: 'bytes',
+            });
+        }
+        /**
+         * Create a stream for writing the file.
+         * Chunks are written to the vnode's cache, then synced when the stream is closed.
+         * @todo Don't repeat ourselves with the implementation in `FileSystem`
+         */
+        streamWrite(options) {
+            if (this.closed)
+                throw UV('EBADF', 'write', this.path);
+            if (this.inode.flags & InodeFlags.Immutable)
+                throw UV('EPERM', 'write', this.path);
+            if (this.fs.attributes.has('readonly'))
+                throw UV('EROFS', 'write', this.path);
+            const { vnode } = this;
+            let position = options.start ?? 0;
+            return new WritableStream({
+                async write(chunk, controller) {
+                    const env_16 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const _ = __addDisposableResource(env_16, await vnode.lock('rw'), false);
+                        await vnode.write(chunk, position).catch(controller.error.bind(controller));
+                        position += chunk.byteLength;
+                    }
+                    catch (e_16) {
+                        env_16.error = e_16;
+                        env_16.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_16);
+                    }
+                },
+                async close() {
+                    const env_17 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const _ = __addDisposableResource(env_17, await vnode.lock('ro'), false);
+                        await vnode.sync();
+                    }
+                    catch (e_17) {
+                        env_17.error = e_17;
+                        env_17.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_17);
+                    }
+                },
+            });
+        }
+    };
+})();
+export { Handle };
 // descriptors
 /**
  * @internal @hidden
@@ -380,6 +683,7 @@ export function toFD(file) {
  * @internal @hidden
  */
 export function fromFD($, fd) {
+    validateFD(fd);
     const map = contextOf($).descriptors;
     const value = map.get(fd);
     if (!value)