@zenfs/core 1.1.3 → 1.1.5

package/dist/backends/fetch.js

@@ -2,21 +2,21 @@ import { Errno, ErrnoError } from '../error.js';
 import { IndexFS } from './file_index.js';
 async function fetchFile(path, type) {
     const response = await fetch(path).catch((e) => {
-        throw new ErrnoError(Errno.EIO, e.message);
+        throw new ErrnoError(Errno.EIO, e.message, path);
     });
     if (!response.ok) {
-        throw new ErrnoError(Errno.EIO, 'fetch failed: response returned code ' + response.status);
+        throw new ErrnoError(Errno.EIO, 'fetch failed: response returned code ' + response.status, path);
     }
     switch (type) {
         case 'buffer': {
             const arrayBuffer = await response.arrayBuffer().catch((e) => {
-                throw new ErrnoError(Errno.EIO, e.message);
+                throw new ErrnoError(Errno.EIO, e.message, path);
             });
             return new Uint8Array(arrayBuffer);
         }
         case 'json':
             return response.json().catch((e) => {
-                throw new ErrnoError(Errno.EIO, e.message);
+                throw new ErrnoError(Errno.EIO, e.message, path);
             });
         default:
             throw new ErrnoError(Errno.EINVAL, 'Invalid download type: ' + type);
@@ -58,11 +58,11 @@ export class FetchFS extends IndexFS {
         }
     }
     constructor({ index = 'index.json', baseUrl = '' }) {
-        super(typeof index != 'string' ? index : fetchFile(index, 'json'));
         // prefix url must end in a directory separator.
         if (baseUrl.at(-1) != '/') {
             baseUrl += '/';
         }
+        super(typeof index != 'string' ? index : fetchFile(baseUrl + index, 'json'));
         this.baseUrl = baseUrl;
     }
     metadata() {

package/dist/backends/overlay.js

@@ -141,7 +141,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             await this.writable.rename(oldPath, newPath);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(oldPath)) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -155,7 +155,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             this.writable.renameSync(oldPath, newPath);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(oldPath)) {
                 throw ErrnoError.With('ENOENT', oldPath, 'rename');
             }
@@ -166,7 +166,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             return await this.writable.stat(path);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(path)) {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
@@ -181,7 +181,7 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             return this.writable.statSync(path);
         }
