@zenfs/core 1.8.8 → 1.9.0

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import type * as fs from 'node:fs';
 import type { ClassLike, OptionalTuple } from 'utilium';
-import { ErrnoError } from './error.js';
+import { ErrnoError } from './internal/error.js';
 import type { AbsolutePath } from './vfs/path.js';
 declare global {
     function atob(data: string): string;
@@ -79,19 +79,6 @@ export declare function randomBigInt(): bigint;
 /**
  * Prevents infinite loops
  * @internal
+ * @deprecated Use `canary` from Utilium
  */
 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

@@ -1,5 +1,5 @@
-import { randomHex } from 'utilium';
-import { Errno, ErrnoError } from './error.js';
+import { Errno, ErrnoError } from './internal/error.js';
+import { log_deprecated } from './internal/log.js';
 import { resolve } from './vfs/path.js';
 /**
  * Encodes a string into a buffer
@@ -122,74 +122,37 @@ export function normalizePath(p) {
 export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
     if (typeof options != 'object' || options === null) {
         return {
-            encoding: typeof options == 'string' ? options : encoding !== null && encoding !== void 0 ? encoding : null,
+            encoding: typeof options == 'string' ? options : (encoding !== null && encoding !== void 0 ? encoding : null),
             flag,
             mode,
         };
     }
     return {
-        encoding: typeof (options === null || options === void 0 ? void 0 : options.encoding) == 'string' ? options.encoding : encoding !== null && encoding !== void 0 ? encoding : null,
+        encoding: typeof (options === null || options === void 0 ? void 0 : options.encoding) == 'string' ? options.encoding : (encoding !== null && encoding !== void 0 ? encoding : null),
         flag: typeof (options === null || options === void 0 ? void 0 : options.flag) == 'string' ? options.flag : flag,
         mode: normalizeMode('mode' in options ? options === null || options === void 0 ? void 0 : options.mode : null, mode),
     };
 }
+/* node:coverage disable */
+import { randomHex } from 'utilium';
 /**
  * Generate a random ino
  * @internal @deprecated @hidden
  */
 export function randomBigInt() {
+    log_deprecated('randomBigInt');
     return BigInt('0x' + randomHex(8));
 }
 /**
  * Prevents infinite loops
  * @internal
+ * @deprecated Use `canary` from Utilium
  */
 export function canary(path, syscall) {
+    log_deprecated('canary');
     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 = typeof SharedArrayBuffer !== 'undefined' && 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) {
-        const newBuffer = new SharedArrayBuffer(newByteLength);
-        new Uint8Array(newBuffer).set(new Uint8Array(buffer));
-        return newBuffer;
-    }
-    try {
-        return buffer.transfer(newByteLength);
-    }
-    catch {
-        const newBuffer = new ArrayBuffer(newByteLength);
-        new Uint8Array(newBuffer).set(new Uint8Array(buffer));
-        return newBuffer;
-    }
-}
+/* node:coverage enable */

package/dist/vfs/async.d.ts

@@ -1,11 +1,11 @@
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
-import type { FileContents } from '../filesystem.js';
 import type { Stats } from '../stats.js';
 import type { Callback } from '../utils.js';
 import type { Dir, Dirent } from './dir.js';
+import type { FileContents } from './types.js';
 import { Buffer } from 'buffer';
-import { ErrnoError } from '../error.js';
+import { ErrnoError } from '../internal/error.js';
 import { BigIntStats } from '../stats.js';
 import * as promises from './promises.js';
 import { ReadStream, WriteStream } from './streams.js';

package/dist/vfs/async.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer';
-import { Errno, ErrnoError } from '../error.js';
+import { Errno, ErrnoError } from '../internal/error.js';
 import { BigIntStats } from '../stats.js';
 import { normalizeMode, normalizePath } from '../utils.js';
 import { R_OK } from './constants.js';
