@zenfs/core 1.7.2 → 1.8.1

package/dist/mixins/mutexed.d.ts

@@ -3,6 +3,7 @@ import type { CreationOptions, FileSystem, FileSystemMetadata } from '../filesys
 import type { Stats } from '../stats.js';
 import type { Concrete } from '../utils.js';
 import '../polyfills.js';
+import type { InodeLike } from '../backends/index.js';
 export declare class MutexLock {
     protected readonly previous?: MutexLock | undefined;
     protected current: PromiseWithResolvers<void>;
@@ -68,15 +69,19 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     existsSync(path: string): boolean;
     link(srcpath: string, dstpath: string): Promise<void>;
     linkSync(srcpath: string, dstpath: string): void;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    sync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): Promise<void>;
+    syncSync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): void;
+    read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
+    readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
+    write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): void;
 }
 /**
  * This serializes access to an underlying async filesystem.
  * For example, on an OverlayFS instance with an async lower
  * directory operations like rename and rmdir may involve multiple
  * requests involving both the upper and lower file systems -- they
- * are not executed in a single atomic step. OverlayFS uses this
+ * are not executed in a single atomic step. OverlayFS used to use this
  * to avoid having to reason about the correctness of
  * multiple requests interleaving.
  *

package/dist/mixins/mutexed.js

@@ -448,13 +448,69 @@ export class _MutexedFS {
             __disposeResources(env_22);
         }
     }
+    async read(path, buffer, offset, end) {
+        const env_23 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_23, await this.lock(path, 'read'), false);
+            return await this._fs.read(path, buffer, offset, end);
+        }
+        catch (e_23) {
+            env_23.error = e_23;
+            env_23.hasError = true;
+        }
+        finally {
+            __disposeResources(env_23);
+        }
+    }
+    readSync(path, buffer, offset, end) {
+        const env_24 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_24, this.lockSync(path, 'read'), false);
+            return this._fs.readSync(path, buffer, offset, end);
+        }
+        catch (e_24) {
+            env_24.error = e_24;
+            env_24.hasError = true;
+        }
+        finally {
+            __disposeResources(env_24);
+        }
+    }
+    async write(path, buffer, offset) {
+        const env_25 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_25, await this.lock(path, 'write'), false);
+            return await this._fs.write(path, buffer, offset);
+        }
+        catch (e_25) {
+            env_25.error = e_25;
+            env_25.hasError = true;
+        }
+        finally {
+            __disposeResources(env_25);
+        }
+    }
+    writeSync(path, buffer, offset) {
+        const env_26 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_26, this.lockSync(path, 'write'), false);
+            return this._fs.writeSync(path, buffer, offset);
+        }
+        catch (e_26) {
+            env_26.error = e_26;
+            env_26.hasError = true;
+        }
+        finally {
+            __disposeResources(env_26);
+        }
+    }
 }
 /**
  * This serializes access to an underlying async filesystem.
  * For example, on an OverlayFS instance with an async lower
  * directory operations like rename and rmdir may involve multiple
  * requests involving both the upper and lower file systems -- they
- * are not executed in a single atomic step. OverlayFS uses this
+ * are not executed in a single atomic step. OverlayFS used to use this
  * to avoid having to reason about the correctness of
  * multiple requests interleaving.
  *

package/dist/mixins/readonly.d.ts

@@ -1,26 +1,27 @@
-import type { File } from '../file.js';
 import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import type { Stats } from '../stats.js';
+import type { StatsLike } from '../stats.js';
 import type { Mixin } from './shared.js';
 /**
  * @internal
  */
 export interface ReadonlyMixin {
     metadata(): FileSystemMetadata;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    renameSync(oldPath: string, newPath: string): void;
-    createFile(path: string, flag: string, mode: number): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number): File;
-    unlink(path: string): Promise<void>;
-    unlinkSync(path: string): void;
-    rmdir(path: string): Promise<void>;
-    rmdirSync(path: string): void;
-    mkdir(path: string, mode: number): Promise<void>;
-    mkdirSync(path: string, mode: number): void;
-    link(srcpath: string, dstpath: string): Promise<void>;
-    linkSync(srcpath: string, dstpath: string): void;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    rename(oldPath: string, newPath: string): Promise<never>;
+    renameSync(oldPath: string, newPath: string): never;
+    createFile(path: string, flag: string, mode: number): Promise<never>;
+    createFileSync(path: string, flag: string, mode: number): never;
+    unlink(path: string): Promise<never>;
+    unlinkSync(path: string): never;
+    rmdir(path: string): Promise<never>;
+    rmdirSync(path: string): never;
+    mkdir(path: string, mode: number): Promise<never>;
+    mkdirSync(path: string, mode: number): never;
+    link(srcpath: string, dstpath: string): Promise<never>;
+    linkSync(srcpath: string, dstpath: string): never;
+    sync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): Promise<never>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): never;
+    write(path: string, buffer: Uint8Array, offset: number): Promise<never>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): Promise<never>;
 }
 /**
  * Implements the non-readonly methods to throw `EROFS`

package/dist/mixins/readonly.js

@@ -50,6 +50,12 @@ export function Readonly(FS) {
         syncSync() {
             throw new ErrnoError(Errno.EROFS);
         }
+        async write() {
+            throw new ErrnoError(Errno.EROFS);
+        }
+        writeSync() {
+            throw new ErrnoError(Errno.EROFS);
+        }
     }
     return ReadonlyFS;
 }

package/dist/mixins/sync.d.ts

@@ -1,5 +1,5 @@
 import type { FileSystem } from '../filesystem.js';
-import type { Mixin, AsyncFSMethods } from './shared.js';
+import type { AsyncFSMethods, Mixin } from './shared.js';
 /**
  * Implements the asynchronous API in terms of the synchronous API.
  */

