@zenfs/core 2.6.1 → 2.6.3

package/dist/backends/cow.d.ts

@@ -46,6 +46,7 @@ export declare class Journal extends EventEmitter<{
     fromString(value: string): this;
     add(op: JournalOperation, path: string): void;
     has(op: JournalOperation, path: string): boolean;
+    delete(op: JournalOperation, path: string): void;
     isDeleted(path: string): boolean;
 }
 /**

package/dist/backends/cow.js

@@ -53,6 +53,9 @@ export class Journal extends EventEmitter {
                 return true;
         return false;
     }
+    delete(op, path) {
+        this.entries = this.entries.filter(entry => entry.op != op || entry.path != path);
+    }
     isDeleted(path) {
         let deleted = false;
         for (const entry of this.entries) {
@@ -168,6 +171,9 @@ export class CopyOnWriteFS extends FileSystem {
             if (this.isDeleted(oldPath))
                 throw withErrno('ENOENT');
         }
+        if (await this.readable.exists(oldPath))
+            this.journal.add('delete', oldPath);
+        this.journal.delete('delete', newPath);
         this.renameInos(oldPath, newPath);
     }
     renameSync(oldPath, newPath) {
@@ -179,6 +185,9 @@ export class CopyOnWriteFS extends FileSystem {
             if (this.isDeleted(oldPath))
                 throw withErrno('ENOENT');
         }
+        if (this.readable.existsSync(oldPath))
+            this.journal.add('delete', oldPath);
+        this.journal.delete('delete', newPath);
         this.renameInos(oldPath, newPath);
     }
     async stat(path) {
@@ -211,19 +220,25 @@ export class CopyOnWriteFS extends FileSystem {
     }
     async createFile(path, options) {
         await this.createParentDirectories(path);
-        return this.remapIno(path, await this.writable.createFile(path, options));
+        const inode = await this.writable.createFile(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     createFileSync(path, options) {
         this.createParentDirectoriesSync(path);
-        return this.remapIno(path, this.writable.createFileSync(path, options));
+        const inode = this.writable.createFileSync(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     async link(srcpath, dstpath) {
         await this.copyForWrite(srcpath);
         await this.writable.link(srcpath, dstpath);
+        this.journal.delete('delete', dstpath);
     }
     linkSync(srcpath, dstpath) {
         this.copyForWriteSync(srcpath);
         this.writable.linkSync(srcpath, dstpath);
+        this.journal.delete('delete', dstpath);
     }
     async unlink(path) {
         if (!(await this.exists(path)))
@@ -285,19 +300,27 @@ export class CopyOnWriteFS extends FileSystem {
         if (await this.exists(path))
             throw withErrno('EEXIST');
         await this.createParentDirectories(path);
-        return this.remapIno(path, await this.writable.mkdir(path, options));
+        const inode = await this.writable.mkdir(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     mkdirSync(path, options) {
         if (this.existsSync(path))
             throw withErrno('EEXIST');
         this.createParentDirectoriesSync(path);
-        return this.remapIno(path, this.writable.mkdirSync(path, options));
+        const inode = this.writable.mkdirSync(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     async readdir(path) {
-        if (this.isDeleted(path) || !(await this.exists(path)))
+        if (this.isDeleted(path))
+            throw withErrno('ENOENT');
+        const readable = await this.readable.stat(path).catch(() => null);
+        const writable = await this.writable.stat(path).catch(() => null);
+        if (!readable && !writable)
             throw withErrno('ENOENT');
-        const entries = (await this.readable.exists(path)) ? await this.readable.readdir(path) : [];
-        if (await this.writable.exists(path))
+        const entries = readable && isDirectory(readable) ? await this.readable.readdir(path) : [];
+        if (writable && isDirectory(writable))
             for (const entry of await this.writable.readdir(path)) {
                 if (!entries.includes(entry))
                     entries.push(entry);
@@ -305,10 +328,26 @@ export class CopyOnWriteFS extends FileSystem {
         return entries.filter(entry => !this.isDeleted(join(path, entry)));
     }
     readdirSync(path) {
-        if (this.isDeleted(path) || !this.existsSync(path))
+        if (this.isDeleted(path))
+            throw withErrno('ENOENT');
+        let readable = null;
+        let writable = null;
+        try {
+            readable = this.readable.statSync(path);
+        }
+        catch {
+            // Not on the readable layer
+        }
+        try {
+            writable = this.writable.statSync(path);
+        }
+        catch {
+            // Not on the writable layer
+        }
+        if (!readable && !writable)
             throw withErrno('ENOENT');
-        const entries = this.readable.existsSync(path) ? this.readable.readdirSync(path) : [];
-        if (this.writable.existsSync(path))
+        const entries = readable && isDirectory(readable) ? this.readable.readdirSync(path) : [];
+        if (writable && isDirectory(writable))
             for (const entry of this.writable.readdirSync(path)) {
                 if (!entries.includes(entry))
                     entries.push(entry);

package/dist/backends/single_buffer.js

@@ -320,7 +320,7 @@ const sb_magic = 0x62732e7a; // 'z.sb'
  * Shortcut for minor perf. bump
  * @internal
  */
