@zenfs/core 1.11.3 → 2.0.0

package/dist/vfs/promises.js

@@ -51,37 +51,74 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
-import { _throw } from 'utilium';
-import { credentials } from '../internal/credentials.js';
+import { _throw, decodeUTF8, pick } from 'utilium';
+import { defaultContext } from '../internal/contexts.js';
 import { Errno, ErrnoError } from '../internal/error.js';
-import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.js';
+import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
+import { dirname, join, parse, resolve } from '../path.js';
 import '../polyfills.js';
-import { BigIntStats } from '../stats.js';
-import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
-import { config } from './config.js';
+import { createInterface } from '../readline.js';
+import { normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { checkAccess } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
-import { dirname, join, parse, resolve } from './path.js';
-import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
+import { deleteFD, fromFD, SyncHandle, toFD } from './file.js';
+import * as flags from './flags.js';
+import { _statfs, fixError, resolveMount } from './shared.js';
+import { _chown, BigIntStats, Stats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
-import { FSWatcher, emitChange } from './watchers.js';
+import { emitChange, FSWatcher } from './watchers.js';
 export * as constants from './constants.js';
 export class FileHandle {
-    constructor(fdOrFile, context) {
+    /**
+     * 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 & constants.O_APPEND ? this.inode.size : this._position;
+    }
+    set position(value) {
+        this._position = value;
+    }
+    constructor(context, fd) {
         this.context = context;
-        const isFile = typeof fdOrFile != 'number';
-        this.fd = isFile ? file2fd(fdOrFile) : fdOrFile;
-        this.file = isFile ? fdOrFile : fd2file(fdOrFile);
+        this.fd = fd;
+        /**
+         * Current position
+         */
+        this._position = 0;
+        /**
+         * Whether the file has changes which have not been written to the FS
+         */
+        this.dirty = false;
+        /**
+         * Whether the file is open or closed
+         */
+        this.closed = false;
+        const sync = fromFD(context, fd);
+        Object.assign(this, pick(sync, 'path', 'fs', 'internalPath', 'flag', 'inode'));
+    }
+    get _isSync() {
+        return !!(this.flag & constants.O_SYNC || this.inode.flags & InodeFlags.Sync);
     }
     _emitChange() {
-        var _a, _b, _c;
-        emitChange(this.context, 'change', this.file.path.slice((_c = (_b = (_a = this.context) === null || _a === void 0 ? void 0 : _a.root) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0));
+        emitChange(this.context, 'change', this.path);
     }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
     async chown(uid, gid) {
-        await this.file.chown(uid, gid);
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chown');
+        this.dirty = true;
+        _chown(this.inode, uid, gid);
+        if (this._isSync)
+            await this.sync();
         this._emitChange();
     }
     /**
@@ -92,30 +129,49 @@ export class FileHandle {
         const numMode = normalizeMode(mode, -1);
         if (numMode < 0)
             throw new ErrnoError(Errno.EINVAL, 'Invalid mode');
-        await this.file.chmod(numMode);
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chmod');
+        this.dirty = true;
+        this.inode.mode = (this.inode.mode & (numMode > constants.S_IFMT ? ~constants.S_IFMT : constants.S_IFMT)) | numMode;
+        if (this._isSync || numMode > constants.S_IFMT)
+            await this.sync();
         this._emitChange();
     }
     /**
      * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
      */
     datasync() {
-        return this.file.datasync();
+        return this.sync();
     }
     /**
      * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
      */
-    sync() {
-        return this.file.sync();
+    async sync() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'sync');
+        if (!this.dirty)
+            return;
+        if (!this.fs.attributes.has('no_write'))
+            await this.fs.touch(this.internalPath, this.inode);
+        this.dirty = false;
     }
     /**
      * Asynchronous ftruncate(2) - Truncate a file to a specified length.
      * @param length If not specified, defaults to `0`.
      */
-    async truncate(length) {
-        length || (length = 0);
+    async truncate(length = 0) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'truncate');
         if (length < 0)
             throw new ErrnoError(Errno.EINVAL);
-        await this.file.truncate(length);
+        this.dirty = true;
+        if (!(this.flag & constants.O_WRONLY || this.flag & constants.O_RDWR)) {
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode', this.path, 'truncate');
+        }
+        this.inode.mtimeMs = Date.now();
+        this.inode.size = length;
+        if (this._isSync)
+            await this.sync();
         this._emitChange();
     }
     /**
@@ -124,7 +180,13 @@ export class FileHandle {
      * @param mtime The last modified time. If a string is provided, it will be coerced to number.
      */
     async utimes(atime, mtime) {
-        await this.file.utimes(normalizeTime(atime), normalizeTime(mtime));
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'utimes');
+        this.dirty = true;
+        this.inode.atimeMs = normalizeTime(atime);
+        this.inode.mtimeMs = normalizeTime(mtime);
+        if (this._isSync)
+            await this.sync();
         this._emitChange();
     }
     /**
@@ -138,17 +200,45 @@ export class FileHandle {
      */
     async appendFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isAppendable(flag)) {
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_APPEND)) {
             throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this.file.write(encodedData, 0, encodedData.length);
+        await this._write(encodedData, 0, encodedData.length);
         this._emitChange();
     }