-        catch (e) {
+        catch {
             if (this._deletedFiles.has(path)) {
                 throw ErrnoError.With('ENOENT', path, 'stat');
             }
@@ -323,13 +323,13 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             contents.push(...(await this.writable.readdir(path)));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         try {
             contents.push(...(await this.readable.readdir(path)).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         const seenMap = {};
@@ -350,13 +350,13 @@ export class UnmutexedOverlayFS extends FileSystem {
         try {
             contents = contents.concat(this.writable.readdirSync(path));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         try {
             contents = contents.concat(this.readable.readdirSync(path).filter((fPath) => !this._deletedFiles.has(`${path}/${fPath}`)));
         }
-        catch (e) {
+        catch {
             // NOP.
         }
         const seenMap = {};

package/dist/backends/port/fs.js

@@ -180,7 +180,7 @@ export async function handleRequest(port, fs, request) {
                     };
                 }
                 break;
-            case 'file':
+            case 'file': {
                 const { fd } = request;
                 if (!descriptors.has(fd)) {
                     throw new ErrnoError(Errno.EBADF);
@@ -191,6 +191,7 @@ export async function handleRequest(port, fs, request) {
                     descriptors.delete(fd);
                 }
                 break;
+            }
             default:
                 return;
         }

package/dist/backends/port/rpc.js

@@ -79,7 +79,7 @@ export function catchMessages(port) {
     return function (fs) {
         detach(port, handler);
         for (const event of events) {
-            const request = 'data' in event ? event.data : event;
+            const request = ('data' in event ? event.data : event);
             void handleRequest(port, fs, request);
         }
     };

package/dist/config.js

@@ -19,6 +19,7 @@ export async function resolveMountConfig(configuration, _depth = 0) {
         throw new ErrnoError(Errno.EINVAL, 'Invalid mount configuration');
     }
     if (configuration instanceof FileSystem) {
+        await configuration.ready();
         return configuration;
     }
     if (isBackend(configuration)) {

package/dist/devices.js

@@ -105,14 +105,16 @@ export class DeviceFile extends File {
     closeSync() {
         this.driver.close?.(this);
     }
-    async close() {
+    close() {
         this.closeSync();
+        return Promise.resolve();
     }
     syncSync() {
         this.driver.sync?.(this);
     }
-    async sync() {
+    sync() {
         this.syncSync();
+        return Promise.resolve();
     }
     chown() {
         throw ErrnoError.With('ENOTSUP', this.path, 'chown');

package/dist/emulation/async.d.ts

@@ -181,7 +181,7 @@ export declare function link(existing: fs.PathLike, newpath: fs.PathLike, cb?: C
  */
 export declare function symlink(target: fs.PathLike, path: fs.PathLike, cb?: Callback): void;
 export declare function symlink(target: fs.PathLike, path: fs.PathLike, type?: fs.symlink.Type, cb?: Callback): void;
-export declare function readlink(path: fs.PathLike, callback: Callback<[string]> & any): void;
+export declare function readlink(path: fs.PathLike, callback: Callback<[string]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.BufferEncodingOption, callback: Callback<[Uint8Array]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string | Uint8Array]>): void;
 export declare function readlink(path: fs.PathLike, options: fs.EncodingOption, callback: Callback<[string]>): void;

package/dist/emulation/promises.d.ts

@@ -92,6 +92,9 @@ export declare class FileHandle implements promises.FileHandle {
      * @experimental
      */
     readableWebStream(options?: promises.ReadableWebStreamOptions): TReadableStream<Uint8Array>;
+    /**
+     * @todo Implement
+     */
     readLines(options?: promises.CreateReadStreamOptions): ReadlineInterface;
     [Symbol.asyncDispose](): Promise<void>;
     /**
@@ -296,6 +299,7 @@ export declare function lutimes(path: fs.PathLike, atime: fs.TimeLike, mtime: fs
  * Asynchronous realpath(3) - return the canonicalized absolute pathname.
  * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
  * @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(path: fs.PathLike, options: fs.BufferEncodingOption): Promise<Buffer>;
 export declare function realpath(path: fs.PathLike, options?: fs.EncodingOption | BufferEncoding): Promise<string>;

package/dist/emulation/promises.js

@@ -206,6 +206,9 @@ export class FileHandle {
         }
         return new _gt.ReadableStream({ start, type: options.type });
     }
+    /**
+     * @todo Implement
+     */
     readLines(options) {
         throw ErrnoError.With('ENOSYS', this.file.path, 'FileHandle.readLines');
     }
@@ -383,11 +386,11 @@ export async function exists(path) {
 }
 export async function stat(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount((await exists(path)) ? await realpath(path) : path);
+    const { fs, path: resolved } = resolveMount(await realpath(path));
     try {
         const stats = await fs.stat(resolved);
         if (!stats.hasAccess(constants.R_OK)) {
-            throw ErrnoError.With('EACCES', path, 'stat');
+            throw ErrnoError.With('EACCES', resolved, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
     }
@@ -448,7 +451,7 @@ unlink;
 async function _open(path, _flag, _mode = 0o644, resolveSymlinks) {
     path = normalizePath(path);
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks && (await exists(path)) ? await realpath(path) : path;
+    path = resolveSymlinks ? await realpath(path) : path;
     const { fs, path: resolved } = resolveMount(path);
     const stats = await fs.stat(resolved).catch(() => null);
     if (!stats) {
@@ -577,7 +580,7 @@ appendFile;
 // DIRECTORY-ONLY METHODS
 export async function rmdir(path) {
     path = normalizePath(path);
-    path = (await exists(path)) ? await realpath(path) : path;
+    path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
         if (!(await fs.stat(resolved)).hasAccess(constants.W_OK)) {
@@ -594,8 +597,7 @@ rmdir;
 export async function mkdir(path, options) {
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = normalizePath(path);
-    path = (await exists(path)) ? await realpath(path) : path;
+    path = await realpath(normalizePath(path));
     const { fs, path: resolved } = resolveMount(path);
     const errorPaths = { [resolved]: path };
     try {
@@ -628,12 +630,11 @@ export async function mkdir(path, options) {
 mkdir;
 export async function readdir(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
-    path = normalizePath(path);
-    if (!(await stat(path)).hasAccess(constants.R_OK)) {
+    path = await realpath(normalizePath(path));
+    const { fs, path: resolved } = resolveMount(path);
+    if (!(await fs.stat(resolved)).hasAccess(constants.R_OK)) {
         throw ErrnoError.With('EACCES', path, 'readdir');
     }
-    path = (await exists(path)) ? await realpath(path) : path;
-    const { fs, path: resolved } = resolveMount(path);
     const entries = await fs.readdir(resolved).catch((e) => {
         throw fixError(e, { [resolved]: path });
     });
@@ -649,8 +650,12 @@ export async function readdir(path, options) {
     }
     const values = [];
     for (const entry of entries) {
-        const fullPath = join(path, entry);
-        const stats = options?.recursive || options?.withFileTypes ? await stat(fullPath) : null;
+        let stats;
+        if (options?.recursive || options?.withFileTypes) {
+            stats = await fs.stat(join(resolved, entry)).catch((error) => {
+                throw fixError(error, { [resolved]: path });
+            });
+        }
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, stats));
         }
@@ -663,7 +668,7 @@ export async function readdir(path, options) {
         if (!options?.recursive || !stats?.isDirectory()) {
             continue;
         }
-        for (const subEntry of await readdir(fullPath, options)) {
+        for (const subEntry of await readdir(join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -861,9 +866,12 @@ export async function realpath(path, options) {
         if (!stats.isSymbolicLink()) {
             return lpath;
         }
-        return realpath(mountPoint + (await readlink(lpath)));
+        return await realpath(mountPoint + (await readlink(lpath)));
     }
     catch (e) {
+        if (e.code == 'ENOENT') {
+            return path;
+        }
         throw fixError(e, { [resolvedPath]: lpath });
     }
 }
@@ -972,9 +980,9 @@ copyFile;
  * @returns A `Dir` object representing the opened directory.
  * @todo Use options
  */
-export async function opendir(path, options) {
+export function opendir(path, options) {
     path = normalizePath(path);
-    return new Dir(path);
+    return Promise.resolve(new Dir(path));
 }
 opendir;
 /**
@@ -1026,8 +1034,8 @@ export async function cp(source, destination, opts) {
     }
 }
 cp;
-export async function statfs(path, opts) {
+export function statfs(path, opts) {
     path = normalizePath(path);
     const { fs } = resolveMount(path);
-    return _statfs(fs, opts?.bigint);
+    return Promise.resolve(_statfs(fs, opts?.bigint));
 }

package/dist/emulation/shared.d.ts

@@ -1,4 +1,5 @@
 import type { BigIntStatsFs, StatsFs } from 'node:fs';
+import { ErrnoError } from '../error.js';
 import type { File } from '../file.js';
 import type { FileSystem } from '../filesystem.js';
 import { type AbsolutePath } from './path.js';
@@ -36,7 +37,7 @@ export declare function fixPaths(text: string, paths: Record<string, string>): s
  * Fix paths in error stacks
  * @hidden
  */
-export declare function fixError<E extends Error>(e: E, paths: Record<string, string>): E;
+export declare function fixError<E extends ErrnoError>(e: E, paths: Record<string, string>): E;
 export declare function mountObject(mounts: MountObject): void;
 /**
  * @hidden

package/dist/emulation/sync.d.ts

@@ -199,6 +199,7 @@ export declare function writevSync(fd: number, buffers: readonly ArrayBufferView
  * @param path The path to the directory.
  * @param options Options for opening the directory.
  * @returns A `Dir` object representing the opened directory.
+ * @todo Handle options
  */
 export declare function opendirSync(path: fs.PathLike, options?: fs.OpenDirOptions): Dir;
 /**

package/dist/emulation/sync.js

@@ -97,11 +97,11 @@ export function existsSync(path) {
 existsSync;
 export function statSync(path, options) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
         const stats = fs.statSync(resolved);
         if (!stats.hasAccess(constants.R_OK)) {
-            throw ErrnoError.With('EACCES', path, 'stat');
+            throw ErrnoError.With('EACCES', resolved, 'stat');
         }
         return options?.bigint ? new BigIntStats(stats) : stats;
     }
@@ -159,9 +159,16 @@ unlinkSync;
 function _openSync(path, _flag, _mode, resolveSymlinks = true) {
     path = normalizePath(path);
     const mode = normalizeMode(_mode, 0o644), flag = parseFlag(_flag);
-    path = resolveSymlinks && existsSync(path) ? realpathSync(path) : path;
+    path = resolveSymlinks ? realpathSync(path) : path;
     const { fs, path: resolved } = resolveMount(path);
-    if (!fs.existsSync(resolved)) {
+    let stats;
+    try {
+        stats = fs.statSync(resolved);
+    }
+    catch {
+        // nothing
+    }
+    if (!stats) {
         if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
             throw ErrnoError.With('ENOENT', path, '_open');
         }
@@ -175,7 +182,6 @@ function _openSync(path, _flag, _mode, resolveSymlinks = true) {
         }
         return fs.createFileSync(resolved, flag, mode);
     }
-    const stats = fs.statSync(resolved);
     if (!stats.hasAccess(mode) || !stats.hasAccess(flagToMode(flag))) {
         throw ErrnoError.With('EACCES', path, '_open');
     }
@@ -384,7 +390,7 @@ export function futimesSync(fd, atime, mtime) {
 futimesSync;
 export function rmdirSync(path) {
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
         if (!fs.statSync(resolved).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'rmdir');
@@ -400,8 +406,7 @@ rmdirSync;
 export function mkdirSync(path, options) {
     options = typeof options === 'object' ? options : { mode: options };
     const mode = normalizeMode(options?.mode, 0o777);
-    path = normalizePath(path);
-    path = existsSync(path) ? realpathSync(path) : path;
+    path = realpathSync(normalizePath(path));
     const { fs, path: resolved } = resolveMount(path);
     const errorPaths = { [resolved]: path };
     try {
@@ -433,12 +438,12 @@ mkdirSync;
 export function readdirSync(path, options) {
     options = typeof options === 'object' ? options : { encoding: options };
     path = normalizePath(path);
-    const { fs, path: resolved } = resolveMount(existsSync(path) ? realpathSync(path) : path);
+    const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
-    if (!statSync(path).hasAccess(constants.R_OK)) {
-        throw ErrnoError.With('EACCES', path, 'readdir');
-    }
     try {
+        if (!fs.statSync(resolved).hasAccess(constants.R_OK)) {
+            throw ErrnoError.With('EACCES', path, 'readdir');
+        }
         entries = fs.readdirSync(resolved);
     }
     catch (e) {
@@ -458,8 +463,7 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const fullPath = join(path, entry);
-        const entryStat = statSync(fullPath);
+        const entryStat = fs.statSync(join(resolved, entry));
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -471,7 +475,7 @@ export function readdirSync(path, options) {
         }
         if (!entryStat.isDirectory() || !options?.recursive)
             continue;
-        for (const subEntry of readdirSync(fullPath, options)) {
+        for (const subEntry of readdirSync(join(path, entry), options)) {
             if (subEntry instanceof Dirent) {
                 subEntry.path = join(entry, subEntry.path);
                 values.push(subEntry);
@@ -596,13 +600,15 @@ export function realpathSync(path, options) {
         return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
     }
     catch (e) {
+        if (e.code == 'ENOENT') {
+            return path;
+        }
         throw fixError(e, { [resolvedPath]: lpath });
     }
 }
 realpathSync;
 export function accessSync(path, mode = 0o600) {
-    const stats = statSync(path);
-    if (!stats.hasAccess(mode)) {
+    if (!statSync(path).hasAccess(mode)) {
         throw new ErrnoError(Errno.EACCES);
     }
 }
@@ -706,6 +712,7 @@ writevSync;
  * @param path The path to the directory.
  * @param options Options for opening the directory.
  * @returns A `Dir` object representing the opened directory.
+ * @todo Handle options
  */
 export function opendirSync(path, options) {
     path = normalizePath(path);

package/dist/error.js

@@ -261,7 +261,7 @@ export class ErrnoError extends Error {
         this.path = path;
         this.syscall = syscall;
         this.code = Errno[errno];
-        this.message = `${this.code}: ${message}${this.path ? `, '${this.path}'` : ''}`;
+        this.message = this.code + ': ' + message + (this.path ? `, '${this.path}'` : '');
     }
     /**
      * @returns A friendly error message.

package/eslint.shared.js

@@ -44,6 +44,7 @@ export default [
 			'@typescript-eslint/no-redundant-type-constituents': 'warn',
 			'@typescript-eslint/no-unsafe-call': 'warn',
 			'@typescript-eslint/restrict-plus-operands': 'off',
+			'@typescript-eslint/no-base-to-string': 'off',
 		},
 	},
 	{

package/license.md

@@ -1,6 +1,6 @@
 Copyright (c) James Prevett and other ZenFS contributors.
 Copyright (c) 2013-2023 John Vilk and other BrowserFS contributors.
-Copyright (c) Joyent, Inc. and other Node contributors for `test/fixtures/node`.
+Copyright (c) Joyent, Inc. and other Node contributors for `test/data`.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.1.3",
+	"version": "1.1.5",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -14,11 +14,12 @@
 		"storage"
 	],
 	"bin": {
-		"make-index": "scripts/make-index.js"
+		"make-index": "scripts/make-index.js",
+		"zenfs-test": "scripts/test.js"
 	},
 	"files": [
 		"dist",
-		"src",
+		"tests",
 		"license.md",
 		"tsconfig.json",
 		"eslint.shared.js"
@@ -52,6 +53,7 @@
 		"format": "prettier --write .",
 		"format:check": "prettier --check .",
 		"lint": "eslint src tests",
+		"test:common": "tsx --test --experimental-test-coverage 'tests/**/!(fs)/*.test.ts' 'tests/*.test.ts'",
 		"test": "tsx --test --experimental-test-coverage",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc",

package/readme.md

@@ -29,15 +29,10 @@ npm install @zenfs/core
 
 ## Usage
 
-> [!NOTE]
-> The examples are written in ESM.  
-> If you are using CJS, you can `require` the package.  
-> If using a browser environment, you can use a `<script>` with `type=module` (you may need to use import maps)
-
 ```js
-import fs from '@zenfs/core'; // You can also use the named export, `fs`
+import { fs } from '@zenfs/core'; // You can also use the default export
 
-fs.writeFileSync('/test.txt', 'Cool, I can do this in any JS environment (including browsers)!');
+fs.writeFileSync('/test.txt', 'You can do this in anywhere (including browsers)!');
 
 const contents = fs.readFileSync('/test.txt', 'utf-8');
 console.log(contents);
@@ -148,7 +143,7 @@ fs.umount('/mnt/zip'); // finished using the zip
 > [!CAUTION]
 > Instances of backends follow the _internal_ API. You should never use a backend's methods unless you are extending a backend.
 
-#### Devices and device files
+### Devices and device files
 
 > [!WARNING]
 > This is an **experimental** feature. Breaking changes may occur during non-major releases. Using this feature is the fastest way to make it stable.

package/scripts/make-index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
-import { readdirSync, statSync, writeFileSync } from 'fs';
+import { readdirSync, statSync, writeFileSync } from 'node:fs';
 import { minimatch } from 'minimatch';
-import { join, relative, resolve } from 'path/posix';
-import { parseArgs } from 'util';
+import { join, relative, resolve } from 'node:path/posix';
+import { parseArgs } from 'node:util';
 
 const { values: options, positionals } = parseArgs({
 	options: {

package/scripts/test.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+
+import { execSync } from 'node:child_process';
+import { join } from 'node:path';
+import { parseArgs } from 'node:util';
+
+const { values: options, positionals } = parseArgs({
+	options: {
+		help: { short: 'h', type: 'boolean', default: false },
+		verbose: { type: 'boolean', default: false },
+	},
+	allowPositionals: true,
+});
+
+if (options.help) {
+	console.log(`zenfs-test [...options] <...paths> 
+
+paths: The setup files to run tests on
+
+options:
+	--help, -h		Outputs this help message
+	--verbose		Output verbose messages
+	`);
+	process.exit();
+}
+
+for (const setupFile of positionals) {
+	if (options.verbose) console.debug('Running tests for:', setupFile);
+	process.env.SETUP = setupFile;
+	execSync('tsx --test --experimental-test-coverage ' + join(import.meta.dirname, '../tests/fs/*.test.ts'), { stdio: 'inherit' });
+}

package/tests/assignment.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+
+/*
+	This test assigns the exported fs module from ZenFS with the one exported from Node.
+	This ensures anything new that is added will be caught
+
+	Notes on omissions and exclusions:
+	- __promisify__ is omitted as it is metadata
+	- native is omitted as zenfs isn't native
+	- ReadStream and WriteStream are excluded since they are polfilled from another module
+*/
+
+import { fs as zen } from '../src/index.js';
+import type * as node from 'node:fs';
+
+type Mock = {
+	[K in Exclude<keyof typeof node, 'ReadStream' | 'WriteStream'>]: Omit<(typeof node)[K], '__promisify__' | 'native'>;
+};
+
+const _module: Mock = zen;

package/tests/common.ts

@@ -0,0 +1,21 @@
+import { join, resolve } from 'node:path';
+import { Worker } from 'node:worker_threads';
+import { fs } from '../src/index.js';
+
+/**
+ * Creates a Typescript Worker
+ * @see https://github.com/privatenumber/tsx/issues/354
+ * @see https://github.com/nodejs/node/issues/47747#issuecomment-2287745567
+ */
+export function createTSWorker(source: string): Worker {
+	return new Worker(`import('tsx/esm/api').then(tsx => {tsx.register();import('${source}');});`, { eval: true });
+}
+
+const setupPath = resolve(process.env.SETUP || join(import.meta.dirname, 'setup/memory.ts'));
+
+await import(setupPath).catch(error => {
+	console.log('Failed to import test setup:');
+	throw error;
+});
+
+export { fs };

package/tests/data/49chars.txt

@@ -0,0 +1 @@
+0123456789abcdef0123456789abcdef0123456789abcdef