@@ -476,10 +476,10 @@ export function createWriteStream(path, options) {
         },
         destroy(error, callback) {
             callback(error);
-            handle === null || handle === void 0 ? void 0 : handle.close().then(() => callback(error)).catch(callback);
+            void (handle === null || handle === void 0 ? void 0 : handle.close().then(() => callback(error)).catch(callback));
         },
         final(callback) {
-            handle === null || handle === void 0 ? void 0 : handle.close().then(() => callback()).catch(callback);
+            void (handle === null || handle === void 0 ? void 0 : handle.close().then(() => callback()).catch(callback));
         },
     });
     stream.path = path.toString();

package/dist/vfs/dir.js

@@ -1,4 +1,4 @@
-import { Errno, ErrnoError } from '../error.js';
+import { Errno, ErrnoError } from '../internal/error.js';
 import { basename } from './path.js';
 import { readdir } from './promises.js';
 import { readdirSync } from './sync.js';

package/dist/vfs/promises.d.ts

@@ -4,10 +4,9 @@ import type { Stream } from 'node:stream';
 import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import type { V_Context } from '../context.js';
-import type { File } from '../file.js';
-import type { FileContents } from '../filesystem.js';
+import type { File } from '../internal/file.js';
 import type { Stats } from '../stats.js';
