@zenfs/core 2.3.1 → 2.3.3

package/dist/backends/single_buffer.js

@@ -102,7 +102,7 @@ const { format } = new Intl.NumberFormat('en-US', {
 });
 let MetadataEntry = (() => {
     var _a, _b, _c, _d;
-    let _classDecorators = [struct(packed)];
+    let _classDecorators = [struct(packed, { name: 'MetadataEntry' })];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;

package/dist/internal/inode.js

@@ -49,7 +49,7 @@ export const rootIno = 0;
 const maxDynamicData = 3968;
 let Attribute = (() => {
     var _a, _b;
-    let _classDecorators = [struct(packed)];
+    let _classDecorators = [struct(packed, { name: 'Attribute' })];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;

package/dist/vfs/dir.d.ts

@@ -2,13 +2,56 @@ import type { Dir as _Dir, Dirent as _Dirent } from 'node:fs';
 import type { V_Context } from '../context.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { Callback } from '../utils.js';
-export declare class Dirent<Name extends string | Buffer = string> implements _Dirent<Name> {
-    path: string;
-    protected stats: InodeLike;
-    protected readonly encoding?: (BufferEncoding | "buffer" | null) | undefined;
+import { Buffer } from 'buffer';
+import { BufferView } from 'utilium/buffer.js';
+/**
+ * @see `DT_*` in `dirent.h`
+ */
+export declare enum DirType {
+    UNKNOWN = 0,
+    FIFO = 1,
+    CHR = 2,
+    DIR = 4,
+    BLK = 6,
+    REG = 8,
+    LNK = 10,
+    SOCK = 12,
+    WHT = 14
+}
+/**
+ * Converts a file mode to a directory type.
+ * @see `IFTODT` in `dirent.h`
+ */
+export declare function ifToDt(mode: number): DirType;
+/**
+ * Converts a directory type to a file mode.
+ * @see `DTTOIF` in `dirent.h`
+ */
+export declare function dtToIf(dt: DirType): number;
+export declare class Dirent<Name extends string | Buffer = string, TArrayBuffer extends ArrayBufferLike = ArrayBufferLike> extends BufferView<TArrayBuffer> implements _Dirent<Name> {
+    protected accessor ino: number;
+    /** Reserved for 64-bit inodes */
+    private accessor _ino;
+    protected accessor type: DirType;
+    protected accessor _name: Uint8Array;
     get name(): Name;
-    constructor(path: string, stats: InodeLike, encoding?: (BufferEncoding | "buffer" | null) | undefined);
+    /**
+     * @internal @protected
+     */
+    _encoding?: BufferEncoding | 'buffer' | null;
+    /**
+     * @internal @protected
+     */
+    _parentPath: string;
     get parentPath(): string;
+    /**
+     * @deprecated Removed in Node v24, use `parentPath` instead.
+     */
+    get path(): string;
+    /**
+     * @internal
+     */
+    static from(path: string, stats: InodeLike, encoding?: BufferEncoding | 'buffer' | null): Dirent;
     isFile(): boolean;
     isDirectory(): boolean;
     isBlockDevice(): boolean;

package/dist/vfs/dir.js

@@ -1,46 +1,184 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Buffer } from 'buffer';
 import { withErrno } from 'kerium';
-import { isBlockDevice, isCharacterDevice, isDirectory, isFIFO, isFile, isSocket, isSymbolicLink } from '../internal/inode.js';
-import { basename } from '../path.js';
+import { packed, sizeof, struct, types as t } from 'memium';
+import { warn } from 'kerium/log';
+import { encodeUTF8 } from 'utilium';
+import { BufferView } from 'utilium/buffer.js';
+import { basename, dirname } from '../path.js';
 import { readdir } from './promises.js';
 import { readdirSync } from './sync.js';
-export class Dirent {
-    path;
-    stats;
-    encoding;
-    get name() {
-        const name = Buffer.from(basename(this.path));
-        return (this.encoding == 'buffer' ? name : name.toString(this.encoding));
-    }
-    constructor(path, stats, encoding) {
-        this.path = path;
-        this.stats = stats;
-        this.encoding = encoding;
-    }
-    get parentPath() {
-        return this.path;
-    }
-    isFile() {
-        return isFile(this.stats);
-    }
-    isDirectory() {
-        return isDirectory(this.stats);
-    }
-    isBlockDevice() {
-        return isBlockDevice(this.stats);
-    }
-    isCharacterDevice() {
-        return isCharacterDevice(this.stats);
-    }
-    isSymbolicLink() {
-        return isSymbolicLink(this.stats);
-    }
-    isFIFO() {
-        return isFIFO(this.stats);
-    }
-    isSocket() {
-        return isSocket(this.stats);
-    }
+/**
+ * @see `DT_*` in `dirent.h`
+ */
+export var DirType;
+(function (DirType) {
+    DirType[DirType["UNKNOWN"] = 0] = "UNKNOWN";
+    DirType[DirType["FIFO"] = 1] = "FIFO";
+    DirType[DirType["CHR"] = 2] = "CHR";
+    DirType[DirType["DIR"] = 4] = "DIR";
+    DirType[DirType["BLK"] = 6] = "BLK";
+    DirType[DirType["REG"] = 8] = "REG";
+    DirType[DirType["LNK"] = 10] = "LNK";
+    DirType[DirType["SOCK"] = 12] = "SOCK";
+    DirType[DirType["WHT"] = 14] = "WHT";
+})(DirType || (DirType = {}));
+/**
+ * Converts a file mode to a directory type.
+ * @see `IFTODT` in `dirent.h`
+ */
+export function ifToDt(mode) {
+    return ((mode & 0o170000) >> 12);
+}
+/**
+ * Converts a directory type to a file mode.
+ * @see `DTTOIF` in `dirent.h`
+ */
+export function dtToIf(dt) {
+    return dt << 12;
 }
+let Dirent = (() => {
+    var _a, _b, _c;
+    let _classDecorators = [struct(packed, { name: 'Dirent' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = BufferView;
+    let _ino_decorators;
+    let _ino_initializers = [];
+    let _ino_extraInitializers = [];
+    let __ino_decorators;
+    let __ino_initializers = [];
+    let __ino_extraInitializers = [];
+    let _type_decorators;
+    let _type_initializers = [];
+    let _type_extraInitializers = [];
+    let __name_decorators;
+    let __name_initializers = [];
+    let __name_extraInitializers = [];
+    var Dirent = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _ino_decorators = [(_a = t).uint32.bind(_a)];
+            __ino_decorators = [(_b = t).uint32.bind(_b)];
+            _type_decorators = [(_c = t).uint8.bind(_c)];
+            __name_decorators = [t.char(256)];
+            __esDecorate(this, null, _ino_decorators, { kind: "accessor", name: "ino", static: false, private: false, access: { has: obj => "ino" in obj, get: obj => obj.ino, set: (obj, value) => { obj.ino = value; } }, metadata: _metadata }, _ino_initializers, _ino_extraInitializers);
+            __esDecorate(this, null, __ino_decorators, { kind: "accessor", name: "_ino", static: false, private: false, access: { has: obj => "_ino" in obj, get: obj => obj._ino, set: (obj, value) => { obj._ino = value; } }, metadata: _metadata }, __ino_initializers, __ino_extraInitializers);
+            __esDecorate(this, null, _type_decorators, { kind: "accessor", name: "type", static: false, private: false, access: { has: obj => "type" in obj, get: obj => obj.type, set: (obj, value) => { obj.type = value; } }, metadata: _metadata }, _type_initializers, _type_extraInitializers);
+            __esDecorate(this, null, __name_decorators, { kind: "accessor", name: "_name", static: false, private: false, access: { has: obj => "_name" in obj, get: obj => obj._name, set: (obj, value) => { obj._name = value; } }, metadata: _metadata }, __name_initializers, __name_extraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Dirent = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #ino_accessor_storage = __runInitializers(this, _ino_initializers, void 0);
+        get ino() { return this.#ino_accessor_storage; }
+        set ino(value) { this.#ino_accessor_storage = value; }
+        #_ino_accessor_storage = (__runInitializers(this, _ino_extraInitializers), __runInitializers(this, __ino_initializers, void 0));
+        /** Reserved for 64-bit inodes */
+        get _ino() { return this.#_ino_accessor_storage; }
+        set _ino(value) { this.#_ino_accessor_storage = value; }
+        #type_accessor_storage = (__runInitializers(this, __ino_extraInitializers), __runInitializers(this, _type_initializers, void 0));
+        get type() { return this.#type_accessor_storage; }
+        set type(value) { this.#type_accessor_storage = value; }
+        #_name_accessor_storage = (__runInitializers(this, _type_extraInitializers), __runInitializers(this, __name_initializers, void 0));
+        get _name() { return this.#_name_accessor_storage; }
+        set _name(value) { this.#_name_accessor_storage = value; }
+        get name() {
+            const end = (this._name.indexOf(0) + 1 || 256) - 1;
+            const name = Buffer.from(this._name.subarray(0, end));
+            return (this._encoding == 'buffer' ? name : name.toString(this._encoding));
+        }
+        /**
+         * @internal @protected
+         */
+        _encoding = __runInitializers(this, __name_extraInitializers);
+        /**
+         * @internal @protected
+         */
+        _parentPath;
+        get parentPath() {
+            return this._parentPath;
+        }
+        /**
+         * @deprecated Removed in Node v24, use `parentPath` instead.
+         */
+        get path() {
+            warn('Dirent.path was removed in Node v24, use parentPath instead');
+            return this._parentPath;
+        }
+        /**
+         * @internal
+         */
+        static from(path, stats, encoding) {
+            const dirent = new Dirent(new ArrayBuffer(sizeof(Dirent) + 1));
+            dirent._parentPath = dirname(path);
+            dirent._name = encodeUTF8(basename(path));
+            dirent.ino = stats.ino;
+            dirent.type = ifToDt(stats.mode);
+            dirent._encoding = encoding;
+            return dirent;
+        }
+        isFile() {
+            return this.type === DirType.REG;
+        }
+        isDirectory() {
+            return this.type === DirType.DIR;
+        }
+        isBlockDevice() {
+            return this.type === DirType.BLK;
+        }
+        isCharacterDevice() {
+            return this.type === DirType.CHR;
+        }
+        isSymbolicLink() {
+            return this.type === DirType.LNK;
+        }
+        isFIFO() {
+            return this.type === DirType.FIFO;
+        }
+        isSocket() {
+            return this.type === DirType.SOCK;
+        }
+    };
+    return Dirent = _classThis;
+})();
+export { Dirent };
 /**
  * A class representing a directory stream.
  */

package/dist/vfs/ioctl.js

@@ -87,7 +87,7 @@ var XFlag;
 })(XFlag || (XFlag = {}));
 let fsxattr = (() => {
     var _a, _b, _c, _d, _e;
-    let _classDecorators = [struct()];
+    let _classDecorators = [struct({ name: 'fsxattr' })];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;

package/dist/vfs/promises.d.ts

@@ -11,6 +11,7 @@ import type { FileContents, ReaddirOptions } from './types.js';
 import { Buffer } from 'buffer';
 import '../polyfills.js';
 import { Dir, Dirent } from './dir.js';
+import { SyncHandle } from './file.js';
 import { BigIntStats, Stats } from './stats.js';
 import { ReadStream, WriteStream } from './streams.js';
 export * as constants from './constants.js';
@@ -18,10 +19,6 @@ export declare class FileHandle implements promises.FileHandle {
     protected context: V_Context;
     readonly fd: number;
     protected _buffer?: Uint8Array;
-    /**
-     * Current position
-     */
-    protected _position: number;
     /**
      * Get the current file position.
      *
@@ -42,15 +39,16 @@ export declare class FileHandle implements promises.FileHandle {
      */
     protected closed: boolean;
     /** The path relative to the context's root */
-    readonly path: string;
+    get path(): string;
     /** The internal FS associated with the handle */
-    protected readonly fs: FileSystem;
+    protected get fs(): FileSystem;
     /** The path relative to the `FileSystem`'s root */
-    readonly internalPath: string;
+    get internalPath(): string;
     /** The flag the handle was opened with */
-    readonly flag: number;
+    get flag(): number;
     /** Stats for the handle */
-    readonly inode: InodeLike;
+    get inode(): InodeLike;
+    protected _sync: SyncHandle;
     constructor(context: V_Context, fd: number);
     private get _isSync();
     private _emitChange;

package/dist/vfs/promises.js

@@ -52,10 +52,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { Buffer } from 'buffer';
 import { Exception, rethrow, setUVMessage, UV } from 'kerium';
-import { decodeUTF8, pick } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
 import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { dirname, join, matchesGlob, parse, resolve } from '../path.js';
+import { basename, dirname, join, matchesGlob, parse, resolve } from '../path.js';
 import '../polyfills.js';
 import { createInterface } from '../readline.js';
 import { __assertType, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
@@ -73,10 +72,6 @@ export class FileHandle {
     context;
     fd;
     _buffer;
-    /**
-     * Current position
-     */
-    _position = 0;
     /**
      * Get the current file position.
      *
@@ -87,10 +82,10 @@ export class FileHandle {
      * @returns The current file position.
      */
     get position() {
-        return this.flag & constants.O_APPEND ? this.inode.size : this._position;
+        return this._sync.position;
     }
     set position(value) {
-        this._position = value;
+        this._sync.position = value;
     }
     /**
      * Whether the file has changes which have not been written to the FS
@@ -101,20 +96,30 @@ export class FileHandle {
      */
     closed = false;
     /** The path relative to the context's root */
-    path;
+    get path() {
+        return this._sync.path;
+    }
     /** The internal FS associated with the handle */
-    fs;
+    get fs() {
+        return this._sync.fs;
+    }
     /** The path relative to the `FileSystem`'s root */
-    internalPath;
+    get internalPath() {
+        return this._sync.internalPath;
+    }
     /** The flag the handle was opened with */
-    flag;
+    get flag() {
+        return this._sync.flag;
+    }
     /** Stats for the handle */
-    inode;
+    get inode() {
+        return this._sync.inode;
+    }
+    _sync;
     constructor(context, fd) {
         this.context = context;
         this.fd = fd;
-        const sync = fromFD(context, fd);
-        Object.assign(this, pick(sync, 'path', 'fs', 'internalPath', 'flag', 'inode'));
+        this._sync = fromFD(context, fd);
     }
     get _isSync() {
         return !!(this.flag & constants.O_SYNC || this.inode.flags & InodeFlags.Sync);
@@ -246,7 +251,7 @@ export class FileHandle {
         if (!isCharacterDevice(this.inode) && !isBlockDevice(this.inode) && end > this.inode.size) {
             end = position + Math.max(this.inode.size - position, 0);
         }
-        this._position = end;
+        this._sync.position = end;
         const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
         await this.fs.read(this.internalPath, uint8.subarray(offset, offset + length), position, end);
         if (this._isSync)
@@ -348,7 +353,7 @@ export class FileHandle {
             this.inode.size = end;
         this.inode.mtimeMs = Date.now();
         this.inode.ctimeMs = Date.now();
-        this._position = position + slice.byteLength;
+        this._sync.position = position + slice.byteLength;
         await this.fs.write(this.internalPath, slice, position);
         if (this._isSync)
             await this.sync();
@@ -534,8 +539,9 @@ export async function stat(path, options) {
 stat;
 export async function lstat(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path, this);
     const $ex = { syscall: 'lstat', path };
+    path = join(await realpath.call(this, dirname(path)), basename(path));
+    const { fs, path: resolved } = resolveMount(path, this);
     const stats = await fs.stat(resolved).catch(rethrow($ex));
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
         throw UV('EACCES', $ex);
@@ -747,9 +753,9 @@ export async function mkdir(path, options) {
     return dirs[0][0];
 }
 mkdir;
-export async function readdir(path, options) {
+export async function readdir(_path, options) {
     const opt = typeof options === 'object' && options != null ? options : { encoding: options, withFileTypes: false, recursive: false };
-    path = await realpath.call(this, path);
+    const path = await realpath.call(this, _path);
     const { fs, path: resolved } = resolveMount(path, this);
     const $ex = { syscall: 'readdir', path };
     const stats = await fs.stat(resolved).catch(rethrow({ syscall: 'stat', path }));
@@ -773,7 +779,7 @@ export async function readdir(path, options) {
                 return;
         }
         if (opt.withFileTypes) {
-            values.push(new Dirent(entry, entryStats, opt.encoding));
+            values.push(Dirent.from(join(_path.toString(), entry), entryStats, opt.encoding));
         }
         else if (opt.encoding == 'buffer') {
             values.push(Buffer.from(entry));
@@ -783,19 +789,9 @@ export async function readdir(path, options) {
         }
         if (!opt.recursive || !isDirectory(entryStats))
             return;
-        for (const subEntry of await readdir.call(this, join(path, entry), opt)) {
-            if (subEntry instanceof Dirent) {
-                subEntry.path = join(entry, subEntry.path);
-                values.push(subEntry);
-            }
-            else if (Buffer.isBuffer(subEntry)) {
-                // Convert Buffer to string, prefix with the full path
-                values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
-            }
-            else {
-                values.push(join(entry, subEntry));
-            }
-        }
+        const children = await fs.readdir(join(resolved, entry)).catch(rethrow({ syscall: 'readdir', path: join(path, entry) }));
+        for (const child of children)
+            await addEntry(join(entry, child));
     };
     await Promise.all(entries.map(addEntry));
     return values;
@@ -1232,7 +1228,7 @@ export function glob(pattern, opt) {
     async function* recursiveList(dir) {
         const entries = await readdir(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
-            const fullPath = withFileTypes ? entry.path : dir + '/' + entry;
+            const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + '/' + entry;
             if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**

package/dist/vfs/sync.js

@@ -52,11 +52,11 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { Buffer } from 'buffer';
 import { Errno, Exception, setUVMessage, UV } from 'kerium';
-import { decodeUTF8, encodeUTF8 } from 'utilium';
+import { encodeUTF8 } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
 import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { dirname, join, matchesGlob, parse, resolve } from '../path.js';
+import { basename, dirname, join, matchesGlob, parse, resolve } from '../path.js';
 import { __assertType, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from './config.js';
 import * as constants from './constants.js';
@@ -139,7 +139,8 @@ export function statSync(path, options) {
 statSync;
 export function lstatSync(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(path, this);
+    const real = join(realpathSync.call(this, dirname(path)), basename(path));
+    const { fs, path: resolved } = resolveMount(real, this);
     const stats = wrap(fs, 'statSync', path)(resolved);
     if (checkAccess && !hasAccess(this, stats, constants.R_OK))
         throw UV('EACCES', { syscall: 'lstat', path });
@@ -485,16 +486,18 @@ export function readdirSync(path, options) {
     const entries = wrap(fs, 'readdirSync', path)(resolved);
     // Iterate over entries and handle recursive case if needed
     const values = [];
-    for (const entry of entries) {
+    const addEntry = (entry) => {
         let entryStat;
         try {
             entryStat = fs.statSync(join(resolved, entry));
         }
-        catch {
-            continue;
+        catch (e) {
+            if (e.code == 'ENOENT')
+                return;
+            throw setUVMessage(Object.assign(e, { syscall: 'stat', path: join(path, entry) }));
         }
         if (options?.withFileTypes) {
-            values.push(new Dirent(entry, entryStat, options.encoding));
+            values.push(Dirent.from(entry, entryStat, options.encoding));
         }
         else if (options?.encoding == 'buffer') {
             values.push(Buffer.from(entry));
@@ -503,20 +506,13 @@ export function readdirSync(path, options) {
             values.push(entry);
         }
         if (!isDirectory(entryStat) || !options?.recursive)
-            continue;
-        for (const subEntry of readdirSync.call(this, join(path, entry), options)) {
-            if (subEntry instanceof Dirent) {
-                subEntry.path = join(entry, subEntry.path);
-                values.push(subEntry);
-            }
-            else if (Buffer.isBuffer(subEntry)) {
-                values.push(Buffer.from(join(entry, decodeUTF8(subEntry))));
-            }
-            else {
-                values.push(join(entry, subEntry));
-            }
-        }
-    }
+            return;
+        const children = wrap(fs, 'readdirSync', join(path, entry))(join(resolved, entry));
+        for (const child of children)
+            addEntry(join(entry, child));
+    };
+    for (const entry of entries)
+        addEntry(entry);
     return values;
 }
 readdirSync;
@@ -862,7 +858,7 @@ export function globSync(pattern, options = {}) {
     function recursiveList(dir) {
         const entries = readdirSync(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
-            const fullPath = withFileTypes ? entry.path : dir + '/' + entry;
+            const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + '/' + entry;
             if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**
@@ -872,7 +868,7 @@ export function globSync(pattern, options = {}) {
                 recursiveList(fullPath);
             }
             if (regexPatterns.some(pattern => pattern.test(fullPath.replace(/^\/+/g, '')))) {
-                results.push(withFileTypes ? entry.path : fullPath.replace(/^\/+/g, ''));
+                results.push(withFileTypes ? entry : fullPath.replace(/^\/+/g, ''));
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.3.1",
+	"version": "2.3.3",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/scripts/test.js

@@ -40,13 +40,14 @@ if (options.help) {
 Paths: The setup files to run tests on
 
 Behavior:
-    -a, --auto          Automatically detect setup files
-    -b, --build         Run the npm build script prior to running tests
-    -c, --common        Also run tests not specific to any backend
-    -e, --exit-on-fail  If any tests suites fail, exit immediately
-    -t, --test <glob>   Which FS test suite(s) to run
-    -f, --force         Whether to use --test-force-exit
-    -I, --inspect       Use the inspector for debugging
+    -a, --auto            Automatically detect setup files
+    -b, --build           Run the npm build script prior to running tests
+    -c, --common          Also run tests not specific to any backend
+    -e, --exit-on-fail    If any tests suites fail, exit immediately
+    -t, --test <glob>     Which FS test suite(s) to run
+    -f, --force           Whether to use --test-force-exit
+    -I, --inspect         Use the inspector for debugging
+	-s, --skip <pattern>  Skip tests with names matching the given pattern.
 
 Output:
     -h, --help          Outputs this help message
@@ -211,11 +212,11 @@ for (const setupFile of positionals) {
 		execSync(
 			[
 				'tsx --trace-deprecation',
-				options.inspect ? 'inspect' : '',
+				options.inspect ? '--inspect' : '',
 				'--test --experimental-test-coverage',
 				options.force ? '--test-force-exit' : '',
 				options.skip ? `--test-skip-pattern=${options.skip}` : '',
-				testsGlob,
+				`'${testsGlob.replaceAll("'", "\\'")}'`,
 				process.env.CMD,
 			].join(' '),
 			{

package/tests/fs/dir.test.ts

@@ -16,15 +16,15 @@ for (const file of testFiles) {
 suite('Dirent', () => {
 	test('name and parentPath getters', async () => {
 		const stats = await fs.promises.lstat(testFile);
-		const dirent = new fs.Dirent(testFile, stats);
+		const dirent = fs.Dirent.from(testFile, stats);
 
 		assert.equal(dirent.name, testFile);
-		assert.equal(dirent.parentPath, testFile);
+		assert.equal(dirent.parentPath, '.');
 	});
 
 	test('isFile', async () => {
 		const fileStats = await fs.promises.lstat(testFile);
-		const fileDirent = new fs.Dirent(testFile, fileStats);
+		const fileDirent = fs.Dirent.from(testFile, fileStats);
 
 		assert(fileDirent.isFile());
 		assert(!fileDirent.isDirectory());
@@ -32,7 +32,7 @@ suite('Dirent', () => {
 
 	test('isDirectory', async () => {
 		const dirStats = await fs.promises.lstat('test-directory');
-		const dirDirent = new fs.Dirent('test-directory', dirStats);
+		const dirDirent = fs.Dirent.from('test-directory', dirStats);
 
 		assert(!dirDirent.isFile());
 		assert(dirDirent.isDirectory());
@@ -40,14 +40,14 @@ suite('Dirent', () => {
 
 	test('isSymbolicLink', async () => {
 		const symlinkStats = await fs.promises.lstat('test-symlink');
-		const symlinkDirent = new fs.Dirent('test-symlink', symlinkStats);
+		const symlinkDirent = fs.Dirent.from('test-symlink', symlinkStats);
 
 		assert(symlinkDirent.isSymbolicLink());
 	});
 
 	test('other methods return false', async () => {
 		const fileStats = await fs.promises.lstat(testFile);
-		const fileDirent = new fs.Dirent(testFile, fileStats);
+		const fileDirent = fs.Dirent.from(testFile, fileStats);
 
 		assert(!fileDirent.isBlockDevice());
 		assert(!fileDirent.isCharacterDevice());

package/tests/fs/directory.test.ts

@@ -1,4 +1,5 @@
 import assert from 'node:assert/strict';
+import { join } from 'node:path/posix';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
 
@@ -143,10 +144,12 @@ suite('Directories', () => {
 
 	test('readdir returns Dirent recursively', async () => {
 		const entries = await fs.promises.readdir(testDir, { recursive: true, withFileTypes: true });
-		const paths = entries.map(entry => entry.path).sort();
-		assert.equal(paths[0], 'file1.txt');
-		assert.equal(paths[4], 'subdir1/file4.txt');
-		assert.equal(paths[8], 'subdir2/file5.txt');
+		entries.sort((a, b) => join(a.parentPath, a.name).localeCompare(join(b.parentPath, b.name)));
+		const values = entries.map(entry => [entry.parentPath, entry.name]);
+
+		assert.deepEqual(values[0], [testDir, 'file1.txt']);
+		assert.deepEqual(values[4], [join(testDir, 'subdir1'), 'file4.txt']);
+		assert.deepEqual(values[8], [join(testDir, 'subdir2'), 'file5.txt']);
 	});
 
 	test('readdirSync returns files recursively', () => {

package/tests/fs/links.test.ts

@@ -18,6 +18,16 @@ suite('Links', () => {
 		assert(stats.isSymbolicLink());
 	});
 
+	test('lstat file inside symlinked directory', async () => {
+		// @zenfs/core#241
+		await fs.promises.mkdir('/a');
+		await fs.promises.writeFile('/a/hello.txt', 'hello world');
+		await fs.promises.symlink('/a', '/b');
+
+		const stat = await fs.promises.lstat('/b/hello.txt');
+		assert(stat.isFile());
+	});
+
 	test('readlink', async () => {
 		const destination = await fs.promises.readlink(symlink);
 		assert.equal(destination, target);

package/tests/fs/read.test.ts

@@ -1,7 +1,9 @@
 import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
+import type { OpenMode, PathLike } from 'node:fs';
 import { suite, test } from 'node:test';
-import { fs } from '../common.js';
+import { promisify } from 'node:util';
+import { fs, type Callback } from '../common.js';
 
 const filepath = 'x.txt';
 const expected = 'xyz\n';
@@ -65,4 +67,25 @@ suite('read', () => {
 		assert.equal(buffer.subarray(10, buffer.length).toString(), expected);
 		assert.equal(bytesRead, expected.length);
 	});
+
+	test('read using callback API', async () => {
+		// @zenfs/core#239
+		const path = '/text.txt';
+
+		fs.writeFileSync(path, 'hello world');
+		const fd: number = (await promisify<PathLike, OpenMode, number | string>(fs.open)(path, 0, 0)) as any;
+
+		const read = promisify(fs.read);
+
+		const buf = Buffer.alloc(1024);
+		const n0 = await read(fd, buf, 0, 1024, undefined);
+		assert.equal(n0, 11);
+		assert.equal(buf.subarray(0, n0).toString('utf8'), 'hello world');
+
+		const n1 = await read(fd, buf, 0, 1024, undefined);
+		assert.equal(n1, 0);
+		assert.equal(buf.subarray(0, n1).toString('utf8'), '');
+
+		await promisify(fs.close)(fd);
+	});
 });