-const usedBytes = 2;
+const kUsedBytes = 2;
 /**
  * The super block structure for a single-buffer file system
  */
@@ -502,16 +502,34 @@ let SuperBlock = (() => {
          * @returns the new metadata block
          */
         rotateMetadata() {
-            const padding = this.used_bytes % BigInt(4);
-            Atomics.add(this, usedBytes, padding);
-            const offset = Number(Atomics.add(this, usedBytes, BigInt(sizeof(MetadataBlock))));
-            const metadata = new MetadataBlock(this.buffer, offset);
-            metadata.previous_offset = this.metadata_offset;
+            const alignment = BigInt(Int32Array.BYTES_PER_ELEMENT), blockSize = BigInt(sizeof(MetadataBlock));
+            let used = Atomics.load(this, kUsedBytes), offset;
+            // Padding and block space must be reserved together because other writers can advance used_bytes at any time.
+            for (;;) {
+                const padding = (alignment - (used % alignment)) % alignment;
+                offset = used + padding;
+                const next = offset + blockSize;
+                if (next > this.total_bytes)
+                    throw err(withErrno('ENOSPC', 'sbfs: not enough space for a new metadata block'));
+                const observed = Atomics.compareExchange(this, kUsedBytes, used, next);
+                if (observed === used)
+                    break;
+                used = observed;
+            }
+            const metadata = new MetadataBlock(this.buffer, Number(offset));
+            const offsets = new Uint32Array(this.buffer, this.byteOffset, sizeof(SuperBlock) / Uint32Array.BYTES_PER_ELEMENT);
+            let previous = Atomics.load(offsets, kMetadataOffset);
+            for (;;) {
+                metadata.previous_offset = previous;
+                _update(metadata);
+                const observed = Atomics.compareExchange(offsets, kMetadataOffset, previous, metadata.byteOffset);
+                if (observed === previous)
+                    break;
+                previous = observed;
+            }
             this.metadata = metadata;
-            this.metadata_offset = metadata.byteOffset;
-            _update(metadata);
             _update(this);
-            debug(`sbfs: rotated metadata block at ${hex(metadata.previous_offset)} with new block at ${hex(offset)}`);
+            debug(`sbfs: rotated metadata block at ${hex(metadata.previous_offset)} with new block at ${hex(metadata.byteOffset)}`);
             return metadata;
         }
         /**
@@ -545,6 +563,11 @@ let SuperBlock = (() => {
     return SuperBlock = _classThis;
 })();
 export { SuperBlock };
+/**
+ * Index of `SuperBlock.metadata_offset` in a `Uint32Array` view of the super block.
+ * @internal
+ */
+const kMetadataOffset = offsetof(SuperBlock, 'metadata_offset') / Uint32Array.BYTES_PER_ELEMENT;
 /**
  * Compute the checksum for a super block or metadata block.
  * Note we don't include the checksum when computing a new one.
@@ -635,7 +658,7 @@ export class SingleBufferStore extends BufferView {
                             _update(block);
                             return;
                         }
-                        entry.offset = Number(Atomics.add(this.superblock, usedBytes, BigInt(data.length)));
+                        entry.offset = Number(Atomics.add(this.superblock, kUsedBytes, BigInt(data.length)));
                         entry.size = data.length;
                         this._u8.set(data, entry.offset);
                         _update(block);
@@ -657,7 +680,7 @@ export class SingleBufferStore extends BufferView {
                 entry = this.superblock.metadata.items[0];
             }
             const lock = __addDisposableResource(env_1, this.superblock.metadata.lock(), false);
-            const offset = Number(Atomics.add(this.superblock, usedBytes, BigInt(data.length)));
+            const offset = Number(Atomics.add(this.superblock, kUsedBytes, BigInt(data.length)));
             entry.id = id;
             entry.offset = offset;
             entry.size = data.length;

package/dist/context.js

@@ -24,6 +24,7 @@ export function bindContext(init = {}) {
     const bound = Object.assign(ctx, {
         fs: {
             ...bindFunctions(fs, ctx),
+            Utf8Stream: fs.Utf8Stream._withContext(ctx),
             promises: bindFunctions(fs.promises, ctx),
             xattr: bindFunctions(xattr, ctx),
         },

package/dist/internal/contexts.d.ts

@@ -14,7 +14,7 @@ declare const kIsContext: unique symbol;
  * @category Contexts
  */
 export interface FSContext {
-    /** The unique ID of the context */
+    /** Brand */
     readonly [kIsContext]: boolean;
     /** The unique ID of the context */
     readonly id: number;
@@ -35,6 +35,8 @@ export interface FSContext {
     /** The child contexts */
     readonly children: FSContext[];
 }
+export declare function isContext(obj: unknown): obj is FSContext;
+export declare function assertContext(ctx: unknown): asserts ctx is FSContext;
 /**
  * maybe an FS context
  */

package/dist/internal/contexts.js

@@ -1,9 +1,18 @@
 import { createCredentials } from './credentials.js';
+import { warn } from 'kerium/log';
+import { withErrno } from 'kerium';
 /**
  * Symbol used for context branding
  * @internal @hidden
  */
 const kIsContext = Symbol('ZenFSContext');
+export function isContext(obj) {
+    return typeof obj === 'object' && obj !== null && kIsContext in obj;
+}
+export function assertContext(ctx) {
+    if (!isContext(ctx))
+        throw warn(withErrno('EINVAL', 'Invalid context provided'));
+}
 /**
  * The default/global context.
  * @internal @hidden
@@ -20,7 +29,7 @@ export const defaultContext = {
     children: [],
 };
 export function contextOf($) {
-    return typeof $ === 'object' && $ !== null && kIsContext in $ ? $ : defaultContext;
+    return isContext($) ? $ : defaultContext;
 }
 // 0 is reserved for the global/default context
 let _nextId = 1;
@@ -33,6 +42,7 @@ let _nextId = 1;
  * This exists so that `kIsContext` is not exported and to make sure the context is "secure".
  */
 export function createChildContext(parent, init = {}) {
+    assertContext(parent);
     const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials) } = init;
     const ctx = {
         [kIsContext]: true,

package/dist/internal/inode.d.ts

@@ -243,6 +243,8 @@ export declare function isFIFO(metadata: {
 export declare function hasAccess($: V_Context, inode: Pick<InodeLike, 'mode' | 'uid' | 'gid'>, access: number): boolean;
 /**
  * @hidden @internal
+ *
+ * @todo https://github.com/nodejs/node/pull/58836 support -1 for `*chown`
  */
 export declare function _chown(stats: Partial<InodeLike>, uid: number, gid: number): boolean;
 export {};

package/dist/internal/inode.js

@@ -662,6 +662,8 @@ export function hasAccess($, inode, access) {
 }
 /**
  * @hidden @internal
+ *
+ * @todo https://github.com/nodejs/node/pull/58836 support -1 for `*chown`
  */
 export function _chown(stats, uid, gid) {
     let valid = true;

package/dist/internal/rpc.d.ts

@@ -1,12 +1,12 @@
 import type { ExceptionJSON } from 'kerium';
-import type { TransferListItem } from 'node:worker_threads';
+import type { Transferable } from 'node:worker_threads';
 import type { WithOptional } from 'utilium';
 import type { Backend, FilesystemOf } from '../backends/backend.js';
 import type { PortFS } from '../backends/port.js';
 import type { CreationOptions, FileSystem, UsageInfo } from '../internal/filesystem.js';
 import '../polyfills.js';
 export interface WebMessagePort {
-    postMessage(value: unknown, transfer?: TransferListItem[]): void;
+    postMessage(value: unknown, transfer?: Transferable[]): void;
     addEventListener(type: 'message', listener: (ev: {
         data: any;
     }) => void): void;
@@ -15,7 +15,7 @@ export interface WebMessagePort {
     }) => void): void;
 }
 export interface NodeMessagePort {
-    postMessage(value: unknown, transfer?: TransferListItem[]): void;
+    postMessage(value: unknown, transfer?: Transferable[]): void;
     on(type: 'message', listener: (ev: any) => void): void;
     off(type: 'message', listener: (ev: any) => void): void;
 }
@@ -24,7 +24,7 @@ export type Channel = NodeMessagePort | WebMessagePort | WebSocket;
 export interface Port<T extends Channel = Channel> {
     readonly channel: T;
     /** Send a request */
-    send<M extends Message>(message: M, transfer?: TransferListItem[]): void;
+    send<M extends Message>(message: M, transfer?: Transferable[]): void;
     /** Add a response handler */
     addHandler<M extends Message>(handler: (message: M) => void): void;
     /** Remove a response handler */

package/dist/node/async.d.ts

@@ -22,11 +22,21 @@ export declare function exists(this: V_Context, path: fs.PathLike, cb?: (exists:
 export declare function stat(this: V_Context, path: fs.PathLike, callback: Callback<[Stats]>): void;
 export declare function stat(this: V_Context, path: fs.PathLike, options: {
     bigint?: false;
+    throwIfNoEntry?: true;
 }, callback: Callback<[Stats]>): void;
 export declare function stat(this: V_Context, path: fs.PathLike, options: {
     bigint: true;
+    throwIfNoEntry?: true;
 }, callback: Callback<[BigIntStats]>): void;
-export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats] | [BigIntStats]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: {
+    bigint?: false;
+    throwIfNoEntry: false;
+}, callback: Callback<[Stats | undefined]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: {
+    bigint: true;
+    throwIfNoEntry: false;
+}, callback: Callback<[BigIntStats | undefined]>): void;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions, callback: Callback<[Stats | BigIntStats | undefined]>): void;
 /**
  * Asynchronous `lstat`.
  * `lstat()` is identical to `stat()`, except that if path is a symbolic link,

package/dist/node/async.js

@@ -148,47 +148,26 @@ fdatasync;
 export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
     let buffer, offset, length, position, encoding;
     const handle = new promises.FileHandle(this, fd);
+    const _cb = ([cbPosOff, cbLenEnc, cbPosEnc].find(arg => typeof arg === 'function') ?? cb);
     if (typeof data === 'string') {
-        // Signature 1: (fd, string, [position?, [encoding?]], cb?)
-        encoding = 'utf8';
-        switch (typeof cbPosOff) {
-            case 'function':
-                // (fd, string, cb)
-                cb = cbPosOff;
-                break;
-            case 'number':
-                // (fd, string, position, encoding?, cb?)
-                position = cbPosOff;
-                encoding = typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8';
-                cb = typeof cbPosEnc === 'function' ? cbPosEnc : cb;
-                break;
-            default:
-                // ...try to find the callback and get out of here!
-                cb = (typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-                cb(withErrno('EINVAL'));
-                return;
-        }
-        buffer = Buffer.from(data);
+        // (fd, string, [position?, [encoding?]], cb?)
+        position = typeof cbPosOff === 'number' ? cbPosOff : null;
+        encoding = typeof cbLenEnc === 'string' ? cbLenEnc : 'utf8';
+        buffer = Buffer.from(data, encoding);
         offset = 0;
-        length = buffer.length;
-        const _cb = cb;
-        handle
-            .write(buffer, offset, length, position)
-            .then(({ bytesWritten }) => _cb(null, bytesWritten, buffer.toString(encoding)))
-            .catch(_cb);
+        length = buffer.byteLength;
     }
     else {
-        // Signature 2: (fd, buffer, offset, length, position?, cb?)
-        buffer = Buffer.from(data.buffer);
-        offset = cbPosOff;
-        length = cbLenEnc;
+        // (fd, buffer, [offset?, [length?, [position?]]], cb?)
+        buffer = Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        offset = typeof cbPosOff === 'number' ? cbPosOff : 0;
+        length = typeof cbLenEnc === 'number' ? cbLenEnc : buffer.byteLength - offset;
         position = typeof cbPosEnc === 'number' ? cbPosEnc : null;
-        const _cb = (typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-        void handle
-            .write(buffer, offset, length, position)
-            .then(({ bytesWritten }) => _cb(null, bytesWritten, buffer))
-            .catch(_cb);
     }
+    handle
+        .write(buffer, offset, length, position)
+        .then(({ bytesWritten }) => _cb(null, bytesWritten, typeof data === 'string' ? data : buffer))
+        .catch(_cb);
 }
 write;
 /**

package/dist/node/index.d.ts

@@ -6,3 +6,4 @@ export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
 export type { StatsLike } from './stats.js';
 export * from './streams.js';
 export * from './sync.js';
+export { Utf8Stream } from './utf8stream.js';

package/dist/node/index.js

@@ -6,3 +6,4 @@ export * as promises from './promises.js';
 export { BigIntStatsFs, Stats, StatsFs } from './stats.js';
 export * from './streams.js';
 export * from './sync.js';
+export { Utf8Stream } from './utf8stream.js';

package/dist/node/promises.d.ts

@@ -180,11 +180,25 @@ export declare function rename(this: V_Context, oldPath: fs.PathLike, newPath: f
  * Test whether or not `path` exists by checking with the file system.
  */
 export declare function exists(this: V_Context, path: fs.PathLike): Promise<boolean>;
-export declare function stat(this: V_Context, path: fs.PathLike, options: fs.BigIntOptions): Promise<BigIntStats>;
-export declare function stat(this: V_Context, path: fs.PathLike, options?: {
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.BigIntOptions & {
+    throwIfNoEntry?: true;
+}): Promise<BigIntStats>;
+export declare function stat(this: V_Context, path: fs.PathLike, options?: fs.StatOptions & {
     bigint?: false;
+    throwIfNoEntry?: true;
 }): Promise<Stats>;
-export declare function stat(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats>;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint?: false;
+    throwIfNoEntry: false;
+}): Promise<Stats | undefined>;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    bigint: true;
+    throwIfNoEntry: false;
+}): Promise<BigIntStats | undefined>;
+export declare function stat(this: V_Context, path: fs.PathLike, options: fs.StatOptions & {
+    throwIfNoEntry?: true;
+}): Promise<Stats | BigIntStats>;
+export declare function stat(this: V_Context, path: fs.PathLike, options?: fs.StatOptions): Promise<Stats | BigIntStats | undefined>;
 /**
  * `lstat`.
  * `lstat()` is identical to `stat()`, except that if path is a symbolic link,

package/dist/node/promises.js

@@ -54,10 +54,11 @@ import { Buffer } from 'buffer';
 import { Exception, rethrow, UV } from 'kerium';
 import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
+import { contextOf } from '../internal/contexts.js';
 import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
-import { dirname, join, matchesGlob } from '../path.js';
+import { dirname, join, matchesGlob, relative, resolve } from '../path.js';
 import '../polyfills.js';
-import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
+import { _isNoEntry, _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
 import * as _async from '../vfs/async.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
@@ -541,7 +542,15 @@ export async function exists(path) {
     }
 }
 export async function stat(path, options) {
-    const stats = await _async.stat.call(this, path, false);
+    let stats;
+    try {
+        stats = await _async.stat.call(this, path, false);
+    }
+    catch (e) {
+        if (options?.throwIfNoEntry === false && _isNoEntry(e))
+            return;
+        throw e;
+    }
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 stat;
@@ -1081,8 +1090,16 @@ export async function cp(source, destination, opts) {
             await Promise.all(entries.map(_cp));
             break;
         }
-        case constants.S_IFREG:
         case constants.S_IFLNK:
+            if (opts?.dereference) {
+                await copyFile.call(this, source, destination);
+            }
+            else {
+                const link = await readlink.call(this, source);
+                await symlink.call(this, opts?.verbatimSymlinks ? link : resolve.call(this, dirname(source), link), destination);
+            }
+            break;
+        case constants.S_IFREG:
             await copyFile.call(this, source, destination);
             break;
         case constants.S_IFBLK:
@@ -1105,8 +1122,10 @@ export async function statfs(path, opts) {
 }
 export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
-    const { cwd = '/', withFileTypes = false, exclude = () => false } = opt || {};
-    const normalizedPatterns = pattern.map(p => p.replace(/^\/+/g, ''));
+    const $ = contextOf(this);
+    const { cwd = $.pwd, withFileTypes = false, exclude = () => false, followSymlinks = false } = opt || {};
+    const base = resolve.call($, cwd instanceof URL ? cwd.pathname : cwd);
+    const normalizedPatterns = pattern.map(p => (p.startsWith('/') ? relative.call($, base, p) : p));
     const hasGlobStar = normalizedPatterns.some(p => p.includes('**'));
     const patternBases = normalizedPatterns.map(p => {
         const firstGlob = p.search(/[*?[\]{]/);
@@ -1116,23 +1135,28 @@ export function glob(pattern, opt) {
         return lastSlash === -1 ? '' : p.slice(0, lastSlash);
     });
     const regexPatterns = normalizedPatterns.map(globToRegex);
+    async function shouldDescend(path, relativePath) {
+        const isNamed = patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'));
+        const inScope = hasGlobStar || isNamed;
+        const stats = await lstat.call($, path);
+        if (!stats.isSymbolicLink())
+            return inScope && stats.isDirectory();
+        return inScope && (followSymlinks || isNamed) && !!(await stat.call($, path, { throwIfNoEntry: false }))?.isDirectory();
+    }
     async function* recursiveList(dir) {
-        const entries = await readdir(dir, { withFileTypes, encoding: 'utf8' });
+        const entries = await readdir.call($, dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
             const fullPath = join(dir, withFileTypes ? entry.name : entry);
-            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
+            const relPath = relative.call($, base, fullPath);
+            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, relPath)) : exclude((withFileTypes ? entry : relPath)))
                 continue;
-            const relativePath = fullPath.replace(/^\/+/g, '');
-            if ((await stat(fullPath)).isDirectory()) {
-                if (hasGlobStar || patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'))) {
-                    yield* recursiveList(fullPath);
-                }
-            }
-            if (regexPatterns.some(rx => rx.test(relativePath))) {
-                yield withFileTypes ? entry : relativePath;
+            if (await shouldDescend(fullPath, relPath))
+                yield* recursiveList(fullPath);
+            if (regexPatterns.some(rx => rx.test(relPath))) {
+                yield withFileTypes ? entry : relPath;
             }
         }
     }
-    return recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
+    return recursiveList(base);
 }
 glob;

package/dist/node/stats.d.ts

@@ -91,24 +91,32 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     atimeMs: T;
     get atime(): Date;
     set atime(value: Date);
+    get atimeInstant(): Temporal.Instant;
+    set atimeInstant(value: Temporal.Instant);
     /**
      * Time of last modification, since epoch
      */
     mtimeMs: T;
     get mtime(): Date;
     set mtime(value: Date);
+    get mtimeInstant(): Temporal.Instant;
+    set mtimeInstant(value: Temporal.Instant);
     /**
      * Time of last time file status was changed, since epoch
      */
     ctimeMs: T;
     get ctime(): Date;
     set ctime(value: Date);
+    get ctimeInstant(): Temporal.Instant;
+    set ctimeInstant(value: Temporal.Instant);
     /**
      * Time of file creation, since epoch
      */
     birthtimeMs: T;
     get birthtime(): Date;
     set birthtime(value: Date);
+    get birthtimeInstant(): Temporal.Instant;
+    set birthtimeInstant(value: Temporal.Instant);
     /**
      * Size of the item in bytes.
      * For directories/symlinks, this is normally the size of the struct that represents the item.
@@ -193,6 +201,8 @@ export declare class StatsFs implements Node.StatsFsBase<number> {
     bavail: number;
     /** Total file nodes in file system. */
     files: number;
+    /** Fundamental file system block size. */
+    frsize: number;
     /** Free file nodes in file system. */
     ffree: number;
 }
@@ -212,6 +222,8 @@ export declare class BigIntStatsFs implements Node.StatsFsBase<bigint> {
     bavail: bigint;
     /** Total file nodes in file system. */
     files: bigint;
+    /** Fundamental file system block size. */
+    frsize: bigint;
     /** Free file nodes in file system. */
     ffree: bigint;
 }