@zenfs/core 0.0.12 → 0.2.0

package/dist/emulation/promises.js

@@ -1,18 +1,154 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { ApiError, ErrorCode } from '../ApiError.js';
-import * as constants from './constants.js';
-export { constants };
-import { FileFlag } from '../file.js';
+export * as constants from './constants.js';
+import { ActionType, FileFlag } from '../file.js';
 import { normalizePath, normalizeMode, getFdForFile, normalizeOptions, fd2file, fdMap, normalizeTime, cred, nop, resolveFS, fixError, mounts } from './shared.js';
+import { BigIntStats, FileType } from '../stats.js';
 import { decode, encode } from '../utils.js';
+import { Dirent } from './dir.js';
+import { dirname, join } from './path.js';
+export class FileHandle {
+    constructor(
+    /**
+     * Gets the file descriptor for this file handle.
+     */
+    fd) {
+        this.fd = fd;
+    }
+    /**
+     * Asynchronous fchown(2) - Change ownership of a file.
+     */
+    chown(uid, gid) {
+        return fd2file(this.fd).chown(uid, gid);
+    }
+    /**
+     * Asynchronous fchmod(2) - Change permissions of a file.
+     * @param mode A file mode. If a string is passed, it is parsed as an octal integer.
+     */
+    chmod(mode) {
+        const numMode = normalizeMode(mode, -1);
+        if (numMode < 0) {
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid mode.');
+        }
+        return fd2file(this.fd).chmod(numMode);
+    }
+    /**
+     * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
+     */
+    datasync() {
+        return fd2file(this.fd).datasync();
+    }
+    /**
+     * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
+     */
+    sync() {
+        return fd2file(this.fd).sync();
+    }
+    /**
+     * Asynchronous ftruncate(2) - Truncate a file to a specified length.
+     * @param len If not specified, defaults to `0`.
+     */
+    truncate(len) {
+        if (len < 0) {
+            throw new ApiError(ErrorCode.EINVAL);
+        }
+        return fd2file(this.fd).truncate(len);
+    }
+    /**
+     * Asynchronously change file timestamps of the file.
+     * @param atime The last access time. If a string is provided, it will be coerced to number.
+     * @param mtime The last modified time. If a string is provided, it will be coerced to number.
+     */
+    utimes(atime, mtime) {
+        return fd2file(this.fd).utimes(normalizeTime(atime), normalizeTime(mtime));
+    }
+    /**
+     * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
+     * The `FileHandle` must have been opened for appending.
+     * @param data The data to write. If something other than a `Buffer` or `Uint8Array` is provided, the value is coerced to a string.
+     * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
+     * If `encoding` is not supplied, the default of `'utf8'` is used.
+     * If `mode` is not supplied, the default of `0o666` is used.
+     * If `mode` is a string, it is parsed as an octal integer.
+     * If `flag` is not supplied, the default of `'a'` is used.
+     */
+    appendFile(data, options) {
+        return appendFile(fd2file(this.fd).path, data, options);
+    }
+    /**
+     * Asynchronously reads data from the file.
+     * The `FileHandle` must have been opened for reading.
+     * @param buffer The buffer that the data will be written to.
+     * @param offset The offset in the buffer at which to start writing.
+     * @param length The number of bytes to read.
+     * @param position The offset from the beginning of the file from which data should be read. If `null`, data will be read from the current position.
+     */
+    read(buffer, offset, length, position) {
+        if (isNaN(+position)) {
+            position = fd2file(this.fd).position;
+        }
+        return fd2file(this.fd).read(buffer, offset, length, position);
+    }
+    readFile(options) {
+        return readFile(fd2file(this.fd).path, options);
+    }
+    stat(opts) {
+        return stat(fd2file(this.fd).path, opts);
+    }
+    async write(data, posOrOff, lenOrEnc, position) {
+        let buffer, offset = 0, length;
+        if (typeof data === 'string') {
+            // Signature 1: (fd, string, [position?, [encoding?]])
+            position = typeof posOrOff === 'number' ? posOrOff : null;
+            const encoding = (typeof lenOrEnc === 'string' ? lenOrEnc : 'utf8');
+            offset = 0;
+            buffer = encode(data, encoding);
+            length = buffer.length;
+        }
+        else {
+            // Signature 2: (fd, buffer, offset, length, position?)
+            buffer = data;
+            offset = posOrOff;
+            length = lenOrEnc;
+            position = typeof position === 'number' ? position : null;
+        }
+        position ?? (position = fd2file(this.fd).position);
+        const bytesWritten = await fd2file(this.fd).write(buffer, offset, length, position);
+        return { buffer, bytesWritten };
+    }
+    /**
+     * Asynchronously writes data to a file, replacing the file if it already exists. The underlying file will _not_ be closed automatically.
+     * The `FileHandle` must have been opened for writing.
+     * It is unsafe to call `writeFile()` multiple times on the same file without waiting for the `Promise` to be resolved (or rejected).
+     * @param data The data to write. If something other than a `Buffer` or `Uint8Array` is provided, the value is coerced to a string.
+     * @param options Either the encoding for the file, or an object optionally specifying the encoding, file mode, and flag.
+     * If `encoding` is not supplied, the default of `'utf8'` is used.
+     * If `mode` is not supplied, the default of `0o666` is used.
+     * If `mode` is a string, it is parsed as an octal integer.
+     * If `flag` is not supplied, the default of `'w'` is used.
+     */
+    writeFile(data, options) {
+        return writeFile(fd2file(this.fd).path, data, options);
+    }
+    /**
+     * See `fs.writev` promisified version.
+     */
+    writev(buffers, position) {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+    /**
+     * See `fs.readv` promisified version.
+     */
+    readv(buffers, position) {
+        throw new ApiError(ErrorCode.ENOTSUP);
+    }
+    /**
+     * Asynchronous close(2) - close a `FileHandle`.
+     */
+    async close() {
+        await fd2file(this.fd).close();
+        fdMap.delete(this.fd);
+    }
+}
 /**
  * Utility for FS ops. It handles
  * - path normalization (for the first parameter to the FS op)
@@ -25,18 +161,16 @@ import { decode, encode } from '../utils.js';
  * @param args the rest of the parameters are passed to the FS function. Note that the first parameter is required to be a path
  * @returns
  */
-function doOp(...[name, resolveSymlinks, path, ...args]) {
-    return __awaiter(this, void 0, void 0, function* () {
-        path = normalizePath(path);
-        const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && (yield exists(path)) ? yield realpath(path) : path);
-        try {
-            // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
-            return fs[name](resolvedPath, ...args);
-        }
-        catch (e) {
-            throw fixError(e, { [resolvedPath]: path });
-        }
-    });
+async function doOp(...[name, resolveSymlinks, rawPath, ...args]) {
+    rawPath = normalizePath(rawPath);
+    const { fs, path } = resolveFS(resolveSymlinks && (await exists(rawPath)) ? await realpath(rawPath) : rawPath);
+    try {
+        // @ts-expect-error 2556 (since ...args is not correctly picked up as being a tuple)
+        return fs[name](path, ...args);
+    }
+    catch (e) {
+        throw fixError(e, { [path]: rawPath });
+    }
 }
 // fs.promises
 /**
@@ -44,232 +178,245 @@ function doOp(...[name, resolveSymlinks, path, ...args]) {
  * @param oldPath
  * @param newPath
  */
-export function rename(oldPath, newPath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        oldPath = normalizePath(oldPath);
-        newPath = normalizePath(newPath);
-        const _old = resolveFS(oldPath);
-        const _new = resolveFS(newPath);
-        const paths = { [_old.path]: oldPath, [_new.path]: newPath };
-        try {
-            if (_old === _new) {
-                return _old.fs.rename(_old.path, _new.path, cred);
-            }
-            const data = yield readFile(oldPath);
-            yield writeFile(newPath, data);
-            yield unlink(oldPath);
-        }
-        catch (e) {
-            throw fixError(e, paths);
-        }
-    });
-}
+export async function rename(oldPath, newPath) {
+    oldPath = normalizePath(oldPath);
+    newPath = normalizePath(newPath);
+    const { path: old } = resolveFS(oldPath);
+    const { fs, path } = resolveFS(newPath);
+    try {
+        const data = await readFile(oldPath);
+        await writeFile(newPath, data);
+        await unlink(oldPath);
+    }
+    catch (e) {
+        throw fixError(e, { [old]: oldPath, [path]: newPath });
+    }
+}
+rename;
 /**
  * Test whether or not the given path exists by checking with the file system.
- * @param path
+ * @param _path
  */