package/dist/stats.d.ts

@@ -1,6 +1,7 @@
 import type * as Node from 'node:fs';
 import type { V_Context } from './context.js';
 import * as c from './vfs/constants.js';
+import type { InodeFields, InodeLike } from './backends/store/inode.js';
 /**
  * Indicates the type of a file. Applied to 'mode'.
  */
@@ -91,8 +92,10 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     gid: T;
     /**
      * Some file systems stash data on stats objects.
+     * @todo [BREAKING] Remove this
+     * @deprecated @hidden
      */
-    fileData?: Uint8Array;
+    fileData?: unknown;
     /**
      * Time of last access, since epoch
      */
@@ -122,10 +125,12 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      * For directories/symlinks, this is normally the size of the struct that represents the item.
      */
     size: T;
+    data?: number;
+    flags?: number;
     /**
      * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
      */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino }?: Partial<StatsLike>);
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, ...rest }?: Partial<InodeLike>);
     isFile(): boolean;
     isDirectory(): boolean;
     isSymbolicLink(): boolean;
@@ -133,6 +138,7 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     isBlockDevice(): boolean;
     isCharacterDevice(): boolean;
     isFIFO(): boolean;
+    toJSON(): StatsLike<T> & InodeFields;
     /**
      * Checks if a given user/group has access to this item
      * @param mode The requested access, combination of W_OK, R_OK, and X_OK
@@ -143,15 +149,15 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     /**
      * Change the mode of the file.
      * We use this helper function to prevent messing up the type of the file.
-     * @internal
-     * @deprecated This will be removed in the next minor release since it is internal
+     * @internal @deprecated
+     * @todo [BREAKING] Remove
      */
     chmod(mode: number): void;
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
-     * @internal
-     * @deprecated This will be removed in the next minor release since it is internal
+     * @internal @deprecated
+     * @todo [BREAKING] Remove
      */
     chown(uid: number, gid: number): void;
     get atimeNs(): bigint;

package/dist/stats.js

@@ -1,5 +1,7 @@
 import { credentials } from './credentials.js';
 import * as c from './vfs/constants.js';
+import { pick } from 'utilium';
+import { _inode_fields } from './backends/store/inode.js';
 const n1000 = BigInt(1000);
 /**
  * Provides information about a particular entry in the file system.
@@ -39,7 +41,7 @@ export class StatsCommon {
     /**
      * Creates a new stats instance from a stats-like object. Can be used to copy stats (note)
      */
