@zenfs/core 2.5.0 → 2.5.2

package/dist/backends/backend.js

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-redundant-type-constituents */
+/* eslint-disable @typescript-eslint/no-redundant-type-constituents */
 import { withErrno } from 'kerium';
 import { debug, err } from 'kerium/log';
 /**

package/dist/internal/rpc.js

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
 import { Errno, Exception, withErrno } from 'kerium';
 import { err, info, warn } from 'kerium/log';
 import { isJSON, pick } from 'utilium';

package/dist/mixins/async.js

@@ -30,7 +30,6 @@ export function Async(FS) {
         }
         _promise = Promise.resolve();
         _async(thunk) {
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
             this._promise = this._promise.finally(() => thunk());
         }
         _isInitialized = false;

package/dist/mixins/shared.js

@@ -1,8 +1,4 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/*
-    Code shared by various mixins
-*/
 export const _asyncFSKeys = [
     'rename',
     'stat',

package/dist/node/promises.d.ts

@@ -72,11 +72,11 @@ export declare class FileHandle implements promises.FileHandle {
     read<T extends NodeJS.ArrayBufferView = Buffer>(options?: promises.FileReadOptions<T>): Promise<promises.FileReadResult<T>>;
     readFile(options?: ({
         encoding?: null;
-    } & Abortable) | null): Promise<Buffer>;
+    } & Abortable) | null): Promise<NonSharedBuffer>;
     readFile(options: ({
         encoding: BufferEncoding;
     } & Abortable) | BufferEncoding): Promise<string>;
-    readFile(_options?: (fs.ObjectEncodingOptions & Abortable) | BufferEncoding | null): Promise<string | Buffer>;
+    readFile(_options?: (fs.ObjectEncodingOptions & Abortable) | BufferEncoding | null): Promise<string | NonSharedBuffer>;
     /**
      * Read file data using a `ReadableStream`.
      * The handle will not be closed automatically.
@@ -139,14 +139,14 @@ export declare class FileHandle implements promises.FileHandle {
      * @param position The position in the file where to begin writing.
      * @returns The number of bytes written.
      */
-    writev(buffers: Uint8Array[], position?: number): Promise<fs.WriteVResult>;
+    writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(buffers: TBuffers, position?: number): Promise<fs.WriteVResult<TBuffers>>;
     /**
      * Asynchronous `readv`. Reads into multiple buffers.
      * @param buffers An array of Uint8Array buffers.
      * @param position The position in the file where to begin reading.
      * @returns The number of bytes read.
      */