-export function exists(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        path = normalizePath(path);
-        try {
-            const { fs, path: resolvedPath } = resolveFS(path);
-            return fs.exists(resolvedPath, cred);
-        }
-        catch (e) {
-            if (e.errno == ErrorCode.ENOENT) {
-                return false;
-            }
-            throw e;
+export async function exists(_path) {
+    try {
+        const { fs, path } = resolveFS(_path);
+        return fs.exists(path, cred);
+    }
+    catch (e) {
+        if (e.errno == ErrorCode.ENOENT) {
+            return false;
         }
-    });
+        throw e;
+    }
 }
-/**
- * `stat`.
- * @param path
- * @returns Stats
- */
-export function stat(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('stat', true, path, cred);
-    });
+export async function stat(path, options) {
+    const stats = await doOp('stat', true, path, cred);
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
-/**
- * `lstat`.
- * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
- * then the link itself is stat-ed, not the file that it refers to.
- * @param path
- * @return [ZenFS.node.fs.Stats]
- */
-export function lstat(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('stat', false, path, cred);
-    });
+stat;
+export async function lstat(path, options) {
+    const stats = await doOp('stat', false, path, cred);
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
+lstat;
 // FILE-ONLY METHODS
 /**
  * `truncate`.
  * @param path
  * @param len
  */
-export function truncate(path, len = 0) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (len < 0) {
-            throw new ApiError(ErrorCode.EINVAL);
-        }
-        return doOp('truncate', true, path, len, cred);
-    });
-}
+export async function truncate(path, len = 0) {
+    const handle = await open(path, 'r+');
+    try {
+        await handle.truncate(len);
+    }
+    finally {
+        await handle.close();
+    }
+}
+truncate;
 /**
  * `unlink`.
  * @param path
  */