+    /**
+     * 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 unset, data will be read from the current file position.
+     */
+    async _read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'read');
+        if (this.flag & constants.O_WRONLY)
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode');
+        if (!(this.inode.flags & InodeFlags.NoAtime)) {
+            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 { bytesRead: end - position, buffer };
+    }
     async read(buffer, offset, length, position) {
         if (typeof offset == 'object' && offset != null) {
             position = offset.position;
@@ -161,19 +251,19 @@ export class FileHandle {
             offset = buffer.offset;
             buffer = buffer.buffer;
         }
-        const pos = Number.isSafeInteger(position) ? position : this.file.position;
-        buffer || (buffer = new Uint8Array((await this.file.stat()).size));
+        const pos = Number.isSafeInteger(position) ? position : this.position;
+        buffer || (buffer = new Uint8Array(this.inode.size));
         offset !== null && offset !== void 0 ? offset : (offset = 0);
-        return this.file.read(buffer, offset, length !== null && length !== void 0 ? length : buffer.byteLength - offset, pos);
+        return this._read(buffer, offset, length !== null && length !== void 0 ? length : buffer.byteLength - offset, pos);
     }
     async readFile(_options) {
         const options = normalizeOptions(_options, null, 'r', 0o444);
-        const flag = parseFlag(options.flag);
-        if (!isReadable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading');
+        const flag = flags.parse(options.flag);
+        if (flag & constants.O_WRONLY) {
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for reading', this.path, 'readFile');
         }
         const { size } = await this.stat();
-        const { buffer: data } = await this.file.read(new Uint8Array(size), 0, size, 0);
+        const { buffer: data } = await this._read(new Uint8Array(size), 0, size, 0);
         const buffer = Buffer.from(data);
         return options.encoding ? buffer.toString(options.encoding) : buffer;
     }
@@ -182,23 +272,72 @@ export class FileHandle {
      * The handle will not be closed automatically.
      */
     readableWebStream(options = {}) {
-        return this.file.fs.streamRead(this.file.path, {});
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'readableWebStream');
+        return this.fs.streamRead(this.internalPath, options);
+    }
+    /**
+     * Not part of the Node.js API!
+     *
+     * Write file data using a `WritableStream`.
+     * The handle will not be closed automatically.
+     * @internal
+     */
+    writableWebStream(options = {}) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'writableWebStream');
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'writableWebStream');
+        return this.fs.streamWrite(this.internalPath, options);
     }
     /**
-     * @todo Implement
+     * Creates a readline Interface object that allows reading the file line by line
+     * @param options Options for creating a read stream
+     * @returns A readline interface for reading the file line by line
      */
     readLines(options) {
-        throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
+        if (this.closed || this.flag & constants.O_WRONLY)
+            throw ErrnoError.With('EBADF', this.path, 'readLines');
+        return createInterface({ input: this.createReadStream(options), crlfDelay: Infinity });
     }
     [Symbol.asyncDispose]() {
         return this.close();
     }
     async stat(opts) {
-        const stats = await this.file.stat();
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this.context)) {
-            throw ErrnoError.With('EACCES', this.file.path, 'stat');
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'stat');
+        if (checkAccess && !hasAccess(this.context, this.inode, constants.R_OK)) {
+            throw ErrnoError.With('EACCES', this.path, 'stat');
         }