-    readv(buffers: NodeJS.ArrayBufferView[], position?: number): Promise<fs.ReadVResult>;
+    readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(buffers: TBuffers, position?: number): Promise<fs.ReadVResult<TBuffers>>;
     /**
      * Creates a stream for reading from the file.
      * @param options Options for the readable stream
@@ -197,14 +197,14 @@ export declare function open(this: V_Context, path: fs.PathLike, flag?: fs.OpenM
 export declare function readFile(this: V_Context, path: fs.PathLike | promises.FileHandle, options?: ({
     encoding?: null;
     flag?: fs.OpenMode;
-} & Abortable) | null): Promise<Buffer>;
+} & Abortable) | null): Promise<NonSharedBuffer>;
 export declare function readFile(this: V_Context, path: fs.PathLike | promises.FileHandle, options: ({
     encoding: BufferEncoding;
     flag?: fs.OpenMode;
 } & Abortable) | BufferEncoding): Promise<string>;
 export declare function readFile(this: V_Context, path: fs.PathLike | promises.FileHandle, _options?: (fs.ObjectEncodingOptions & Abortable & {
     flag?: fs.OpenMode;
-}) | BufferEncoding | null): Promise<string | Buffer>;
+}) | BufferEncoding | null): Promise<string | NonSharedBuffer>;
 /**
  * Asynchronously writes data to a file, replacing the file if it already exists.
  *
@@ -257,11 +257,11 @@ export declare function readdir(this: V_Context, path: fs.PathLike, options: {
     encoding: 'buffer';
     withFileTypes?: false;
     recursive?: boolean;
-} | 'buffer'): Promise<Buffer[]>;
+} | 'buffer'): Promise<NonSharedBuffer[]>;
 export declare function readdir(this: V_Context, path: fs.PathLike, options?: (fs.ObjectEncodingOptions & {
     withFileTypes?: false;
     recursive?: boolean;
-}) | BufferEncoding | null): Promise<string[] | Buffer[]>;
+}) | BufferEncoding | null): Promise<string[] | NonSharedBuffer[]>;
 export declare function readdir(this: V_Context, path: fs.PathLike, options: fs.ObjectEncodingOptions & {
     withFileTypes: true;
     recursive?: boolean;
@@ -270,7 +270,7 @@ export declare function readdir(this: V_Context, path: fs.PathLike, options: {
     encoding: 'buffer';
     withFileTypes: true;
     recursive?: boolean;
-}): Promise<Dirent<Buffer>[]>;
+}): Promise<Dirent<NonSharedBuffer>[]>;
 export declare function readdir(this: V_Context, path: fs.PathLike, options?: NodeReaddirOptions): Promise<string[] | Dirent<any>[] | Buffer[]>;
 export declare function link(this: V_Context, path: fs.PathLike, dest: fs.PathLike): Promise<void>;
 /**
@@ -280,9 +280,9 @@ export declare function link(this: V_Context, path: fs.PathLike, dest: fs.PathLi
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
 export declare function symlink(this: V_Context, dest: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type | string | null): Promise<void>;
-export declare function readlink(this: V_Context, path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
+export declare function readlink(this: V_Context, path: fs.PathLike, options: fs.BufferEncodingOption): Promise<NonSharedBuffer>;
 export declare function readlink(this: V_Context, path: fs.PathLike, options?: fs.EncodingOption | null): Promise<string>;
-export declare function readlink(this: V_Context, path: fs.PathLike, options?: fs.BufferEncodingOption | fs.EncodingOption | string | null): Promise<string | Buffer>;
+export declare function readlink(this: V_Context, path: fs.PathLike, options?: fs.BufferEncodingOption | fs.EncodingOption | string | null): Promise<string | NonSharedBuffer>;
 export declare function chown(this: V_Context, path: fs.PathLike, uid: number, gid: number): Promise<void>;
 export declare function lchown(this: V_Context, path: fs.PathLike, uid: number, gid: number): Promise<void>;
 export declare function chmod(this: V_Context, path: fs.PathLike, mode: fs.Mode): Promise<void>;
@@ -301,11 +301,11 @@ export declare function lutimes(this: V_Context, path: fs.PathLike, atime: fs.Ti
  * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. Defaults to `'utf8'`.
  * @todo handle options
  */
-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.BufferEncodingOption): Promise<NonSharedBuffer>;
 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): AsyncIteratorObject<promises.FileChangeInfo<string>, undefined>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIteratorObject<promises.FileChangeInfo<Buffer>, undefined>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIteratorObject<promises.FileChangeInfo<string>, undefined> | AsyncIteratorObject<promises.FileChangeInfo<Buffer>, undefined>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIteratorObject<promises.FileChangeInfo<NonSharedBuffer>, undefined>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIteratorObject<promises.FileChangeInfo<string>, undefined> | AsyncIteratorObject<promises.FileChangeInfo<NonSharedBuffer>, undefined>;
 export declare function access(this: V_Context, path: fs.PathLike, mode?: number): Promise<void>;
 /**
  * Asynchronous `rm`. Removes files or directories (recursively).
@@ -319,7 +319,7 @@ export declare function rm(this: V_Context, path: fs.PathLike, options?: fs.RmOp
  * @returns The path to the created temporary directory, encoded as a string or buffer.
  */
 export declare function mkdtemp(this: V_Context, prefix: string, options?: fs.EncodingOption): Promise<string>;