-export function unlink(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('unlink', false, path, cred);
-    });
+export async function unlink(path) {
+    return doOp('unlink', false, path, cred);
 }
+unlink;
 /**
- * file open.
- * @see http://www.manpagez.com/man/2/open/
- * @param path
- * @param flags
- * @param mode defaults to `0644`
+ * Opens a file. This helper handles the complexity of file flags.
+ * @internal
  */
-export function open(path, flag, mode = 0o644) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const file = yield doOp('open', true, path, FileFlag.getFileFlag(flag), normalizeMode(mode, 0o644), cred);
-        return getFdForFile(file);
-    });
-}
-export function readFile(filename, arg2 = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const options = normalizeOptions(arg2, null, 'r', null);
-        const flag = FileFlag.getFileFlag(options.flag);
-        if (!flag.isReadable()) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to readFile must allow for reading.');
-        }
-        const data = yield doOp('readFile', true, filename, flag, cred);
-        switch (options.encoding) {
-            case 'utf8':
-            case 'utf-8':
-                return decode(data);
+async function _open(_path, _flag, _mode = 0o644, resolveSymlinks) {
+    const path = normalizePath(_path), mode = normalizeMode(_mode, 0o644), flag = FileFlag.FromString(_flag);
+    try {
+        switch (flag.pathExistsAction()) {
+            case ActionType.THROW:
+                throw ApiError.EEXIST(path);
+            case ActionType.TRUNCATE:
+                /*
+                    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.
+                */
+                const file = await doOp('openFile', resolveSymlinks, path, flag, cred);
+                if (!file) {
+                    throw new ApiError(ErrorCode.EIO, 'Impossible code path reached');
+                }
+                await file.truncate(0);
+                await file.sync();
+                return file;
+            case ActionType.NOP:
+                // Must await so thrown errors are caught by the catch below
+                return await doOp('openFile', resolveSymlinks, path, flag, cred);
             default:
-                return data;
+                throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
         }
-    });
-}
-export function writeFile(filename, data, arg3) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const options = normalizeOptions(arg3, 'utf8', 'w', 0o644);
-        const flag = FileFlag.getFileFlag(options.flag);
-        if (!flag.isWriteable()) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to writeFile must allow for writing.');
-        }
-        if (typeof data != 'string' && !options.encoding) {
-            throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
-        }
-        const encodedData = typeof data == 'string' ? encode(data) : data;
-        return doOp('writeFile', true, filename, encodedData, flag, options.mode, cred);
-    });
-}
-export function appendFile(filename, data, arg3) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
-        const flag = FileFlag.getFileFlag(options.flag);
-        if (!flag.isAppendable()) {
-            throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
-        }
-        if (typeof data != 'string' && !options.encoding) {
-            throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+    }
+    catch (e) {
+        switch (flag.pathNotExistsAction()) {
+            case ActionType.CREATE:
+                // Ensure parent exists.
+                const parentStats = await doOp('stat', resolveSymlinks, dirname(path), cred);
+                if (parentStats && !parentStats.isDirectory()) {
+                    throw ApiError.ENOTDIR(dirname(path));
+                }
+                return await doOp('createFile', resolveSymlinks, path, flag, mode, cred);
+            case ActionType.THROW:
+                throw ApiError.ENOENT(path);
+            default:
+                throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
         }
-        const encodedData = typeof data == 'string' ? encode(data) : data;
-        return doOp('appendFile', true, filename, encodedData, flag, options.mode, cred);
-    });
+    }
 }