-        return (opts === null || opts === void 0 ? void 0 : opts.bigint) ? new BigIntStats(stats) : stats;
+        return (opts === null || opts === void 0 ? void 0 : opts.bigint) ? new BigIntStats(this.inode) : new Stats(this.inode);
+    }
+    /**
+     * 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.
+     */
+    async _write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'write');
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'write');
+        if (!(this.flag & constants.O_WRONLY || this.flag & constants.O_RDWR))
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode', this.path, 'write');
+        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;
     }
     /**
      * Asynchronously writes `string` to the file.
@@ -225,8 +364,8 @@ export class FileHandle {
             length = typeof lenOrEnc == 'number' ? lenOrEnc : buffer.byteLength;
             position = typeof position === 'number' ? position : null;
         }
-        position !== null && position !== void 0 ? position : (position = this.file.position);
-        const bytesWritten = await this.file.write(buffer, offset, length, position);
+        position !== null && position !== void 0 ? position : (position = this.position);
+        const bytesWritten = await this._write(buffer, offset, length, position);
         this._emitChange();
         return { buffer: data, bytesWritten };
     }
@@ -242,23 +381,36 @@ export class FileHandle {
      */
     async writeFile(data, _options = {}) {
         const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isWriteable(flag)) {
-            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing');
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_WRONLY || flag & constants.O_RDWR)) {
+            throw new ErrnoError(Errno.EINVAL, 'Flag passed must allow for writing', this.path, 'writeFile');
         }
         if (typeof data != 'string' && !options.encoding) {
             throw new ErrnoError(Errno.EINVAL, 'Encoding not specified');
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
-        await this.file.write(encodedData, 0, encodedData.length, 0);
+        await this._write(encodedData, 0, encodedData.length, 0);
         this._emitChange();
     }
     /**
      * Asynchronous close(2) - close a `FileHandle`.
      */
     async close() {
-        await this.file.close();
-        fdMap.delete(this.fd);
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'close');
+        await this.sync();
+        this.dispose();
+        deleteFD(this.context, this.fd);
+    }
+    /**
+     * Cleans up. This will *not* sync the file data to the FS
+     */
+    dispose(force) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'dispose');
+        if (this.dirty && !force)
+            throw ErrnoError.With('EBUSY', this.path, 'dispose');
+        this.closed = true;
     }
     /**
      * Asynchronous `writev`. Writes from multiple buffers.
@@ -268,7 +420,7 @@ export class FileHandle {
      */
     async writev(buffers, position) {
         if (typeof position == 'number')
-            this.file.position = position;
+            this.position = position;
         let bytesWritten = 0;
         for (const buffer of buffers) {
             bytesWritten += (await this.write(buffer)).bytesWritten;
@@ -283,7 +435,7 @@ export class FileHandle {
      */
     async readv(buffers, position) {
         if (typeof position == 'number')
-            this.file.position = position;
+            this.position = position;
         let bytesRead = 0;
         for (const buffer of buffers) {
             bytesRead += (await this.read(buffer)).bytesRead;
@@ -295,6 +447,8 @@ export class FileHandle {
      * @param options Options for the readable stream
      */
     createReadStream(options = {}) {
+        if (this.closed || this.flag & constants.O_WRONLY)
+            throw ErrnoError.With('EBADF', this.path, 'createReadStream');
         return new ReadStream(options, this);
     }
     /**
@@ -302,6 +456,10 @@ export class FileHandle {
      * @param options Options for the writeable stream.
      */
     createWriteStream(options = {}) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'createWriteStream');
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'createWriteStream');
         return new WriteStream(options, this);
     }
 }
@@ -310,7 +468,7 @@ export async function rename(oldPath, newPath) {
     newPath = normalizePath(newPath);
     const src = resolveMount(oldPath, this);
     const dst = resolveMount(newPath, this);
-    if (config.checkAccess && !(await stat.call(this, dirname(oldPath))).hasAccess(constants.W_OK, this)) {
+    if (checkAccess && !(await stat.call(this, dirname(oldPath))).hasAccess(constants.W_OK, this)) {
         throw ErrnoError.With('EACCES', oldPath, 'rename');
     }
     try {
@@ -349,10 +507,10 @@ export async function stat(path, options) {
     const { fs, path: resolved } = resolveMount(await realpath.call(this, path), this);
     try {
         const stats = await fs.stat(resolved);
-        if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
+        if (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'stat');
         }
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
+        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -364,7 +522,10 @@ export async function lstat(path, options) {
     const { fs, path: resolved } = resolveMount(path, this);
     try {
         const stats = await fs.stat(resolved);
-        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : stats;
+        if (checkAccess && !hasAccess(this, stats, constants.R_OK)) {
+            throw ErrnoError.With('EACCES', resolved, 'lstat');
+        }
+        return (options === null || options === void 0 ? void 0 : options.bigint) ? new BigIntStats(stats) : new Stats(stats);
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -393,7 +554,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
-        if (config.checkAccess && !(await fs.stat(resolved)).hasAccess(constants.W_OK, this)) {
+        if (checkAccess && !hasAccess(this, await fs.stat(resolved), constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -404,16 +565,6 @@ export async function unlink(path) {
     }
 }
 unlink;
-/**
- * Manually apply setuid/setgid.
- */
-async function applySetId(file, uid, gid) {
-    if (file.fs.attributes.has('setid'))
-        return;
-    const parent = await file.fs.stat(dirname(file.path));
-    await file.chown(parent.mode & constants.S_ISUID ? parent.uid : uid, // manually apply setuid/setgid
-    parent.mode & constants.S_ISGID ? parent.gid : gid);
-}
 /**
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
@@ -421,47 +572,48 @@ async function applySetId(file, uid, gid) {
 async function _open($, path, opt) {
     var _a;
     path = normalizePath(path);
-    const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
+    const mode = normalizeMode(opt.mode, 0o644), flag = flags.parse(opt.flag);
     const { fullPath, fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
     if (!stats) {
-        if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
+        if (!(flag & constants.O_CREAT)) {
             throw ErrnoError.With('ENOENT', fullPath, '_open');
         }
         // Create the file
         const parentStats = await fs.stat(dirname(resolved));
-        if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, $)) {
+        if (checkAccess && !hasAccess($, parentStats, constants.W_OK)) {
             throw ErrnoError.With('EACCES', dirname(fullPath), '_open');
         }
-        if (!parentStats.isDirectory()) {
+        if (!isDirectory(parentStats)) {
             throw ErrnoError.With('ENOTDIR', dirname(fullPath), '_open');
         }
-        const { euid: uid, egid: gid } = (_a = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _a !== void 0 ? _a : credentials;
-        const file = await fs.createFile(resolved, flag, mode, { uid, gid });
-        await applySetId(file, uid, gid);
-        return new FileHandle(file, $);
-    }
-    if (config.checkAccess && !stats.hasAccess(flagToMode(flag), $)) {
+        const { euid: uid, egid: gid } = (_a = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
+        const inode = await fs.createFile(resolved, {
+            mode,
+            uid: parentStats.mode & constants.S_ISUID ? parentStats.uid : uid,
+            gid: parentStats.mode & constants.S_ISGID ? parentStats.gid : gid,
+        });
+        return new FileHandle($, toFD(new SyncHandle($, path, fs, resolved, flag, inode)));
+    }
+    if (checkAccess && !hasAccess($, stats, flags.toMode(flag))) {
         throw ErrnoError.With('EACCES', fullPath, '_open');
     }
-    if (isExclusive(flag)) {
+    if (flag & constants.O_EXCL)
         throw ErrnoError.With('EEXIST', fullPath, '_open');
-    }
-    const handle = new FileHandle(await fs.openFile(resolved, flag), $);
+    const handle = new FileHandle($, toFD(new SyncHandle($, path, fs, resolved, flag, stats)));
     /*
         In a previous implementation, we deleted the file and
         re-created it. However, this created a race condition if another
         asynchronous request was trying to read the file, as the file
         would not exist for a small period of time.
     */
-    if (isTruncating(flag)) {
+    if (flag & constants.O_TRUNC)
         await handle.truncate(0);
-    }
     return handle;
 }
 /**
  * Asynchronous file open.
- * @see http://www.manpagez.com/man/2/open/
- * @param flag Handles the complexity of the various file modes. See its API for more details.
+ * @see https://nodejs.org/api/fs.html#fspromisesopenpath-flags-mode
+ * @param flag {@link https://nodejs.org/api/fs.html#file-system-flags}
  * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
 export async function open(path, flag = 'r', mode = 0o644) {
@@ -471,7 +623,7 @@ open;
 export async function readFile(path, _options) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
-        const options = normalizeOptions(_options, null, 'r', 0o644);
+        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);
         return await handle.readFile(options);
     }
@@ -501,7 +653,7 @@ export async function writeFile(path, data, _options) {
         const handle = __addDisposableResource(env_3, 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 ErrnoError(Errno.EINVAL, 'The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data, handle.file.path, 'writeFile');
+            throw new ErrnoError(Errno.EINVAL, 'The "data" argument must be of type string or an instance of Buffer, TypedArray, or DataView. Received ' + typeof data, handle.path, 'writeFile');
         }
         await handle.writeFile(_data, options);
     }
@@ -526,8 +678,8 @@ export async function appendFile(path, data, _options) {
     const env_4 = { stack: [], error: void 0, hasError: false };
     try {
         const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
-        const flag = parseFlag(options.flag);
-        if (!isAppendable(flag)) {
+        const flag = flags.parse(options.flag);
+        if (!(flag & constants.O_APPEND)) {
             throw new ErrnoError(Errno.EINVAL, 'Flag passed to appendFile must allow for appending');
         }
         if (typeof data != 'string' && !options.encoding) {
@@ -548,21 +700,17 @@ export async function appendFile(path, data, _options) {
     }
 }
 appendFile;
-// DIRECTORY-ONLY METHODS
 export async function rmdir(path) {
     path = await realpath.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     try {
         const stats = await fs.stat(resolved);
-        if (!stats) {
+        if (!stats)
             throw ErrnoError.With('ENOENT', path, 'rmdir');
-        }
-        if (!stats.isDirectory()) {
+        if (!isDirectory(stats))
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
-        }
-        if (config.checkAccess && !stats.hasAccess(constants.W_OK, this)) {
+        if (checkAccess && !hasAccess(this, stats, constants.W_OK))
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
-        }
         await fs.rmdir(resolved);
         emitChange(this, 'rename', path.toString());
     }
@@ -573,20 +721,26 @@ export async function rmdir(path) {
 rmdir;
 export async function mkdir(path, options) {
     var _a, _b;
-    const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : credentials;
+    const { euid: uid, egid: gid } = (_a = this === null || this === void 0 ? void 0 : this.credentials) !== null && _a !== void 0 ? _a : defaultContext.credentials;
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options === null || options === void 0 ? void 0 : options.mode, 0o777);
     path = await realpath.call(this, path);
     const { fs, path: resolved, root } = resolveMount(path, this);
     const errorPaths = { [resolved]: path };
+    const __create = async (path, parent) => {
+        if (checkAccess && !hasAccess(this, parent, constants.W_OK))
+            throw ErrnoError.With('EACCES', dirname(path), 'mkdir');
+        const inode = await fs.mkdir(path, {
+            mode,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        });
+        emitChange(this, 'rename', path);
+        return inode;
+    };
     try {
         if (!(options === null || options === void 0 ? void 0 : options.recursive)) {
-            if (config.checkAccess && !(await fs.stat(dirname(resolved))).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(resolved), 'mkdir');
-            }
-            await fs.mkdir(resolved, mode, { uid, gid });
-            await applySetId(await fs.openFile(resolved, 'r+'), uid, gid);
-            emitChange(this, 'rename', path.toString());
+            await __create(resolved, await fs.stat(dirname(resolved)));
             return;
         }
         const dirs = [];
@@ -594,13 +748,11 @@ export async function mkdir(path, options) {
             dirs.unshift(dir);
             errorPaths[dir] = origDir;
         }
-        for (const dir of dirs) {
-            if (config.checkAccess && !(await fs.stat(dirname(dir))).hasAccess(constants.W_OK, this)) {
-                throw ErrnoError.With('EACCES', dirname(dir), 'mkdir');
-            }
-            await fs.mkdir(dir, mode, { uid, gid });
-            await applySetId(await fs.openFile(dir, 'r+'), uid, gid);
-            emitChange(this, 'rename', dir);
+        if (!dirs.length)
+            return;
+        const stats = [await fs.stat(dirname(dirs[0]))];
+        for (const [i, dir] of dirs.entries()) {
+            stats.push(await __create(dir, stats[i]));
         }
         return root.length == 1 ? dirs[0] : (_b = dirs[0]) === null || _b === void 0 ? void 0 : _b.slice(root.length);
     }
@@ -617,12 +769,10 @@ export async function readdir(path, options) {
     if (!stats) {
         throw ErrnoError.With('ENOENT', path, 'readdir');
     }
-    if (config.checkAccess && !stats.hasAccess(constants.R_OK, this)) {
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
         throw ErrnoError.With('EACCES', path, 'readdir');
-    }
-    if (!stats.isDirectory()) {
+    if (!isDirectory(stats))
         throw ErrnoError.With('ENOTDIR', path, 'readdir');
-    }
     const entries = await fs.readdir(resolved).catch((e) => _throw(fixError(e, { [resolved]: path })));
     const values = [];
     const addEntry = async (entry) => {
@@ -645,7 +795,7 @@ export async function readdir(path, options) {
         else {
             values.push(entry);
         }
-        if (!(options === null || options === void 0 ? void 0 : options.recursive) || !(entryStats === null || entryStats === void 0 ? void 0 : entryStats.isDirectory()))
+        if (!(options === null || options === void 0 ? void 0 : options.recursive) || !isDirectory(entryStats))
             return;
         for (const subEntry of await readdir.call(this, join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
@@ -674,13 +824,14 @@ export async function link(targetPath, linkPath) {
         throw ErrnoError.With('EXDEV', linkPath, 'link');
     }
     try {
-        if (config.checkAccess && !(await fs.stat(dirname(targetPath))).hasAccess(constants.R_OK, this)) {
+        if (checkAccess && !hasAccess(this, await fs.stat(dirname(path)), constants.R_OK)) {
             throw ErrnoError.With('EACCES', dirname(path), 'link');
         }
-        if (config.checkAccess && !(await stat.call(this, dirname(linkPath))).hasAccess(constants.W_OK, this)) {
+        // We need to use the VFS here since the link path may be a mount point
+        if (checkAccess && !(await stat.call(this, dirname(linkPath))).hasAccess(constants.W_OK, this)) {
             throw ErrnoError.With('EACCES', dirname(linkPath), 'link');
         }
-        if (config.checkAccess && !(await fs.stat(path)).hasAccess(constants.R_OK, this)) {
+        if (checkAccess && !hasAccess(this, await fs.stat(path), constants.R_OK)) {
             throw ErrnoError.With('EACCES', path, 'link');
         }
         return await fs.link(path, link.path);
@@ -707,7 +858,7 @@ export async function symlink(target, path, type = 'file') {
             throw ErrnoError.With('EEXIST', path, 'symlink');
         const handle = __addDisposableResource(env_5, await _open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
         await handle.writeFile(normalizePath(target, true));
-        await handle.file.chmod(constants.S_IFLNK);
+        await handle.chmod(constants.S_IFLNK);
     }
     catch (e_5) {
         env_5.error = e_5;
@@ -880,10 +1031,10 @@ async function _resolve($, path, preserveSymlinks) {
         const resolved = resolveMount(path, $);
         // Stat it to make sure it exists
         const stats = await resolved.fs.stat(resolved.path);
-        if (!stats.isSymbolicLink()) {
+        if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: path, stats };
         }
-        const target = resolve(dirname(path), (await readlink.call($, path)).toString());
+        const target = resolve.call($, dirname(path), (await readlink.call($, path)).toString());
         return await _resolve($, target);
     }
     catch {
@@ -895,10 +1046,10 @@ async function _resolve($, path, preserveSymlinks) {
     const resolved = resolveMount(maybePath, $);
     try {
         const stats = await resolved.fs.stat(resolved.path);
-        if (!stats.isSymbolicLink()) {
+        if (!isSymbolicLink(stats)) {
             return { ...resolved, fullPath: maybePath, stats };
         }
-        const target = resolve(realDir, (await readlink.call($, maybePath)).toString());
+        const target = resolve.call($, realDir, (await readlink.call($, maybePath)).toString());
         return await _resolve($, target);
     }
     catch (e) {
@@ -959,7 +1110,7 @@ export function watch(filename, options = {}) {
 }
 watch;
 export async function access(path, mode = constants.F_OK) {
-    if (!config.checkAccess)
+    if (!checkAccess)
         return;
     const stats = await stat.call(this, path);
     if (!stats.hasAccess(mode, this)) {