-export declare function mkdtemp(this: V_Context, prefix: string, options?: fs.BufferEncodingOption): Promise<Buffer>;
+export declare function mkdtemp(this: V_Context, prefix: string, options?: fs.BufferEncodingOption): Promise<NonSharedBuffer>;
 /**
  * The resulting Promise holds an async-disposable object whose `path` property holds the created directory path.
  * When the object is disposed, the directory and its contents will be removed asynchronously if it still exists.

package/dist/node/promises.js

@@ -898,25 +898,33 @@ export async function statfs(path, opts) {
 export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = opt || {};
-    // Escape special characters in pattern
-    const regexPatterns = pattern.map(globToRegex);
+    const normalizedPatterns = pattern.map(p => p.replace(/^\/+/g, ''));
+    const hasGlobStar = normalizedPatterns.some(p => p.includes('**'));
+    const patternBases = normalizedPatterns.map(p => {
+        const firstGlob = p.search(/[*?[\]{]/);
+        if (firstGlob === -1)
+            return p;
+        const lastSlash = p.lastIndexOf('/', firstGlob);
+        return lastSlash === -1 ? '' : p.slice(0, lastSlash);
+    });
+    const regexPatterns = normalizedPatterns.map(globToRegex);
     async function* recursiveList(dir) {
         const entries = await readdir(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
-            const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + '/' + entry;
+            const fullPath = join(dir, withFileTypes ? entry.name : entry);
             if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
-            /**
-             * @todo is the pattern.source check correct?
-             */
-            if ((await stat(fullPath)).isDirectory() && regexPatterns.some(pattern => pattern.source.includes('.*'))) {
-                yield* recursiveList(fullPath);
+            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(pattern => pattern.test(fullPath.replace(/^\/+/g, '')))) {
-                yield withFileTypes ? entry : fullPath.replace(/^\/+/g, '');
+            if (regexPatterns.some(rx => rx.test(relativePath))) {
+                yield withFileTypes ? entry : relativePath;
             }
         }
     }
-    return recursiveList(cwd);
+    return recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
 }
 glob;

package/dist/node/readline.js

@@ -1,5 +1,4 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-/* eslint-disable @typescript-eslint/no-explicit-any */
 // A cross-platform node:readline implementation
 import { EventEmitter } from 'eventemitter3';
 import { warn } from 'kerium/log';

package/dist/node/sync.d.ts

@@ -122,11 +122,11 @@ export declare function readdirSync(this: V_Context, path: fs.PathLike, options:
     encoding: 'buffer';
     withFileTypes?: false;
     recursive?: boolean;
-} | 'buffer'): Buffer[];
+} | 'buffer'): NonSharedBuffer[];
 export declare function readdirSync(this: V_Context, path: fs.PathLike, options?: (fs.ObjectEncodingOptions & {
     withFileTypes?: false;
     recursive?: boolean;
-}) | BufferEncoding | null): string[] | Buffer[];
+}) | BufferEncoding | null): string[] | NonSharedBuffer[];
 export declare function readdirSync(this: V_Context, path: fs.PathLike, options: fs.ObjectEncodingOptions & {
     withFileTypes: true;
     recursive?: boolean;
@@ -135,7 +135,7 @@ export declare function readdirSync(this: V_Context, path: fs.PathLike, options:
     encoding: 'buffer';
     withFileTypes: true;
     recursive?: boolean;
-}): Dirent<Buffer>[];
+}): Dirent<NonSharedBuffer>[];
 export declare function readdirSync(this: V_Context, path: fs.PathLike, options?: NodeReaddirOptions): string[] | Dirent<any>[] | Buffer[];
 export declare function linkSync(this: V_Context, targetPath: fs.PathLike, linkPath: fs.PathLike): void;
 /**
@@ -145,9 +145,9 @@ export declare function linkSync(this: V_Context, targetPath: fs.PathLike, linkP
  * @param type can be either `'dir'` or `'file'` (default is `'file'`)
  */
 export declare function symlinkSync(this: V_Context, target: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type | null): void;
-export declare function readlinkSync(this: V_Context, path: fs.PathLike, options?: fs.BufferEncodingOption): Buffer;
+export declare function readlinkSync(this: V_Context, path: fs.PathLike, options?: fs.BufferEncodingOption): NonSharedBuffer;
 export declare function readlinkSync(this: V_Context, path: fs.PathLike, options: fs.EncodingOption | BufferEncoding): string;
-export declare function readlinkSync(this: V_Context, path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): Buffer | string;
+export declare function readlinkSync(this: V_Context, path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding | fs.BufferEncodingOption): NonSharedBuffer | string;
 export declare function chownSync(this: V_Context, path: fs.PathLike, uid: number, gid: number): void;
 export declare function lchownSync(this: V_Context, path: fs.PathLike, uid: number, gid: number): void;
 export declare function chmodSync(this: V_Context, path: fs.PathLike, mode: fs.Mode): void;