-// FILE DESCRIPTOR METHODS
 /**
- * `fstat`.
- * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
- * specified by the file descriptor `fd`.
- * @param fd
- * @return [ZenFS.node.fs.Stats]
+ * Asynchronous file open.
+ * @see http://www.manpagez.com/man/2/open/
+ * @param flags Handles the complexity of the various file modes. See its API for more details.
+ * @param mode Mode to use to open the file. Can be ignored if the filesystem doesn't support permissions.
  */
-export function fstat(fd) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fd2file(fd).stat();
-    });
+export async function open(path, flag, mode = 0o644) {
+    const file = await _open(path, flag, mode, true);
+    return new FileHandle(getFdForFile(file));
 }
+open;
 /**
- * close.
- * @param fd
+ * Opens a file without resolving symlinks
+ * @internal
  */
-export function close(fd) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield fd2file(fd).close();
-        fdMap.delete(fd);
-        return;
-    });
+export async function lopen(path, flag, mode = 0o644) {
+    const file = await _open(path, flag, mode, false);
+    return new FileHandle(getFdForFile(file));
 }
 /**
- * ftruncate.
- * @param fd
- * @param len
+ * Asynchronously reads the entire contents of a file.
  */
-export function ftruncate(fd, len = 0) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const file = fd2file(fd);
-        if (len < 0) {
-            throw new ApiError(ErrorCode.EINVAL);
-        }
-        return file.truncate(len);
-    });
-}
+async function _readFile(fname, flag, resolveSymlinks) {
+    const file = await _open(normalizePath(fname), flag, 0o644, resolveSymlinks);
+    try {
+        const stat = await file.stat();
+        const data = new Uint8Array(stat.size);
+        await file.read(data, 0, stat.size, 0);
+        await file.close();
+        return data;
+    }
+    finally {
+        await file.close();
+    }
+}
+export async function readFile(filename, _options) {
+    const options = normalizeOptions(_options, null, 'r', null);
+    const flag = FileFlag.FromString(options.flag);
+    if (!flag.isReadable()) {
+        throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for reading.');
+    }
+    const data = await _readFile(filename, options.flag, true);
+    return options.encoding ? decode(data, options.encoding) : data;
+}
+readFile;
 /**
- * fsync.
- * @param fd
+ * Asynchronously writes data to a file, replacing the file
+ * if it already exists.
+ *
+ * The encoding option is ignored if data is a buffer.
  */