-    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino } = {}) {
+    constructor({ atimeMs, mtimeMs, ctimeMs, birthtimeMs, uid, gid, size, mode, ino, ...rest } = {}) {
         /**
          * ID of device containing file
          */
@@ -81,6 +83,7 @@ export class StatsCommon {
         if ((this.mode & c.S_IFMT) == 0) {
             this.mode = (this.mode | this._convert(c.S_IFREG));
         }
+        Object.assign(this, rest);
     }
     isFile() {
         return (this.mode & c.S_IFMT) === c.S_IFREG;
@@ -103,6 +106,9 @@ export class StatsCommon {
     isFIFO() {
         return (this.mode & c.S_IFMT) === c.S_IFIFO;
     }
+    toJSON() {
+        return pick(this, _inode_fields);
+    }
     /**
      * Checks if a given user/group has access to this item
      * @param mode The requested access, combination of W_OK, R_OK, and X_OK
@@ -142,11 +148,12 @@ export class StatsCommon {
         // Perform the access check
         return (perm & mode) === mode;
     }
+    /* node:coverage disable */
     /**
      * Change the mode of the file.
      * We use this helper function to prevent messing up the type of the file.
-     * @internal
-     * @deprecated This will be removed in the next minor release since it is internal
+     * @internal @deprecated
+     * @todo [BREAKING] Remove
      */
     chmod(mode) {
         this.mode = this._convert((this.mode & c.S_IFMT) | mode);
@@ -154,8 +161,8 @@ export class StatsCommon {
     /**
      * Change the owner user/group of the file.
      * This function makes sure it is a valid UID/GID (that is, a 32 unsigned int)
-     * @internal
-     * @deprecated This will be removed in the next minor release since it is internal
+     * @internal @deprecated
+     * @todo [BREAKING] Remove
      */
     chown(uid, gid) {
         uid = Number(uid);
@@ -167,6 +174,7 @@ export class StatsCommon {
             this.gid = this._convert(gid);
         }
     }
+    /* node:coverage enable */
     get atimeNs() {
         return BigInt(this.atimeMs) * n1000;
     }
@@ -184,7 +192,7 @@ export class StatsCommon {
  * @hidden @internal
  */
 export function _chown(stats, uid, gid) {
-    if (!isNaN(uid) && 0 <= uid && uid < 2 ** 32) {
+    if (!isNaN(uid) && 0 <= uid && uid < c.size_max) {
         stats.uid = uid;
     }
     if (!isNaN(gid) && 0 <= gid && gid < 2 ** 32) {

package/dist/utils.d.ts

@@ -32,15 +32,16 @@ export { /** @deprecated @hidden */ decodeUTF8 as decode };
  * Decodes a directory listing
  * @hidden
  */
-export declare function decodeDirListing(data: Uint8Array): Record<string, bigint>;
+export declare function decodeDirListing(data: Uint8Array): Record<string, number>;
 /**
  * Encodes a directory listing
  * @hidden
  */
-export declare function encodeDirListing(data: Record<string, bigint>): Uint8Array;
+export declare function encodeDirListing(data: Record<string, number>): Uint8Array;
 export type Callback<Args extends unknown[] = [], NoError = undefined | void> = (e: ErrnoError | NoError, ...args: OptionalTuple<Args>) => unknown;
 /**
  * Normalizes a mode
+ * @param def default
  * @internal
  */
 export declare function normalizeMode(mode: unknown, def?: number): number;
@@ -48,7 +49,7 @@ export declare function normalizeMode(mode: unknown, def?: number): number;
  * Normalizes a time
  * @internal
  */
-export declare function normalizeTime(time: string | number | Date): Date;
+export declare function normalizeTime(time: string | number | Date): number;
 /**
  * Normalizes a path
  * @internal
@@ -75,3 +76,22 @@ export type Concrete<T extends ClassLike> = Pick<T, keyof T> & (new (...args: an
  * @internal
  */
 export declare function randomBigInt(): bigint;
+/**
+ * Prevents infinite loops
+ * @internal
+ */
+export declare function canary(path?: string, syscall?: string): () => void;
+/**
+ * A wrapper for throwing things.
+ * Used in expressions.
+ * @todo Remove once `throw` is allowed in expressions
+ * @see https://github.com/tc39/proposal-throw-expressions
+ * @internal @hidden
+ */
+export declare function _throw(e: unknown): never;
+/**
+ * Grows a buffer if it isn't large enough
+ * @returns The original buffer if resized successfully, or a newly created buffer
+ * @internal Not for external use!
+ */
+export declare function growBuffer<T extends ArrayBufferLike | ArrayBufferView>(buffer: T, newByteLength: number): T;

package/dist/utils.js

@@ -34,7 +34,9 @@ export function encodeUTF8(input) {
     }
     return encoder.encode(input);
 }
+/* node:coverage disable */
 export { /** @deprecated @hidden */ encodeUTF8 as encode };
+/* node:coverage enable */
 const decoder = new TextDecoder();
 /**
  * Decodes a string from a buffer
@@ -46,38 +48,39 @@ export function decodeUTF8(input) {
     }
     return decoder.decode(input);
 }
+/* node:coverage disable */
 export { /** @deprecated @hidden */ decodeUTF8 as decode };
+/* node:coverage enable */
 /**
  * Decodes a directory listing
  * @hidden
  */
 export function decodeDirListing(data) {
-    return JSON.parse(decodeUTF8(data), (k, v) => (k == '' ? v : BigInt(v)));
+    return JSON.parse(decodeUTF8(data), (k, v) => (k == '' ? v : typeof v == 'string' ? BigInt(v).toString(16).slice(0, Math.min(v.length, 8)) : v));
 }
 /**
  * Encodes a directory listing
  * @hidden
  */
 export function encodeDirListing(data) {
-    return encodeUTF8(JSON.stringify(data, (k, v) => (k == '' ? v : v.toString())));
+    return encodeUTF8(JSON.stringify(data));
 }
 /**
  * Normalizes a mode
+ * @param def default
  * @internal
  */
 export function normalizeMode(mode, def) {
-    if (typeof mode == 'number') {
+    if (typeof mode == 'number')
         return mode;
-    }
     if (typeof mode == 'string') {
         const parsed = parseInt(mode, 8);
         if (!isNaN(parsed)) {
             return parsed;
         }
     }
-    if (typeof def == 'number') {
+    if (typeof def == 'number')
         return def;
-    }
     throw new ErrnoError(Errno.EINVAL, 'Invalid mode: ' + (mode === null || mode === void 0 ? void 0 : mode.toString()));
 }
 /**
@@ -85,11 +88,10 @@ export function normalizeMode(mode, def) {
  * @internal
  */
 export function normalizeTime(time) {
-    if (time instanceof Date) {
-        return time;
-    }
+    if (time instanceof Date)
+        return time.getTime();
     try {
-        return new Date(time);
+        return Number(time);
     }
     catch {
         throw new ErrnoError(Errno.EINVAL, 'Invalid time.');
@@ -138,3 +140,49 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
 export function randomBigInt() {
     return BigInt('0x' + randomHex(8));
 }
+/**
+ * Prevents infinite loops
+ * @internal
+ */
+export function canary(path, syscall) {
+    const timeout = setTimeout(() => {
+        throw ErrnoError.With('EDEADLK', path, syscall);
+    }, 5000);
+    return () => clearTimeout(timeout);
+}
+/**
+ * A wrapper for throwing things.
+ * Used in expressions.
+ * @todo Remove once `throw` is allowed in expressions
+ * @see https://github.com/tc39/proposal-throw-expressions
+ * @internal @hidden
+ */
+export function _throw(e) {
+    throw e;
+}
+/**
+ * Grows a buffer if it isn't large enough
+ * @returns The original buffer if resized successfully, or a newly created buffer
+ * @internal Not for external use!
+ */
+export function growBuffer(buffer, newByteLength) {
+    if (buffer.byteLength >= newByteLength)
+        return buffer;
+    if (ArrayBuffer.isView(buffer)) {
+        const newBuffer = growBuffer(buffer.buffer, newByteLength);
+        return new buffer.constructor(newBuffer, buffer.byteOffset, newByteLength);
+    }
+    const isShared = buffer instanceof SharedArrayBuffer;
+    // Note: If true, the buffer must be resizable/growable because of the first check.
+    if (buffer.maxByteLength > newByteLength) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        isShared ? buffer.grow(newByteLength) : buffer.resize(newByteLength);
+        return buffer;
+    }
+    if (!isShared) {
+        return buffer.transfer(newByteLength);
+    }
+    const newBuffer = new SharedArrayBuffer(newByteLength);
+    new Uint8Array(newBuffer).set(new Uint8Array(buffer));
+    return newBuffer;
+}

package/dist/vfs/async.js

@@ -431,7 +431,7 @@ export function createReadStream(path, options) {
             try {
                 handle || (handle = await promises.open.call(context, path, 'r', options === null || options === void 0 ? void 0 : options.mode));
                 const result = await handle.read(new Uint8Array(size), 0, size, handle.file.position);
-                stream.push(!result.bytesRead ? null : result.buffer.slice(0, result.bytesRead));
+                stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead));
                 handle.file.position += result.bytesRead;
                 if (!result.bytesRead) {
                     await handle.close();

package/dist/vfs/constants.d.ts

@@ -111,7 +111,7 @@ export declare const S_IXOTH = 1;
  */
 export declare const UV_FS_O_FILEMAP = 0;
 /**
- * Max 32-bit integer
+ * Max 32-bit unsigned integer
  * @hidden
  */
-export declare const size_max: number;
+export declare const size_max = 4294967295;

package/dist/vfs/constants.js

@@ -123,7 +123,7 @@ export const S_IXOTH = 1;
  */
 export const UV_FS_O_FILEMAP = 0;
 /**
- * Max 32-bit integer
+ * Max 32-bit unsigned integer
  * @hidden
  */
-export const size_max = 2 ** 32 - 1;
+export const size_max = 0xffffffff; // 2^32 - 1

package/dist/vfs/dir.js

@@ -66,7 +66,9 @@ export class Dir {
     async _read() {
         var _a, _b;
         this.checkClosed();
-        (_a = this._entries) !== null && _a !== void 0 ? _a : (this._entries = await readdir.call(this.context, this.path, { withFileTypes: true }));
+        (_a = this._entries) !== null && _a !== void 0 ? _a : (this._entries = await readdir.call(this.context, this.path, {
+            withFileTypes: true,
+        }));
         if (!this._entries.length)
             return null;
         return (_b = this._entries.shift()) !== null && _b !== void 0 ? _b : null;

package/dist/vfs/index.js

@@ -4,6 +4,7 @@ export * as constants from './constants.js';
 export * from './dir.js';
 export * as promises from './promises.js';
 export { chroot, mount, mountObject, 
+/* node:coverage disable */
 /**
  * The map of mount points.
  * Using `fs.mounts` instead of the `mounts` export is a security issue and not recommended.
@@ -11,6 +12,8 @@ export { chroot, mount, mountObject,
  * @todo [BREAKING] remove `fs.mounts` for security.
  * @deprecated Use the `mounts` export that isn't an `fs` property!
  */
-mounts, umount, } from './shared.js';
+mounts, 
+/* node:coverage enable */
+umount, } from './shared.js';
 export * from './streams.js';
 export * from './sync.js';

package/dist/vfs/promises.js

@@ -197,7 +197,7 @@ export class FileHandle {
                         controller.close();
                         return;
                     }
-                    controller.enqueue(result.buffer.slice(0, result.bytesRead));
+                    controller.enqueue(result.buffer.subarray(0, result.bytesRead));
                     position += result.bytesRead;
                     if (++i >= maxChunks) {
                         throw new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'FileHandle.readableWebStream');
@@ -213,7 +213,10 @@ export class FileHandle {
         if (!('ReadableStream' in _gt)) {
             throw new ErrnoError(Errno.ENOSYS, 'ReadableStream is missing on globalThis');
         }
-        return new _gt.ReadableStream({ start, type: options.type });
+        return new _gt.ReadableStream({
+            start,
+            type: options.type,
+        });
     }
     /**
      * @todo Implement
@@ -330,7 +333,7 @@ export class FileHandle {
             read: async (size) => {
                 try {
                     const result = await this.read(new Uint8Array(size), 0, size, this.file.position);
-                    stream.push(!result.bytesRead ? null : result.buffer.slice(0, result.bytesRead)); // Push data or null for EOF
+                    stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead)); // Push data or null for EOF
                     this.file.position += result.bytesRead;
                 }
                 catch (error) {
@@ -478,11 +481,11 @@ async function applySetId(file, uid, gid) {
  * Opens a file. This helper handles the complexity of file flags.
  * @internal
  */
-async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
+async function _open(path, opt) {
     var _a;
     path = normalizePath(path);
-    const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks ? await realpath.call(this, path) : path;
+    const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
+    path = opt.preserveSymlinks ? path : await realpath.call(this, path);
     const { fs, path: resolved } = resolveMount(path, this);
     const stats = await fs.stat(resolved).catch(() => null);
     if (!stats) {
@@ -527,7 +530,7 @@ async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
  * @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) {
-    return await _open.call(this, path, flag, mode, true);
+    return await _open.call(this, path, { flag, mode });
 }
 open;
 export async function readFile(path, _options) {
@@ -771,7 +774,7 @@ export async function symlink(target, path, type = 'file') {
         if (await exists.call(this, path)) {
             throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
         }
-        const handle = __addDisposableResource(env_5, await _open.call(this, path, 'w+', 0o644, false), true);
+        const handle = __addDisposableResource(env_5, await _open.call(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
         await handle.writeFile(target.toString());
         await handle.file.chmod(constants.S_IFLNK);
     }
@@ -789,7 +792,7 @@ symlink;
 export async function readlink(path, options) {
     const env_6 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_6, await _open.call(this, normalizePath(path), 'r', 0o644, false), true);
+        const handle = __addDisposableResource(env_6, await _open.call(this, normalizePath(path), { flag: 'r', mode: 0o644, preserveSymlinks: true }), true);
         const value = await handle.readFile();
         const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
         // always defaults to utf-8 to avoid wrangler (cloudflare) worker "unknown encoding" exception
@@ -826,7 +829,12 @@ chown;
 export async function lchown(path, uid, gid) {
     const env_8 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_8, await _open.call(this, path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_8, await _open.call(this, path, {
+            flag: 'r+',
+            mode: 0o644,
+            preserveSymlinks: true,
+            allowDirectory: true,
+        }), true);
         await handle.chown(uid, gid);
     }
     catch (e_8) {
@@ -860,7 +868,12 @@ chmod;
 export async function lchmod(path, mode) {
     const env_10 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_10, await _open.call(this, path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_10, await _open.call(this, path, {
+            flag: 'r+',
+            mode: 0o644,
+            preserveSymlinks: true,
+            allowDirectory: true,
+        }), true);
         await handle.chmod(mode);
     }
     catch (e_10) {
@@ -900,7 +913,12 @@ utimes;
 export async function lutimes(path, atime, mtime) {
     const env_12 = { stack: [], error: void 0, hasError: false };
     try {
-        const handle = __addDisposableResource(env_12, await _open.call(this, path, 'r+', 0o644, false), true);
+        const handle = __addDisposableResource(env_12, await _open.call(this, path, {
+            flag: 'r+',
+            mode: 0o644,
+            preserveSymlinks: true,
+            allowDirectory: true,
+        }), true);
         await handle.utimes(new Date(atime), new Date(mtime));
     }
     catch (e_12) {
@@ -1006,7 +1024,9 @@ export async function rm(path, options) {
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options === null || options === void 0 ? void 0 : options.recursive) {
-                for (const entry of await readdir.call(this, path, { _isIndirect: true })) {
+                for (const entry of await readdir.call(this, path, {
+                    _isIndirect: true,
+                })) {
                     await rm.call(this, join(path, entry), { ...options, _isIndirect: true });
                 }
             }