@@ -174,7 +174,7 @@ export declare function rmSync(this: V_Context, path: fs.PathLike, options?: fs.
  * @param options The encoding (or an object including `encoding`).
  * @returns The path to the created temporary directory, encoded as a string or buffer.
  */
-export declare function mkdtempSync(this: V_Context, prefix: fs.PathLike, options: fs.BufferEncodingOption): Buffer;
+export declare function mkdtempSync(this: V_Context, prefix: fs.PathLike, options: fs.BufferEncodingOption): NonSharedBuffer;
 export declare function mkdtempSync(this: V_Context, prefix: fs.PathLike, options?: fs.EncodingOption): string;
 /**
  * Returns a disposable object whose `path` property holds the created directory path.

package/dist/node/sync.js

@@ -656,27 +656,35 @@ export function statfsSync(path, options) {
 export function globSync(pattern, options = {}) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = options;
-    // Escape special characters in pattern
-    const regexPatterns = pattern.map(globToRegex);
+    const normalizedPatterns = pattern.map(p => p.replace(/^\/+/g, ''));
+    const hasGlobStar = normalizedPatterns.some(p => p.includes('**'));
+    const patternBases = normalizedPatterns.map(p => {
+        const firstGlob = p.search(/[*?[\]{]/);
+        if (firstGlob === -1)
+            return p;
+        const lastSlash = p.lastIndexOf('/', firstGlob);
+        return lastSlash === -1 ? '' : p.slice(0, lastSlash);
+    });
+    const regexPatterns = normalizedPatterns.map(globToRegex);
     const results = [];
     function recursiveList(dir) {
         const entries = readdirSync(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
-            const fullPath = withFileTypes ? join(entry.parentPath, entry.name) : dir + '/' + entry;
+            const fullPath = join(dir, withFileTypes ? entry.name : entry);
             if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
-            /**
-             * @todo is the pattern.source check correct?
-             */
-            if (statSync(fullPath).isDirectory() && regexPatterns.some(pattern => pattern.source.includes('.*'))) {
-                recursiveList(fullPath);
+            const relativePath = fullPath.replace(/^\/+/g, '');
+            if (statSync(fullPath).isDirectory()) {
+                if (hasGlobStar || patternBases.some(base => relativePath === base || base.startsWith(relativePath + '/'))) {
+                    recursiveList(fullPath);
+                }
             }
-            if (regexPatterns.some(pattern => pattern.test(fullPath.replace(/^\/+/g, '')))) {
-                results.push(withFileTypes ? entry : fullPath.replace(/^\/+/g, ''));
+            if (regexPatterns.some(rx => rx.test(relativePath))) {
+                results.push(withFileTypes ? entry : relativePath);
             }
         }
     }
-    recursiveList(cwd);
+    recursiveList(cwd instanceof URL ? cwd.pathname : cwd);
     return results;
 }
 globSync;

package/dist/polyfills.js