-export function fsync(fd) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fd2file(fd).sync();
-    });
+async function _writeFile(fname, data, flag, mode, resolveSymlinks) {
+    const file = await _open(fname, flag, mode, resolveSymlinks);
+    try {
+        await file.write(data, 0, data.length, 0);
+    }
+    finally {
+        await file.close();
+    }
 }
 /**
- * fdatasync.
- * @param fd
+ * Synchronously writes data to a file, replacing the file if it already exists.
+ *
+ * The encoding option is ignored if data is a buffer.
+ * @param filename
+ * @param data
+ * @param _options
+ * @option options encoding Defaults to `'utf8'`.
+ * @option options mode Defaults to `0644`.
+ * @option options flag Defaults to `'w'`.
+ */
+export async function writeFile(filename, data, _options) {
+    const options = normalizeOptions(_options, 'utf8', 'w', 0o644);
+    const flag = FileFlag.FromString(options.flag);
+    if (!flag.isWriteable()) {
+        throw new ApiError(ErrorCode.EINVAL, 'Flag passed must allow for writing.');
+    }
+    if (typeof data != 'string' && !options.encoding) {
+        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+    }
+    const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
+    await _writeFile(filename, encodedData, options.flag, options.mode, true);
+}
+writeFile;
+/**
+ * Asynchronously append data to a file, creating the file if
+ * it not yet exists.
  */
-export function fdatasync(fd) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fd2file(fd).datasync();
-    });
-}
-export function write(fd, arg2, arg3, arg4, arg5) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let buffer, offset = 0, length, position;
-        if (typeof arg2 === 'string') {
-            // Signature 1: (fd, string, [position?, [encoding?]])
-            position = typeof arg3 === 'number' ? arg3 : null;
-            const encoding = (typeof arg4 === 'string' ? arg4 : 'utf8');
-            offset = 0;
-            buffer = encode(arg2);
-            length = buffer.length;
-        }
-        else {
-            // Signature 2: (fd, buffer, offset, length, position?)
-            buffer = arg2;
-            offset = arg3;
-            length = arg4;
-            position = typeof arg5 === 'number' ? arg5 : null;
-        }
-        const file = fd2file(fd);
-        if (position === undefined || position === null) {
-            position = file.getPos();
-        }
-        return file.write(buffer, offset, length, position);
-    });
+async function _appendFile(fname, data, flag, mode, resolveSymlinks) {
+    const file = await _open(fname, flag, mode, resolveSymlinks);
+    try {
+        await file.write(data, 0, data.length, null);
+    }
+    finally {
+        await file.close();
+    }
 }
