@zenfs/core 0.1.0 → 0.2.0

package/dist/emulation/promises.js

@@ -1,12 +1,154 @@
 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 } from '../stats.js';
+import { BigIntStats, FileType } from '../stats.js';
 import { decode, encode } from '../utils.js';
 import { Dirent } from './dir.js';
-import { join } from './path.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)
@@ -19,15 +161,15 @@ import { join } from './path.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
  */
-async function doOp(...[name, resolveSymlinks, path, ...args]) {
-    path = normalizePath(path);
-    const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && (await exists(path)) ? await realpath(path) : 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](resolvedPath, ...args);
+        return fs[name](path, ...args);
     }
     catch (e) {
-        throw fixError(e, { [resolvedPath]: path });
+        throw fixError(e, { [path]: rawPath });
     }
 }
 // fs.promises
@@ -39,30 +181,26 @@ async function doOp(...[name, resolveSymlinks, path, ...args]) {
 export async function rename(oldPath, newPath) {
     oldPath = normalizePath(oldPath);
     newPath = normalizePath(newPath);
-    const _old = resolveFS(oldPath);
-    const _new = resolveFS(newPath);
-    const paths = { [_old.path]: oldPath, [_new.path]: newPath };
+    const { path: old } = resolveFS(oldPath);
+    const { fs, path } = resolveFS(newPath);
     try {
-        if (_old === _new) {
-            return _old.fs.rename(_old.path, _new.path, cred);
-        }
         const data = await readFile(oldPath);
         await writeFile(newPath, data);
         await unlink(oldPath);
     }
     catch (e) {
-        throw fixError(e, paths);
+        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 async function exists(path) {
-    path = normalizePath(path);
+export async function exists(_path) {
     try {
-        const { fs, path: resolvedPath } = resolveFS(path);
-        return fs.exists(resolvedPath, cred);
+        const { fs, path } = resolveFS(_path);
+        return fs.exists(path, cred);
     }
     catch (e) {
         if (e.errno == ErrorCode.ENOENT) {
@@ -75,10 +213,12 @@ export async function stat(path, options) {
     const stats = await doOp('stat', true, path, cred);
     return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
+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`.
@@ -86,11 +226,15 @@ export async function lstat(path, options) {
  * @param len
  */
 export async function truncate(path, len = 0) {
-    if (len < 0) {
-        throw new ApiError(ErrorCode.EINVAL);
+    const handle = await open(path, 'r+');
+    try {
+        await handle.truncate(len);
+    }
+    finally {
+        await handle.close();
     }
-    return doOp('truncate', true, path, len, cred);
 }
+truncate;
 /**
  * `unlink`.
  * @param path
@@ -98,121 +242,181 @@ export async function truncate(path, len = 0) {
 export async function unlink(path) {
     return doOp('unlink', false, path, cred);
 }
+unlink;
+/**
+ * Opens a file. This helper handles the complexity of file flags.
+ * @internal
+ */
+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:
+                throw new ApiError(ErrorCode.EINVAL, 'Invalid file flag');
+        }
+    }
+    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');
+        }
+    }
+}
 /**
- * file open.
+ * Asynchronous file open.
  * @see http://www.manpagez.com/man/2/open/
- * @param path
- * @param flags
- * @param mode defaults to `0644`
+ * @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 async function open(path, flag, mode = 0o644) {
-    const file = await doOp('open', true, path, FileFlag.getFileFlag(flag), normalizeMode(mode, 0o644), cred);
-    return getFdForFile(file);
+    const file = await _open(path, flag, mode, true);
+    return new FileHandle(getFdForFile(file));
 }
-export async function readFile(filename, arg2 = {}) {
-    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 = await doOp('readFile', true, filename, flag, cred);
-    switch (options.encoding) {
-        case 'utf8':
-        case 'utf-8':
-            return decode(data);
-        default:
-            return data;
-    }
+open;
+/**
+ * Opens a file without resolving symlinks
+ * @internal
+ */
+export async function lopen(path, flag, mode = 0o644) {
+    const file = await _open(path, flag, mode, false);
+    return new FileHandle(getFdForFile(file));
 }
-export async function writeFile(filename, data, arg3) {
-    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.');
+/**
+ * Asynchronously reads the entire contents of a file.
+ */
+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;
     }
-    if (typeof data != 'string' && !options.encoding) {
-        throw new ApiError(ErrorCode.EINVAL, 'Encoding not specified');
+    finally {
+        await file.close();
     }
-    const encodedData = typeof data == 'string' ? encode(data) : data;
-    return doOp('writeFile', true, filename, encodedData, flag, options.mode, cred);
 }
-export async function appendFile(filename, data, arg3) {
-    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');
+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 encodedData = typeof data == 'string' ? encode(data) : data;
-    return doOp('appendFile', true, filename, encodedData, flag, options.mode, cred);
-}
-export async function fstat(fd, options) {
-    const stats = await fd2file(fd).stat();
-    return options?.bigint ? BigIntStats.clone(stats) : stats;
+    const data = await _readFile(filename, options.flag, true);
+    return options.encoding ? decode(data, options.encoding) : data;
 }
+readFile;
 /**
- * close.
- * @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 async function close(fd) {
-    await fd2file(fd).close();
-    fdMap.delete(fd);
-    return;
+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();
+    }
 }
 /**
- * ftruncate.
- * @param fd
- * @param len
+ * 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 ftruncate(fd, len = 0) {
-    const file = fd2file(fd);
-    if (len < 0) {
-        throw new ApiError(ErrorCode.EINVAL);
+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');
     }
-    return file.truncate(len);
+    const encodedData = typeof data == 'string' ? encode(data, options.encoding) : data;
+    await _writeFile(filename, encodedData, options.flag, options.mode, true);
 }
+writeFile;
 /**
- * fsync.
- * @param fd
+ * Asynchronously append data to a file, creating the file if
+ * it not yet exists.
  */
-export async function fsync(fd) {
-    return fd2file(fd).sync();
+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();
+    }
 }
 /**
- * fdatasync.
- * @param fd
+ * 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 fdatasync(fd) {
-    return fd2file(fd).datasync();
-}
-export async function write(fd, arg2, arg3, arg4, arg5) {
-    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, encoding);
-        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);
+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
@@ -222,41 +426,40 @@ export async function write(fd, arg2, arg3, arg4, arg5) {
  *   in the file. If position is null, data will be read from the current file
  *   position.
  */
-export async function read(fd, buffer, offset, length, position) {
-    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 async function fchown(fd, uid, gid) {
-    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 async function fchmod(fd, mode) {
-    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 async function futimes(fd, atime, mtime) {
-    return fd2file(fd).utimes(normalizeTime(atime), normalizeTime(mtime));
+export function futimes(handle, atime, mtime) {
+    return handle.utimes(atime, mtime);
 }
+futimes;
 // DIRECTORY-ONLY METHODS
 /**
  * `rmdir`.
@@ -265,14 +468,11 @@ export async function futimes(fd, atime, mtime) {
 export async function rmdir(path) {
     return doOp('rmdir', true, path, cred);
 }
-/**
- * `mkdir`.
- * @param path
- * @param mode defaults to `0777`
- */
+rmdir;
 export async function mkdir(path, mode) {
-    return doOp('mkdir', true, path, normalizeMode(mode, 0o777), cred);
+    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);
@@ -289,37 +489,49 @@ export async function readdir(path, options) {
     }
     const values = [];
     for (const entry of entries) {
-        values.push(options?.withFileTypes ? new Dirent(entry, await stat(join(path, entry))) : entry);
+        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 async function link(srcpath, dstpath) {
-    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 async function symlink(srcpath, dstpath, type = 'file') {
+export async function symlink(target, path, type = 'file') {
     if (!['file', 'dir', 'junction'].includes(type)) {
-        throw new ApiError(ErrorCode.EINVAL, 'Invalid type: ' + type);
+        throw new ApiError(ErrorCode.EINVAL, 'Invalid symlink type: ' + type);
+    }
+    if (await exists(path)) {
+        throw ApiError.EEXIST(path);
     }
-    dstpath = normalizePath(dstpath);
-    return doOp('symlink', false, srcpath, dstpath, type, cred);
+    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 doOp('readlink', false, path, cred);
-    return encode(value, typeof options == 'object' ? options.encoding : 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`.
@@ -328,8 +540,15 @@ export async function readlink(path, options) {
  * @param gid
  */
 export async function chown(path, uid, gid) {
-    return doOp('chown', true, path, uid, gid, cred);
+    const handle = await open(path, 'r+');
+    try {
+        await handle.chown(uid, gid);
+    }
+    finally {
+        await handle.close();
+    }
 }
+chown;
 /**
  * `lchown`.
  * @param path
@@ -337,32 +556,45 @@ export async function chown(path, uid, gid) {
  * @param gid
  */
 export async function lchown(path, uid, gid) {
-    return doOp('chown', false, path, uid, gid, cred);
+    const handle = await lopen(path, 'r+');
+    try {
+        await handle.chown(uid, gid);
+    }
+    finally {
+        await handle.close();
+    }
 }
+lchown;
 /**
  * `chmod`.
  * @param path
  * @param mode
  */
 export async function chmod(path, mode) {
-    const numMode = normalizeMode(mode, -1);
-    if (numMode < 0) {
-        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+    const handle = await open(path, 'r+');
+    try {
+        await handle.chmod(mode);
+    }
+    finally {
+        await handle.close();
     }
-    return doOp('chmod', true, path, numMode, cred);
 }
+chmod;
 /**
  * `lchmod`.
  * @param path
  * @param mode
  */
 export async function lchmod(path, mode) {
-    const numMode = normalizeMode(mode, -1);
-    if (numMode < 1) {
-        throw new ApiError(ErrorCode.EINVAL, `Invalid mode.`);
+    const handle = await lopen(path, 'r+');
+    try {
+        await handle.chmod(mode);
+    }
+    finally {
+        await handle.close();
     }
-    return doOp('chmod', false, normalizePath(path), numMode, cred);
 }
+lchmod;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
@@ -370,8 +602,15 @@ export async function lchmod(path, mode) {
  * @param mtime
  */
 export async function utimes(path, atime, mtime) {
-    return doOp('utimes', true, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    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
@@ -379,16 +618,15 @@ export async function utimes(path, atime, mtime) {
  * @param mtime
  */
 export async function lutimes(path, atime, mtime) {
-    return doOp('utimes', false, path, normalizeTime(atime), normalizeTime(mtime), cred);
+    const handle = await lopen(path, 'r+');
+    try {
+        await handle.utimes(atime, mtime);
+    }
+    finally {
+        await handle.close();
+    }
 }
-/**
- * `realpath`.
- * @param path
- * @param options
- * @return resolved path
- *
- * Note: This *Can not* use doOp since doOp depends on it
- */
+lutimes;
 export async function realpath(path, options) {
     path = normalizePath(path);
     const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
@@ -397,13 +635,14 @@ export async function realpath(path, options) {
         if (!stats.isSymbolicLink()) {
             return path;
         }
-        const dst = mountPoint + normalizePath(await fs.readlink(resolvedPath, cred));
+        const dst = mountPoint + normalizePath(decode(await _readFile(resolvedPath, 'r+', false)));
         return realpath(dst);
     }
     catch (e) {
         throw fixError(e, { [resolvedPath]: path });
     }
 }
+realpath;
 export async function watchFile(filename, arg2, listener = nop) {
     throw new ApiError(ErrorCode.ENOTSUP);
 }
@@ -419,7 +658,10 @@ export async function watch(filename, arg2, listener = nop) {
  * @param mode
  */
 export async function access(path, mode = 0o600) {
-    return doOp('access', true, path, mode, cred);
+    const stats = await stat(path);
+    if (!stats.hasAccess(mode, cred)) {
+        throw new ApiError(ErrorCode.EACCES);
+    }
 }
 export async function createReadStream(path, options) {
     throw new ApiError(ErrorCode.ENOTSUP);