@@ -5,9 +5,7 @@ import { warn } from 'kerium/log';
 Promise.withResolvers ??=
     (warn('Using a polyfill of Promise.withResolvers'),
         function () {
-            let _resolve, 
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            _reject;
+            let _resolve, _reject;
             const promise = new Promise((resolve, reject) => {
                 _resolve = resolve;
                 _reject = reject;

package/dist/utils.js

@@ -97,11 +97,16 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
  * @internal
  */
 export function globToRegex(pattern) {
+    const GLOBSTAR = '\0GS\0';
+    const STAR = '\0S\0';
     pattern = pattern
-        .replace(/([.?+^$(){}|[\]/])/g, '$1')
-        .replace(/\*\*/g, '.*')
-        .replace(/\*/g, '[^/]*')
-        .replace(/\?/g, '.');
+        .replace(/\*\*/g, GLOBSTAR)
+        .replace(/\*/g, STAR)
+        .replace(/[.+^$(){}|[\]\\]/g, '\\$&')
+        .replace(/\?/g, '.')
+        .replaceAll('/' + GLOBSTAR + '/', '(?:/.*)?/')
+        .replaceAll(GLOBSTAR, '.*')
+        .replaceAll(STAR, '[^/]*');
     return new RegExp(`^${pattern}$`);
 }
 export async function waitOnline(worker) {

package/dist/vfs/watchers.js

@@ -14,14 +14,12 @@ import { normalizePath } from '../utils.js';
 class Watcher extends EventEmitter {
     _context;
     path;
-    /* eslint-disable @typescript-eslint/no-explicit-any */
     off(event, fn, context, once) {
         return super.off(event, fn, context, once);
     }
     removeListener(event, fn, context, once) {
         return super.removeListener(event, fn, context, once);
     }
-    /* eslint-enable @typescript-eslint/no-explicit-any */
     constructor(
     /**
      * @internal

package/eslint.shared.js

@@ -1,12 +1,12 @@
 /* Shared eslint rules */
 import eslint from '@eslint/js';
 import globals from 'globals';
-import tseslint from 'typescript-eslint';
+import { configs } from 'typescript-eslint';
 
 export default [
 	{
 		name: 'ZenFS',
-		extends: [eslint.configs.recommended, ...tseslint.configs.recommendedTypeChecked],
+		extends: [eslint.configs.recommended, ...configs.recommendedTypeChecked],
 		files: ['src/**/*.ts', 'tests/**/*.ts'],
 		languageOptions: {
 			globals: { ...globals.browser, ...globals.node },

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.5.0",
+	"version": "2.5.2",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -71,7 +71,7 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@types/node": "^24.1.0",
+		"@types/node": "^25.2.0",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.3.4",
@@ -80,12 +80,10 @@
 		"utilium": "^2.5.0"
 	},
 	"devDependencies": {
-		"@eslint/js": "^9.8.0",
-		"@octokit/action": "^7.0.0",
-		"@types/eslint__js": "^8.42.3",
-		"c8": "^10.1.2",
+		"@octokit/action": "^8.0.4",
+		"c8": "^10.1.3",
 		"eslint": "^9.15.0",
-		"globals": "^16.0.0",
+		"globals": "^17.3.0",
 		"prettier": "^3.2.5",
 		"tsx": "^4.19.1",
 		"typedoc": "^0.28.0",

package/scripts/test.js

@@ -87,9 +87,19 @@ if (options.clean) {
 	process.exit();
 }
 
+function report() {
+	try {
+		execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
+	} catch (e) {
+		console.error('Failed to generate coverage report!');
+		console.error(e);
+	} finally {
+		rmSync(options.coverage, { recursive: true });
+	}
+}
+
 if (options.report) {
-	execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
-	rmSync(options.coverage, { recursive: true, force: true });
+	report();
 	process.exit();
 }
 
@@ -237,7 +247,4 @@ for (const setupFile of positionals) {
 	}
 }
 
-if (!options.preserve) {
-	execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
-	rmSync(options.coverage, { recursive: true });
-}
+if (!options.preserve) report();

package/tests/backend/single-buffer.test.ts

@@ -64,7 +64,7 @@ await suite('SingleBuffer', () => {
 		const growthSizes = [0, 1, 17, 512, 8192, 65535, 262144, 524288];
 		const shrinkSizes = [262144, 4096, 128, 0];
 
-		const verifySnapshot = async (expected: Buffer, size: number) => {
+		const verifySnapshot = (expected: Buffer, size: number) => {
 			mount(verifyMountPoint, writable);
 			try {
 				const reopened = fs.readFileSync(`${verifyMountPoint}/payload.bin`);
@@ -82,7 +82,7 @@ await suite('SingleBuffer', () => {
 				const direct = fs.readFileSync(filePath);
 				assert.strictEqual(direct.byteLength, size, `direct size mismatch for ${size} bytes`);
 				assert.deepStrictEqual(direct, payload, `direct content mismatch for ${size} bytes`);
-				await verifySnapshot(direct, size);
+				verifySnapshot(direct, size);
 			}
 
 			for (const size of shrinkSizes) {
@@ -91,7 +91,7 @@ await suite('SingleBuffer', () => {
 				const direct = fs.readFileSync(filePath);
 				assert.strictEqual(direct.byteLength, size, `direct size mismatch after shrink to ${size} bytes`);
 				assert.deepStrictEqual(direct, payload, `direct content mismatch after shrink to ${size} bytes`);
-				await verifySnapshot(direct, size);
+				verifySnapshot(direct, size);
 			}
 		} finally {
 			if (fs.existsSync(filePath)) fs.unlinkSync(filePath);

package/tests/common/glob.test.ts

@@ -0,0 +1,135 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { fs } from '../common.js';
+
+// Set up a directory structure for glob tests
+fs.mkdirSync('/glob');
+fs.mkdirSync('/glob/sub');
+fs.mkdirSync('/glob/sub/deep');
+fs.writeFileSync('/glob/a.txt', 'a');
+fs.writeFileSync('/glob/b.txt', 'b');
+fs.writeFileSync('/glob/c.js', 'c');
+fs.writeFileSync('/glob/sub/d.txt', 'd');
+fs.writeFileSync('/glob/sub/e.js', 'e');
+fs.writeFileSync('/glob/sub/deep/f.txt', 'f');
+
+suite('globSync', () => {
+	test('wildcard in root', () => {
+		const results = fs.globSync('glob/*');
+		assert(results.includes('glob/a.txt'), 'should include glob/a.txt');
+		assert(results.includes('glob/b.txt'), 'should include glob/b.txt');
+		assert(results.includes('glob/c.js'), 'should include glob/c.js');
+		assert(results.includes('glob/sub'), 'should include glob/sub');
+	});
+
+	test('wildcard with absolute path pattern', () => {
+		const results = fs.globSync('/glob/*');
+		assert(results.includes('glob/a.txt'), 'should include glob/a.txt');
+		assert(results.includes('glob/b.txt'), 'should include glob/b.txt');
+		assert(results.includes('glob/c.js'), 'should include glob/c.js');
+	});
+
+	test('wildcard with extension filter', () => {
+		const results = fs.globSync('/glob/*.txt');
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(!results.includes('glob/c.js'), 'should not include .js files');
+	});
+
+	test('nested path wildcard', () => {
+		const results = fs.globSync('/glob/sub/*');
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/e.js'));
+		assert(!results.includes('glob/a.txt'), 'should not include files from parent');
+	});
+
+	test('globstar (**)', () => {
+		const results = fs.globSync('/glob/**/*.txt');
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/deep/f.txt'));
+		assert(!results.includes('glob/c.js'), 'should not include .js files');
+	});
+
+	test('question mark wildcard', () => {
+		const results = fs.globSync('/glob/?.txt');
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(!results.includes('glob/c.js'));
+	});
+
+	test('multiple patterns', () => {
+		const results = fs.globSync(['/glob/*.txt', '/glob/*.js']);
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/c.js'));
+	});
+
+	test('no matches returns empty', () => {
+		const results = fs.globSync('/glob/*.xyz');
+		assert.equal(results.length, 0);
+	});
+
+	test('withFileTypes option', () => {
+		const results = fs.globSync('/glob/*.txt', { withFileTypes: true });
+		assert(results.length > 0, 'should have results');
+		assert(typeof results[0] === 'object' && 'name' in results[0], 'results should be Dirent objects');
+	});
+
+	test('exclude option with function', () => {
+		const results = fs.globSync('/glob/*', { exclude: path => typeof path === 'string' && path.endsWith('.js') });
+		assert(!results.includes('glob/c.js'), 'should exclude .js files');
+		assert(results.includes('glob/a.txt'), 'should still include .txt files');
+	});
+});
+
+await suite('promises.glob', () => {
+	test('wildcard in root', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(results.includes('glob/c.js'));
+		assert(results.includes('glob/sub'));
+	});
+
+	test('wildcard with absolute path pattern', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+	});
+
+	test('wildcard with extension filter', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*.txt'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(!results.includes('glob/c.js'));
+	});
+
+	test('nested path wildcard', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/sub/*'));
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/e.js'));
+		assert(!results.includes('glob/a.txt'));
+	});
+
+	test('globstar (**)', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/**/*.txt'));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/b.txt'));
+		assert(results.includes('glob/sub/d.txt'));
+		assert(results.includes('glob/sub/deep/f.txt'));
+		assert(!results.includes('glob/c.js'));
+	});
+
+	test('multiple patterns', async () => {
+		const results = await Array.fromAsync(fs.promises.glob(['/glob/*.txt', '/glob/*.js']));
+		assert(results.includes('glob/a.txt'));
+		assert(results.includes('glob/c.js'));
+	});
+
+	test('no matches returns empty', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/*.xyz'));
+		assert.equal(results.length, 0);
+	});
+});