+/**
+ * Asynchronously append data to a file, creating the file if it not yet
+ * exists.
+ * @param filename
+ * @param data
+ * @param options
+ * @option options encoding Defaults to `'utf8'`.
+ * @option options mode Defaults to `0644`.
+ * @option options flag Defaults to `'a'`.
+ */
+export async function appendFile(filename, data, _options) {
+    const options = normalizeOptions(_options, 'utf8', 'a', 0o644);
+    const flag = FileFlag.FromString(options.flag);
+    if (!flag.isAppendable()) {
+        throw new ApiError(ErrorCode.EINVAL, 'Flag passed to appendFile must allow for appending.');
+    }
+    if (typeof data != 'string' && !options.encoding) {
+        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+    }
+    const encodedData = typeof data == 'string' ? encode(data) : data;
+    await _appendFile(filename, encodedData, options.flag, options.mode, true);
+}
+appendFile;
+export function write(handle, data, posOrOff, lenOrEnc, position) {
+    return handle.write(data, posOrOff, lenOrEnc, position);
+}
+write;
 /**
  * Read data from the file specified by `fd`.
- * @param fd
+ * @param handle
  * @param buffer The buffer that the data will be
  *   written to.
  * @param offset The offset within the buffer where writing will
@@ -279,129 +426,112 @@ export function write(fd, arg2, arg3, arg4, arg5) {
  *   in the file. If position is null, data will be read from the current file
  *   position.
  */
-export function read(fd, buffer, offset, length, position) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const file = fd2file(fd);
-        if (isNaN(+position)) {
-            position = file.getPos();
-        }
-        return file.read(buffer, offset, length, position);
-    });
+export function read(handle, buffer, offset, length, position) {
+    return handle.read(buffer, offset, length, position);
 }
+read;
 /**
  * `fchown`.
- * @param fd
+ * @param handle
  * @param uid
  * @param gid
  */
-export function fchown(fd, uid, gid) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fd2file(fd).chown(uid, gid);
-    });
+export function fchown(handle, uid, gid) {
+    return handle.chown(uid, gid);
 }
+fchown;
 /**
  * `fchmod`.
- * @param fd
+ * @param handle
  * @param mode
  */
-export function fchmod(fd, mode) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const numMode = typeof mode === 'string' ? parseInt(mode, 8) : mode;
-        return fd2file(fd).chmod(numMode);
-    });
+export function fchmod(handle, mode) {
+    return handle.chmod(mode);
 }
+fchmod;
 /**
  * Change the file timestamps of a file referenced by the supplied file
  * descriptor.
- * @param fd
+ * @param handle
  * @param atime
  * @param mtime
  */
-export function futimes(fd, atime, mtime) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fd2file(fd).utimes(normalizeTime(atime), normalizeTime(mtime));
-    });
+export function futimes(handle, atime, mtime) {
+    return handle.utimes(atime, mtime);
 }
+futimes;
 // DIRECTORY-ONLY METHODS
 /**
  * `rmdir`.
  * @param path
  */
-export function rmdir(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('rmdir', true, path, cred);
-    });
-}
-/**
- * `mkdir`.
- * @param path
- * @param mode defaults to `0777`
- */
-export function mkdir(path, mode) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('mkdir', true, path, normalizeMode(mode, 0o777), cred);
-    });
-}
-/**
- * `readdir`. Reads the contents of a directory.
- * @param path
- * @return [String[]]
- */
-export function readdir(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        path = normalizePath(path);
-        const entries = yield doOp('readdir', true, path, cred);
-        const points = [...mounts.keys()];
-        for (const point of points) {
-            if (point.startsWith(path)) {
-                const entry = point.slice(path.length);
-                if (entry.includes('/') || entry.length == 0) {
-                    // ignore FSs mounted in subdirectories and any FS mounted to `path`.
-                    continue;
-                }
-                entries.push(entry);
+export async function rmdir(path) {
+    return doOp('rmdir', true, path, cred);
+}
+rmdir;
+export async function mkdir(path, mode) {
+    await doOp('mkdir', true, path, normalizeMode(typeof mode == 'object' ? mode?.mode : mode, 0o777), cred);
+}
+mkdir;
+export async function readdir(path, options) {
+    path = normalizePath(path);
+    const entries = await doOp('readdir', true, path, cred);
+    const points = [...mounts.keys()];
+    for (const point of points) {
+        if (point.startsWith(path)) {
+            const entry = point.slice(path.length);
+            if (entry.includes('/') || entry.length == 0) {
+                // ignore FSs mounted in subdirectories and any FS mounted to `path`.
+                continue;
             }
+            entries.push(entry);
         }
-        return entries;
-    });
-}
+    }
+    const values = [];
+    for (const entry of entries) {
+        values.push(typeof options == 'object' && options?.withFileTypes ? new Dirent(entry, await stat(join(path, entry))) : entry);
+    }
+    return values;
+}
+readdir;
 // SYMLINK METHODS
 /**
  * `link`.
- * @param srcpath
- * @param dstpath
+ * @param existing
+ * @param newpath
  */
