@zenfs/core 2.3.2 → 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.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 } 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';
@@ -540,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);
@@ -753,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 }));
@@ -779,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));
@@ -789,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;
@@ -1238,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.2",
+	"version": "2.3.3",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/scripts/test.js

@@ -212,7 +212,7 @@ 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}` : '',

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);