-import type { InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
+import type { FileContents, InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
 import { Buffer } from 'buffer';
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
@@ -26,6 +25,7 @@ export declare class FileHandle implements promises.FileHandle {
      */
     readonly file: File;
     constructor(fdOrFile: number | File, context?: V_Context | undefined);
+    private _emitChange;
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
@@ -296,9 +296,9 @@ export declare function lutimes(this: V_Context, path: fs.PathLike, atime: fs.Ti
  */
 export declare function realpath(this: V_Context, path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export declare function realpath(this: V_Context, path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterable<promises.FileChangeInfo<string>>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterable<promises.FileChangeInfo<Buffer>>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterable<promises.FileChangeInfo<string>> | AsyncIterable<promises.FileChangeInfo<Buffer>>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterableIterator<promises.FileChangeInfo<string>>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterableIterator<promises.FileChangeInfo<Buffer>>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterableIterator<promises.FileChangeInfo<string>> | AsyncIterableIterator<promises.FileChangeInfo<Buffer>>;
 export declare function access(this: V_Context, path: fs.PathLike, mode?: number): Promise<void>;
 /**
  * Asynchronous `rm`. Removes files or directories (recursively).

package/dist/vfs/promises.js

@@ -51,9 +51,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
-import { credentials } from '../credentials.js';
-import { Errno, ErrnoError } from '../error.js';
-import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
+import { credentials } from '../internal/credentials.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.js';
 import '../polyfills.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
@@ -73,12 +73,16 @@ export class FileHandle {
         this.fd = isFile ? file2fd(fdOrFile) : fdOrFile;
         this.file = isFile ? fdOrFile : fd2file(fdOrFile);
     }
+    _emitChange() {
+        var _a, _b, _c;
+        emitChange(this.context, 'change', this.file.path.slice((_c = (_b = (_a = this.context) === null || _a === void 0 ? void 0 : _a.root) === null || _b === void 0 ? void 0 : _b.length) !== null && _c !== void 0 ? _c : 0));
+    }
     /**
      * Asynchronous fchown(2) - Change ownership of a file.
      */
     async chown(uid, gid) {
         await this.file.chown(uid, gid);
-        emitChange('change', this.file.path);
+        this._emitChange();
     }
     /**
      * Asynchronous fchmod(2) - Change permissions of a file.
@@ -90,7 +94,7 @@ export class FileHandle {
             throw new ErrnoError(Errno.EINVAL, 'Invalid mode.');
         }
         await this.file.chmod(numMode);
-        emitChange('change', this.file.path);
+        this._emitChange();
     }
     /**
      * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
@@ -114,7 +118,7 @@ export class FileHandle {
             throw new ErrnoError(Errno.EINVAL);
         }
         await this.file.truncate(length);
-        emitChange('change', this.file.path);
+        this._emitChange();
     }
     /**
      * Asynchronously change file timestamps of the file.
@@ -123,7 +127,7 @@ export class FileHandle {
      */
     async utimes(atime, mtime) {
         await this.file.utimes(normalizeTime(atime), normalizeTime(mtime));
-        emitChange('change', this.file.path);
+        this._emitChange();
     }
     /**
      * Asynchronously append data to a file, creating the file if it does not exist. The underlying file will _not_ be closed automatically.
@@ -145,7 +149,7 @@ export class FileHandle {
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length);
-        emitChange('change', this.file.path);
+        this._emitChange();
     }
     async read(buffer, offset, length, position) {
         if (typeof offset == 'object' && offset != null) {
@@ -262,7 +266,7 @@ export class FileHandle {
         }
         position !== null && position !== void 0 ? position : (position = this.file.position);
         const bytesWritten = await this.file.write(buffer, offset, length, position);
-        emitChange('change', this.file.path);
+        this._emitChange();
         return { buffer: data, bytesWritten };
     }
     /**
@@ -286,7 +290,7 @@ export class FileHandle {
         }
         const encodedData = typeof data == 'string' ? Buffer.from(data, options.encoding) : data;
         await this.file.write(encodedData, 0, encodedData.length, 0);
-        emitChange('change', this.file.path);
+        this._emitChange();
     }
     /**
      * Asynchronous close(2) - close a `FileHandle`.
@@ -378,13 +382,13 @@ export async function rename(oldPath, newPath) {
     try {
         if (src.mountPoint == dst.mountPoint) {
             await src.fs.rename(src.path, dst.path);
-            emitChange('rename', oldPath.toString());
-            emitChange('change', newPath.toString());
+            emitChange(this, 'rename', oldPath.toString());
+            emitChange(this, 'change', newPath.toString());
             return;
         }
         await writeFile.call(this, newPath, await readFile(oldPath));
         await unlink.call(this, oldPath);
-        emitChange('rename', oldPath.toString());
+        emitChange(this, 'rename', oldPath.toString());
     }
     catch (e) {
         throw fixError(e, { [src.path]: oldPath, [dst.path]: newPath });
@@ -459,7 +463,7 @@ export async function unlink(path) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
-        emitChange('rename', path.toString());
+        emitChange(this, 'rename', path.toString());
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -470,8 +474,7 @@ unlink;
  * Manually apply setuid/setgid.
  */
 async function applySetId(file, uid, gid) {
-    var _a;
-    if ((_a = file.fs.metadata().features) === null || _a === void 0 ? void 0 : _a.includes('setid'))
+    if (file.fs.attributes.has('setid'))
         return;
     const parent = await file.fs.stat(dirname(file.path));
     await file.chown(parent.mode & constants.S_ISUID ? parent.uid : uid, // manually apply setuid/setgid
@@ -633,7 +636,7 @@ export async function rmdir(path) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
         }
         await fs.rmdir(resolved);
-        emitChange('rename', path.toString());
+        emitChange(this, 'rename', path.toString());
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -655,7 +658,7 @@ export async function mkdir(path, options) {
             }
             await fs.mkdir(resolved, mode, { uid, gid });
             await applySetId(await fs.openFile(resolved, 'r+'), uid, gid);
-            emitChange('rename', path.toString());
+            emitChange(this, 'rename', path.toString());
             return;
         }
         const dirs = [];
@@ -669,7 +672,7 @@ export async function mkdir(path, options) {
             }
             await fs.mkdir(dir, mode, { uid, gid });
             await applySetId(await fs.openFile(dir, 'r+'), uid, gid);
-            emitChange('rename', dir);
+            emitChange(this, 'rename', dir);
         }
         return root.length == 1 ? dirs[0] : (_b = dirs[0]) === null || _b === void 0 ? void 0 : _b.slice(root.length);
     }
@@ -984,36 +987,38 @@ export async function realpath(path, options) {
 }
 realpath;
 export function watch(filename, options = {}) {
-    const context = this;
+    const watcher = new FSWatcher(this, filename.toString(), typeof options !== 'string' ? options : { encoding: options });
+    // A queue to hold change events, since we need to resolve them in the async iterator
+    const eventQueue = [];
+    let done = false;
+    watcher.on('change', (eventType, filename) => {
+        var _a;
+        (_a = eventQueue.shift()) === null || _a === void 0 ? void 0 : _a({ value: { eventType, filename }, done: false });
+    });
+    function cleanup() {
+        done = true;
+        watcher.close();
+        for (const resolve of eventQueue) {
+            resolve({ value: null, done });
+        }
+        eventQueue.length = 0; // Clear the queue
+        return Promise.resolve({ value: null, done: true });
+    }
     return {
+        async next() {
+            if (done)
+                return Promise.resolve({ value: null, done });
+            const { promise, resolve } = Promise.withResolvers();
+            eventQueue.push(resolve);
+            return promise;
+        },
+        return: cleanup,
+        throw: cleanup,
+        async [Symbol.asyncDispose]() {
+            await cleanup();
+        },
         [Symbol.asyncIterator]() {
-            const watcher = new FSWatcher(context, filename.toString(), typeof options !== 'string' ? options : { encoding: options });
-            // A queue to hold change events, since we need to resolve them in the async iterator
-            const eventQueue = [];
-            watcher.on('change', (eventType, filename) => {
-                var _a;
-                (_a = eventQueue.shift()) === null || _a === void 0 ? void 0 : _a({ value: { eventType, filename }, done: false });
-            });
-            function cleanup() {
-                watcher.close();
-                for (const resolve of eventQueue) {
-                    resolve({ value: null, done: true });
-                }
-                eventQueue.length = 0; // Clear the queue
-                return Promise.resolve({ value: null, done: true });
-            }
-            return {
-                async next() {
-                    const { promise, resolve } = Promise.withResolvers();
-                    eventQueue.push(resolve);
-                    return promise;
-                },
-                return: cleanup,
-                throw: cleanup,
-                [Symbol.asyncDispose]() {
-                    return Promise.resolve();
-                },
-            };
+            return this;
         },
     };
 }
@@ -1093,7 +1098,7 @@ export async function copyFile(src, dest, mode) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', dest, 'copyFile');
     }
     await writeFile.call(this, dest, await readFile.call(this, src));
-    emitChange('rename', dest.toString());
+    emitChange(this, 'rename', dest.toString());
 }
 copyFile;
 /**
@@ -1187,7 +1192,7 @@ export function glob(pattern, opt) {
             if (exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**
-             * @todo it the pattern.source check correct?
+             * @todo is the pattern.source check correct?
              */
             if ((await stat(fullPath)).isDirectory() && regexPatterns.some(pattern => pattern.source.includes('.*'))) {
                 yield* recursiveList(fullPath);

package/dist/vfs/shared.d.ts

@@ -1,8 +1,8 @@
 import type * as fs from 'node:fs';
-import type { File } from '../file.js';
-import type { FileSystem } from '../filesystem.js';
+import type { File } from '../internal/file.js';
+import type { FileSystem } from '../internal/filesystem.js';
 import { type BoundContext, type V_Context } from '../context.js';
-import { ErrnoError } from '../error.js';
+import { ErrnoError } from '../internal/error.js';
 import { type AbsolutePath } from './path.js';
 /**
  * @internal @hidden

package/dist/vfs/shared.js

@@ -1,11 +1,13 @@
 // Utilities and shared data
 import { InMemory } from '../backends/memory.js';
 import { bindContext } from '../context.js';
-import { Errno, ErrnoError } from '../error.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { alert, debug, err, info, log_deprecated, notice, warn } from '../internal/log.js';
 import { normalizePath } from '../utils.js';
 import { paths as pathCache } from './cache.js';
 import { size_max } from './constants.js';
 import { join, resolve } from './path.js';
+import { ZenFsType } from '../stats.js';
 // descriptors
 /**
  * @internal @hidden
@@ -41,29 +43,32 @@ mount('/', InMemory.create({ name: 'root' }));
  * @internal
  */
 export function mount(mountPoint, fs) {
-    if (mountPoint[0] !== '/') {
+    if (mountPoint[0] != '/')
         mountPoint = '/' + mountPoint;
-    }
     mountPoint = resolve(mountPoint);
     if (mounts.has(mountPoint)) {
-        throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use.');
+        throw err(new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use.'));
     }
+    fs._mountPoint = mountPoint;
     mounts.set(mountPoint, fs);
+    info(`Mounted ${fs.name} on ${mountPoint}`);
+    debug(`${fs.name} attributes: ${[...fs.attributes].map(([k, v]) => (v !== undefined && v !== null ? k + '=' + v : v)).join(', ')}`);
     pathCache.clear();
 }
 /**
  * Unmounts the file system at `mountPoint`.
  */
 export function umount(mountPoint) {
-    if (mountPoint[0] !== '/') {
+    if (mountPoint[0] != '/')
         mountPoint = '/' + mountPoint;
-    }
     mountPoint = resolve(mountPoint);
     if (!mounts.has(mountPoint)) {
-        throw new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already unmounted.');
+        warn(mountPoint + ' is already unmounted.');
+        return;
     }
     mounts.delete(mountPoint);
     pathCache.clear();
+    notice('Unmounted ' + mountPoint);
 }
 /**
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root
@@ -83,7 +88,7 @@ export function resolveMount(path, ctx) {
             return { fs, path, mountPoint, root };
         }
     }
-    throw new ErrnoError(Errno.EIO, 'No file system');
+    throw alert(new ErrnoError(Errno.EIO, 'No file system', path));
 }
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
@@ -118,6 +123,7 @@ export function fixError(e, paths) {
  * @internal @deprecated
  */
 export function mountObject(mounts) {
+    log_deprecated('mountObject');
     if ('/' in mounts) {
         umount('/');
     }
@@ -130,10 +136,10 @@ export function mountObject(mounts) {
  * @internal @hidden
  */
 export function _statfs(fs, bigint) {
-    const md = fs.metadata();
+    const md = fs.usage();
     const bs = md.blockSize || 4096;
     return {
-        type: (bigint ? BigInt : Number)(md.type),
+        type: (bigint ? BigInt : Number)(fs.id),
         bsize: (bigint ? BigInt : Number)(bs),
         ffree: (bigint ? BigInt : Number)(md.freeNodes || size_max),
         files: (bigint ? BigInt : Number)(md.totalNodes || size_max),

package/dist/vfs/streams.js

@@ -1,5 +1,5 @@
 import { Readable, Writable } from 'readable-stream';
-import { Errno, ErrnoError } from '../error.js';
+import { Errno, ErrnoError } from '../internal/error.js';
 export class ReadStream extends Readable {
     close(callback = () => null) {
         try {

package/dist/vfs/sync.d.ts

@@ -1,8 +1,7 @@
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
-import type { FileContents } from '../filesystem.js';
 import type { Stats } from '../stats.js';
-import type { InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
+import type { FileContents, InternalOptions, NullEnc, ReaddirOptions, ReaddirOptsI, ReaddirOptsU } from './types.js';
 import { Buffer } from 'buffer';
 import { BigIntStats } from '../stats.js';
 import { Dir, Dirent } from './dir.js';

package/dist/vfs/sync.js

@@ -51,9 +51,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
-import { credentials } from '../credentials.js';
-import { Errno, ErrnoError } from '../error.js';
-import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../file.js';
+import { credentials } from '../internal/credentials.js';
+import { Errno, ErrnoError } from '../internal/error.js';
+import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.js';
 import { BigIntStats } from '../stats.js';
 import { decodeUTF8, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as cache from './cache.js';
@@ -74,13 +74,13 @@ export function renameSync(oldPath, newPath) {
     try {
         if (oldMount === newMount) {
             oldMount.fs.renameSync(oldMount.path, newMount.path);
-            emitChange('rename', oldPath.toString());
-            emitChange('change', newPath.toString());
+            emitChange(this, 'rename', oldPath.toString());
+            emitChange(this, 'change', newPath.toString());
             return;
         }
         writeFileSync.call(this, newPath, readFileSync(oldPath));
         unlinkSync.call(this, oldPath);
-        emitChange('rename', oldPath.toString());
+        emitChange(this, 'rename', oldPath.toString());
     }
     catch (e) {
         throw fixError(e, { [oldMount.path]: oldPath, [newMount.path]: newPath });
@@ -158,7 +158,7 @@ export function unlinkSync(path) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
-        emitChange('rename', path.toString());
+        emitChange(this, 'rename', path.toString());
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -169,8 +169,7 @@ unlinkSync;
  * Manually apply setuid/setgid.
  */
 function applySetId(file, uid, gid) {
-    var _a;
-    if ((_a = file.fs.metadata().features) === null || _a === void 0 ? void 0 : _a.includes('setid'))
+    if (file.fs.attributes.has('setid'))
         return;
     const parent = file.fs.statSync(dirname(file.path));
     file.chownSync(parent.mode & constants.S_ISUID ? parent.uid : uid, // manually apply setuid/setgid
@@ -287,7 +286,7 @@ export function writeFileSync(path, data, _options = {}) {
             preserveSymlinks: true,
         }), false);
         file.writeSync(encodedData, 0, encodedData.byteLength, 0);
-        emitChange('change', path.toString());
+        emitChange(this, 'change', path.toString());
     }
     catch (e_3) {
         env_3.error = e_3;
@@ -378,7 +377,7 @@ export function writeSync(fd, data, posOrOff, lenOrEnc, pos) {
     const file = fd2file(fd);
     position !== null && position !== void 0 ? position : (position = file.position);
     const bytesWritten = file.writeSync(buffer, offset, length, position);
-    emitChange('change', file.path);
+    emitChange(this, 'change', file.path);
     return bytesWritten;
 }
 writeSync;
@@ -435,7 +434,7 @@ export function rmdirSync(path) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
         }
         fs.rmdirSync(resolved);
-        emitChange('rename', path.toString());
+        emitChange(this, 'rename', path.toString());
     }
     catch (e) {
         throw fixError(e, { [resolved]: path });
@@ -470,7 +469,7 @@ export function mkdirSync(path, options) {
             }
             fs.mkdirSync(dir, mode, { uid, gid });
             applySetId(fs.openFileSync(dir, 'r+'), uid, gid);
-            emitChange('rename', dir);
+            emitChange(this, 'rename', dir);
         }
         return root.length == 1 ? dirs[0] : (_b = dirs[0]) === null || _b === void 0 ? void 0 : _b.slice(root.length);
     }
@@ -747,7 +746,7 @@ export function copyFileSync(source, destination, flags) {
         throw new ErrnoError(Errno.EEXIST, 'Destination file already exists.', destination, 'copyFile');
     }
     writeFileSync.call(this, destination, readFileSync(source));
-    emitChange('rename', destination.toString());
+    emitChange(this, 'rename', destination.toString());
 }
 copyFileSync;
 /**
@@ -868,7 +867,7 @@ export function globSync(pattern, options = {}) {
             if (exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**
-             * @todo it the pattern.source check correct?
+             * @todo is the pattern.source check correct?
              */
             if (statSync(fullPath).isDirectory() && regexPatterns.some(pattern => pattern.source.includes('.*'))) {
                 recursiveList(fullPath);

package/dist/vfs/types.d.ts

@@ -1,4 +1,5 @@
 import type * as fs from 'node:fs';
+export type FileContents = ArrayBufferView | string;
 /**
  * Options used for caching, among other things.
  * @internal @hidden *UNSTABLE*