-export function link(srcpath, dstpath) {
-    return __awaiter(this, void 0, void 0, function* () {
-        dstpath = normalizePath(dstpath);
-        return doOp('link', false, srcpath, dstpath, cred);
-    });
+export async function link(existing, newpath) {
+    newpath = normalizePath(newpath);
+    return doOp('link', false, existing, newpath, cred);
 }
+link;
 /**
  * `symlink`.
- * @param srcpath
- * @param dstpath
+ * @param target target path
+ * @param path link path
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
-export function symlink(srcpath, dstpath, type = 'file') {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (!['file', 'dir', 'junction'].includes(type)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
-        }
-        dstpath = normalizePath(dstpath);
-        return doOp('symlink', false, srcpath, dstpath, type, cred);
-    });
-}
-/**
- * readlink.
- * @param path
- * @return [String]
- */
-export function readlink(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('readlink', false, path, cred);
-    });
-}
+export async function symlink(target, path, type = 'file') {
+    if (!['file', 'dir', 'junction'].includes(type)) {
+        throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
+    }
+    if (await exists(path)) {
+        throw ApiError.EEXIST(path);
+    }
+    await writeFile(path, target);
+    const file = await _open(path, 'r+', 0o644, false);
+    await file._setType(FileType.SYMLINK);
+}
+symlink;
+export async function readlink(path, options) {
+    const value = await _readFile(path, 'r', false);
+    const encoding = typeof options == 'object' ? options.encoding : options;
+    if (encoding == 'buffer') {
+        return value;
+    }
+    return decode(value, encoding);
+}
+readlink;
 // PROPERTY OPERATIONS
 /**
  * `chown`.
@@ -409,129 +539,142 @@ export function readlink(path) {
  * @param uid
  * @param gid
  */
-export function chown(path, uid, gid) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('chown', true, path, uid, gid, cred);
-    });
-}
+export async function chown(path, uid, gid) {
+    const handle = await open(path, 'r+');
+    try {
+        await handle.chown(uid, gid);
+    }
+    finally {
+        await handle.close();
+    }
+}
+chown;
 /**
  * `lchown`.
  * @param path
  * @param uid
  * @param gid
  */
-export function lchown(path, uid, gid) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('chown', false, path, uid, gid, cred);
-    });
-}
+export async function lchown(path, uid, gid) {
+    const handle = await lopen(path, 'r+');
+    try {
+        await handle.chown(uid, gid);
+    }
+    finally {
+        await handle.close();
+    }
+}
+lchown;
 /**
  * `chmod`.
  * @param path
  * @param mode
  */
-export function chmod(path, mode) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const numMode = normalizeMode(mode, -1);
-        if (numMode < 0) {
-            throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
-        }
-        return doOp('chmod', true, path, numMode, cred);
-    });
-}
+export async function chmod(path, mode) {
+    const handle = await open(path, 'r+');
+    try {
+        await handle.chmod(mode);
+    }
+    finally {
+        await handle.close();
+    }
+}
+chmod;
 /**
  * `lchmod`.
  * @param path
  * @param mode
  */
-export function lchmod(path, mode) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const numMode = normalizeMode(mode, -1);
-        if (numMode < 1) {
-            throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
-        }
-        return doOp('chmod', false, normalizePath(path), numMode, cred);
-    });
-}
+export async function lchmod(path, mode) {
+    const handle = await lopen(path, 'r+');
+    try {
+        await handle.chmod(mode);
+    }
+    finally {
+        await handle.close();
+    }
+}
+lchmod;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
  * @param atime
  * @param mtime
  */
-export function utimes(path, atime, mtime) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('utimes', true, path, normalizeTime(atime), normalizeTime(mtime), cred);
-    });
-}
+export async function utimes(path, atime, mtime) {
+    const handle = await open(path, 'r+');
+    try {
+        await handle.utimes(atime, mtime);
+    }
+    finally {
+        await handle.close();
+    }
+}
+utimes;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
  * @param atime
  * @param mtime
  */
-export function lutimes(path, atime, mtime) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('utimes', false, path, normalizeTime(atime), normalizeTime(mtime), cred);
-    });
-}
-/**
- * `realpath`.
- * @param path
- * @param cache An object literal of mapped paths that can be used to
- *   force a specific path resolution or avoid additional `fs.stat` calls for
- *   known real paths.
- * @return [String]
- */
-export function realpath(path, cache = {}) {
-    return __awaiter(this, void 0, void 0, function* () {
-        path = normalizePath(path);
-        const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
-        try {
-            const stats = yield fs.stat(resolvedPath, cred);
-            if (!stats.isSymbolicLink()) {
-                return path;
-            }
-            const dst = mountPoint + normalizePath(yield fs.readlink(resolvedPath, cred));
-            return realpath(dst);
+export async function lutimes(path, atime, mtime) {
+    const handle = await lopen(path, 'r+');
+    try {
+        await handle.utimes(atime, mtime);
+    }
+    finally {
+        await handle.close();
+    }
+}
+lutimes;
+export async function realpath(path, options) {
+    path = normalizePath(path);
+    const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
+    try {
+        const stats = await fs.stat(resolvedPath, cred);
+        if (!stats.isSymbolicLink()) {
+            return path;
         }
-        catch (e) {
-            throw fixError(e, { [resolvedPath]: path });
-        }
-    });
+        const dst = mountPoint + normalizePath(decode(await _readFile(resolvedPath, 'r+', false)));
+        return realpath(dst);
+    }
+    catch (e) {
+        throw fixError(e, { [resolvedPath]: path });
+    }
 }
-export function watchFile(filename, arg2, listener = nop) {
-    return __awaiter(this, void 0, void 0, function* () {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    });
+realpath;
+export async function watchFile(filename, arg2, listener = nop) {
+    throw new ApiError(ErrorCode.ENOTSUP);
 }
-export function unwatchFile(filename, listener = nop) {
-    return __awaiter(this, void 0, void 0, function* () {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    });
+export async function unwatchFile(filename, listener = nop) {
+    throw new ApiError(ErrorCode.ENOTSUP);
 }
-export function watch(filename, arg2, listener = nop) {
-    return __awaiter(this, void 0, void 0, function* () {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    });
+export async function watch(filename, arg2, listener = nop) {
+    throw new ApiError(ErrorCode.ENOTSUP);
 }
 /**
  * `access`.
  * @param path
  * @param mode
  */
-export function access(path, mode = 0o600) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return doOp('access', true, path, mode, cred);
-    });
+export async function access(path, mode = 0o600) {
+    const stats = await stat(path);
+    if (!stats.hasAccess(mode, cred)) {
+        throw new ApiError(ErrorCode.EACCES);
+    }
 }
-export function createReadStream(path, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    });
+export async function createReadStream(path, options) {
+    throw new ApiError(ErrorCode.ENOTSUP);
 }
-export function createWriteStream(path, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        throw new ApiError(ErrorCode.ENOTSUP);
-    });
+export async function createWriteStream(path, options) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+export async function rm(path) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+export async function mkdtemp(path) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+export async function copyFile(path) {
+    throw new ApiError(ErrorCode.ENOTSUP);
 }