@zenfs/core 1.10.4 → 1.11.1

package/dist/backends/cow.d.ts

@@ -1,18 +1,19 @@
 import type { File } from '../internal/file.js';
-import type { CreationOptions, UsageInfo } from '../internal/filesystem.js';
+import type { CreationOptions, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { Stats } from '../stats.js';
 import { FileSystem } from '../internal/filesystem.js';
 import { EventEmitter } from 'eventemitter3';
+import { type MountConfiguration } from '../config.js';
 /**
  * Configuration options for CoW.
  * @category Backends and Configuration
  */
 export interface CopyOnWriteOptions {
     /** The file system that initially populates this file system. */
-    readable: FileSystem;
+    readable: MountConfiguration<any>;
     /** The file system to write modified files to. */
-    writable: FileSystem;
+    writable: MountConfiguration<any>;
     /** @see {@link Journal} */
     journal?: Journal;
 }
@@ -98,6 +99,8 @@ export declare class CopyOnWriteFS extends FileSystem {
     mkdirSync(path: string, mode: number, options: CreationOptions): void;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
+    streamRead(path: string, options: StreamOptions): ReadableStream;
+    streamWrite(path: string, options: StreamOptions): WritableStream;
     /**
      * Create the needed parent directories on the writable storage should they not exist.
      * Use modes from the read-only storage.
@@ -143,7 +146,7 @@ declare const _CopyOnWrite: {
             readonly required: false;
         };
     };
-    readonly create: (options: CopyOnWriteOptions) => CopyOnWriteFS;
+    readonly create: (options: CopyOnWriteOptions) => Promise<CopyOnWriteFS>;
 };
 type _CopyOnWrite = typeof _CopyOnWrite;
 export interface CopyOnWrite extends _CopyOnWrite {

package/dist/backends/cow.js

@@ -57,6 +57,7 @@ import { FileSystem } from '../internal/filesystem.js';
 import { debug, err, warn } from '../internal/log.js';
 import { dirname, join } from '../vfs/path.js';
 import { EventEmitter } from 'eventemitter3';
+import { resolveMountConfig } from '../config.js';
 const journalOperations = ['delete'];
 /** Because TS doesn't work right w/o it */
 function isJournalOp(op) {
@@ -323,9 +324,9 @@ export class CopyOnWriteFS extends FileSystem {
         this.writable.mkdirSync(path, mode, options);
     }
     async readdir(path) {
-        if (this.isDeleted(path))
+        if (this.isDeleted(path) || !(await this.exists(path)))
             throw ErrnoError.With('ENOENT', path, 'readdir');
-        const entries = await this.writable.readdir(path);
+        const entries = (await this.readable.exists(path)) ? await this.readable.readdir(path) : [];
         if (await this.writable.exists(path))
             for (const entry of await this.writable.readdir(path)) {
                 if (!entries.includes(entry))
@@ -334,9 +335,9 @@ export class CopyOnWriteFS extends FileSystem {
         return entries.filter(entry => !this.isDeleted(join(path, entry)));
     }
     readdirSync(path) {
-        if (this.isDeleted(path))
+        if (this.isDeleted(path) || !this.existsSync(path))
             throw ErrnoError.With('ENOENT', path, 'readdir');
-        const entries = this.writable.readdirSync(path);
+        const entries = this.readable.existsSync(path) ? this.readable.readdirSync(path) : [];
         if (this.writable.existsSync(path))
             for (const entry of this.writable.readdirSync(path)) {
                 if (!entries.includes(entry))
@@ -344,6 +345,13 @@ export class CopyOnWriteFS extends FileSystem {
             }
         return entries.filter(entry => !this.isDeleted(join(path, entry)));
     }
+    streamRead(path, options) {
+        return this.writable.existsSync(path) ? this.writable.streamRead(path, options) : this.readable.streamRead(path, options);
+    }
+    streamWrite(path, options) {
+        this.copyForWriteSync(path);
+        return this.writable.streamWrite(path, options);
+    }
     /**
      * Create the needed parent directories on the writable storage should they not exist.
      * Use modes from the read-only storage.
@@ -478,8 +486,10 @@ const _CopyOnWrite = {
         readable: { type: 'object', required: true },
         journal: { type: 'object', required: false },
     },
-    create(options) {
-        return new CopyOnWriteFS(options.readable, options.writable, options.journal);
+    async create(options) {
+        const readable = await resolveMountConfig(options.readable);
+        const writable = await resolveMountConfig(options.writable);
+        return new CopyOnWriteFS(readable, writable, options.journal);
     },
 };
 /**

package/dist/backends/fetch.js

@@ -50,7 +50,6 @@ export class FetchFS extends IndexFS {
         const inode = this.index.get(path);
         if (!inode)
             throw ErrnoError.With('ENOENT', path, 'read');
-        end !== null && end !== void 0 ? end : (end = inode.size);
         if (end - offset == 0)
             return;
         const data = await requests
@@ -65,7 +64,6 @@ export class FetchFS extends IndexFS {
         const inode = this.index.get(path);
         if (!inode)
             throw ErrnoError.With('ENOENT', path, 'read');
-        end !== null && end !== void 0 ? end : (end = inode.size);
         if (end - offset == 0)
             return;
         const { data, missing } = requests.getCached(this.baseUrl + path, { start: offset, end, size: inode.size, warn });
@@ -78,9 +76,17 @@ export class FetchFS extends IndexFS {
         buffer.set(data);
     }
     async write(path, data, offset) {
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'write');
+        inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
         await requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError(path, this));
     }
     writeSync(path, data, offset) {
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'write');
+        inode.update({ mtimeMs: Date.now(), size: Math.max(inode.size, data.byteLength + offset) });
         this._async(requests.set(this.baseUrl + path, data, { offset, warn, cacheOnly: !this.remoteWrite }, this.requestInit).catch(parseError(path, this)));
     }
 }

package/dist/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference path="../types/readable-stream.d.ts" preserve="true" />
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';

package/dist/index.js

@@ -1,5 +1,3 @@
-// eslint-disable-next-line @typescript-eslint/triple-slash-reference
-/// <reference path="../types/readable-stream.d.ts" preserve="true" />
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';

package/dist/internal/filesystem.d.ts

@@ -96,6 +96,16 @@ export type FileSystemAttributes = {
      * This should be set for read-only file systems.
      */
     no_write: void;
+    /**
+     * The FS is using the default implementation for `streamRead`
+     * @internal
+     */
+    default_stream_read: void;
+    /**
+     * The FS is using the default implementation for `streamWrite`
+     * @internal
+     */
+    default_stream_write: void;
 };
 /**
  * Options used when creating files and directories.
@@ -131,6 +141,13 @@ export interface PureCreationOptions extends CreationOptions {
      */
     mode: number;
 }
+/**
+ * @internal
+ */
+export interface StreamOptions {
+    start?: number;
+    end?: number;
+}
 /**
  * Provides a consistent and easy to use internal API.
  * Default implementations for `exists` and `existsSync` are included.
@@ -158,7 +175,7 @@ export declare abstract class FileSystem {
     /**
      * @see FileSystemAttributes
      */
-    readonly attributes: ConstMap<FileSystemAttributes>;
+    readonly attributes: ConstMap<FileSystemAttributes> & Map<string, any>;
     constructor(
     /**
      * A unique ID for this kind of file system.
@@ -253,4 +270,14 @@ export declare abstract class FileSystem {
      * @param offset The offset in the file to start writing
      */
     abstract writeSync(path: string, buffer: Uint8Array, offset: number): void;
+    /**
+     * Read a file using a stream.
+     * @privateRemarks The default implementation of `streamRead` uses "chunked" `read`s
+     */
+    streamRead(path: string, options: StreamOptions): ReadableStream;
+    /**
+     * Write a file using stream.
+     * @privateRemarks The default implementation of `streamWrite` uses "chunked" `write`s
+     */
+    streamWrite(path: string, options: StreamOptions): WritableStream;
 }

package/dist/internal/filesystem.js

@@ -1,3 +1,4 @@
+const _chunkSize = 0x1000;
 /**
  * Provides a consistent and easy to use internal API.
  * Default implementations for `exists` and `existsSync` are included.
@@ -23,6 +24,10 @@ export class FileSystem {
          * @see FileSystemAttributes
          */
         this.attributes = new Map();
+        if (this.streamRead === FileSystem.prototype.streamRead)
+            this.attributes.set('default_stream_read');
+        if (this.streamWrite === FileSystem.prototype.streamWrite)
+            this.attributes.set('default_stream_write');
     }
     toString() {
         var _a;
@@ -81,4 +86,38 @@ export class FileSystem {
             return e.code != 'ENOENT';
         }
     }
+    /**
+     * Read a file using a stream.
+     * @privateRemarks The default implementation of `streamRead` uses "chunked" `read`s
+     */
+    streamRead(path, options) {
+        return new ReadableStream({
+            start: async (controller) => {
+                const { size } = await this.stat(path);
+                const { start = 0, end = size } = options;
+                for (let offset = start; offset < end; offset += _chunkSize) {
+                    const bytesRead = offset + _chunkSize > end ? end - offset : _chunkSize;
+                    const buffer = new Uint8Array(bytesRead);
+                    await this.read(path, buffer, offset, offset + bytesRead).catch(controller.error.bind(controller));
+                    controller.enqueue(buffer);
+                }
+                controller.close();
+            },
+            type: 'bytes',
+        });
+    }
+    /**
+     * Write a file using stream.
+     * @privateRemarks The default implementation of `streamWrite` uses "chunked" `write`s
+     */
+    streamWrite(path, options) {
+        var _a;
+        let position = (_a = options.start) !== null && _a !== void 0 ? _a : 0;
+        return new WritableStream({
+            write: async (chunk, controller) => {
+                await this.write(path, chunk, position).catch(controller.error.bind(controller));
+                position += chunk.byteLength;
+            },
+        });
+    }
 }

package/dist/internal/log.d.ts

@@ -96,7 +96,7 @@ export declare const formats: {
     readonly ansi_message: (this: void, entry: Entry) => string;
     readonly css_level: (this: void, entry: Entry) => string[];
     readonly css_message: (this: void, entry: Entry) => string[];
-    readonly default: (this: void, entry: Entry) => string;
+    readonly default: (this: void, entry: Entry) => string[];
 };
 export declare function format(entry: Entry): string[];
 /** Whether log entries are being recorded */

package/dist/internal/log.js

@@ -172,20 +172,20 @@ export const formats = {
     },
     css_level(entry) {
         const levelLabel = levels[entry.level].toUpperCase();
-        return [..._prettyMs(entry, 'css'), `%c${levelLabel}%c ${entry.message}`, _cssLevelColor[entry.level], ''];
+        return [..._prettyMs(entry, 'css'), '%c' + levelLabel, _cssLevelColor[entry.level], entry.message];
     },
     css_message(entry) {
         const text = _prettyMs(entry, 'css');
         const isImportant = entry.level < Level.CRIT;
         if (isImportant) {
             const levelLabel = levels[entry.level].toUpperCase();
-            text.push(`%c${levelLabel}%c:`, _cssLevelColor[entry.level], '');
+            text.push('%c' + levelLabel, _cssLevelColor[entry.level]);
         }
         text.push('%c' + entry.message, _cssMessageColor[entry.level]);
         return text;
     },
     default(entry) {
-        return `[${_prettyMs(entry)}] ${entry.message}`;
+        return [_prettyMs(entry), entry.message];
     },
 };
 let _format = formats.default;

package/dist/mixins/async.js

@@ -186,6 +186,22 @@ export function Async(FS) {
             this._sync.writeSync(path, buffer, offset);
             this._async(this.write(path, buffer, offset));
         }
+        streamWrite(path, options) {
+            this.checkSync(path, 'streamWrite');
+            const sync = this._sync.streamWrite(path, options).getWriter();
+            const async = super.streamWrite(path, options).getWriter();
+            return new WritableStream({
+                async write(chunk, controller) {
+                    await Promise.all([sync.write(chunk), async.write(chunk)]).catch(controller.error.bind(controller));
+                },
+                async close() {
+                    await Promise.all([sync.close(), async.close()]);
+                },
+                async abort(reason) {
+                    await Promise.all([sync.abort(reason), async.abort(reason)]);
+                },
+            });
+        }
         /**
          * @internal
          */

package/dist/mixins/mutexed.d.ts

@@ -1,5 +1,5 @@
 import type { File } from '../internal/file.js';
-import type { CreationOptions, FileSystem, FileSystemMetadata, UsageInfo } from '../internal/filesystem.js';
+import type { CreationOptions, FileSystem, FileSystemMetadata, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
 import type { Stats } from '../stats.js';
 import type { Concrete } from '../utils.js';
@@ -31,7 +31,7 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     get name(): string;
     get label(): string | undefined;
     set label(value: string | undefined);
-    get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void>;
+    get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void> & Map<string, any>;
     ready(): Promise<void>;
     usage(): UsageInfo;
     metadata(): FileSystemMetadata;
@@ -86,6 +86,8 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
     writeSync(path: string, buffer: Uint8Array, offset: number): void;
+    streamRead(path: string, options: StreamOptions): ReadableStream;
+    streamWrite(path: string, options: StreamOptions): WritableStream;
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/mutexed.js

@@ -528,6 +528,34 @@ export class _MutexedFS {
             __disposeResources(env_26);
         }
     }
+    streamRead(path, options) {
+        const env_27 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_27, this.lockSync(path, 'streamRead'), false);
+            return this._fs.streamRead(path, options);
+        }
+        catch (e_27) {
+            env_27.error = e_27;
+            env_27.hasError = true;
+        }
+        finally {
+            __disposeResources(env_27);
+        }
+    }
+    streamWrite(path, options) {
+        const env_28 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_28, this.lockSync(path, 'streamWrite'), false);
+            return this._fs.streamWrite(path, options);
+        }
+        catch (e_28) {
+            env_28.error = e_28;
+            env_28.hasError = true;
+        }
+        finally {
+            __disposeResources(env_28);
+        }
+    }
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/readonly.js

@@ -58,6 +58,9 @@ export function Readonly(FS) {
         writeSync() {
             throw new ErrnoError(Errno.EROFS);
         }
+        streamWrite() {
+            throw new ErrnoError(Errno.EROFS);
+        }
     }
     return ReadonlyFS;
 }

package/dist/stats.d.ts

@@ -4,6 +4,7 @@ import type { InodeFields, InodeLike } from './internal/inode.js';
 import * as c from './vfs/constants.js';
 /**
  * Indicates the type of a file. Applied to 'mode'.
+ * @deprecated
  */
 export type FileType = typeof c.S_IFREG | typeof c.S_IFDIR | typeof c.S_IFLNK;
 export interface StatsLike<T extends number | bigint = number | bigint> {
@@ -60,7 +61,6 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
     set blocks(value: T);
     /**
      * Unix-style file mode (e.g. 0o644) that includes the type of the item.
-     * Type of the item can be FILE, DIRECTORY, SYMLINK, or SOCKET
      */
     mode: T;
     /**

package/dist/vfs/async.d.ts

@@ -7,8 +7,7 @@ import type { FileContents } from './types.js';
 import { Buffer } from 'buffer';
 import { ErrnoError } from '../internal/error.js';
 import { BigIntStats } from '../stats.js';
-import * as promises from './promises.js';
-import { ReadStream, WriteStream } from './streams.js';
+import { ReadStream, WriteStream, type ReadStreamOptions, type WriteStreamOptions } from './streams.js';
 import { FSWatcher } from './watchers.js';
 /**
  * Asynchronous rename. No arguments other than a possible exception are given to the completion callback.
@@ -237,34 +236,6 @@ export declare function watch(this: V_Context, path: fs.PathLike, listener?: (ev
 export declare function watch(this: V_Context, path: fs.PathLike, options: {
     persistent?: boolean;
 }, listener?: (event: string, filename: string) => any): FSWatcher;
-interface StreamOptions {
-    flags?: string;
-    encoding?: BufferEncoding;
-    fd?: number | promises.FileHandle;
-    mode?: number;
-    autoClose?: boolean;
-    emitClose?: boolean;
-    start?: number;
-    signal?: AbortSignal;
-    highWaterMark?: number;
-}
-interface FSImplementation {
-    open?: (...args: unknown[]) => unknown;
-    close?: (...args: unknown[]) => unknown;
-}
-interface ReadStreamOptions extends StreamOptions {
-    fs?: FSImplementation & {
-        read: (...args: unknown[]) => unknown;
-    };
-    end?: number;
-}
-interface WriteStreamOptions extends StreamOptions {
-    fs?: FSImplementation & {
-        write: (...args: unknown[]) => unknown;
-        writev?: (...args: unknown[]) => unknown;
-    };
-    flush?: boolean;
-}
 /**
  * Opens a file in read mode and creates a Node.js-like ReadStream.
  *

package/dist/vfs/async.js

@@ -421,47 +421,9 @@ watch;
  * @returns A ReadStream object for interacting with the file's contents.
  */
 export function createReadStream(path, options) {
-    var _a;
     options = typeof options == 'object' ? options : { encoding: options };
     const _handle = promises.open.call(this, path, 'r', options === null || options === void 0 ? void 0 : options.mode);
-    void _handle.then(handle => {
-        if (typeof options.start == 'number')
-            handle.file.position = options.start;
-    });
-    let handle;
-    const stream = new ReadStream({
-        highWaterMark: options.highWaterMark || 0x1000,
-        encoding: (_a = options.encoding) !== null && _a !== void 0 ? _a : undefined,
-        async read(size) {
-            var _a;
-            try {
-                handle || (handle = await _handle);
-                const start = (_a = options.start) !== null && _a !== void 0 ? _a : handle.file.position;
-                if (typeof options.end === 'number' && start >= options.end) {
-                    stream.push(null);
-                    await handle.close();
-                    return;
-                }
-                if (typeof options.end === 'number') {
-                    size = Math.min(size, options.end - start);
-                }
-                const result = await handle.read(new Uint8Array(size), 0, size);
-                stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead));
-                if (!result.bytesRead)
-                    await handle.close();
-            }
-            catch (error) {
-                await (handle === null || handle === void 0 ? void 0 : handle.close());
-                stream.destroy(error);
-            }
-        },
-        async destroy(error, callback) {
-            await (handle === null || handle === void 0 ? void 0 : handle.close().catch(nop));
-            callback(error);
-        },
-    });
-    stream.path = path.toString();
-    return stream;
+    return new ReadStream({ ...options, autoClose: true }, _handle);
 }
 createReadStream;
 /**
@@ -474,39 +436,7 @@ createReadStream;
 export function createWriteStream(path, options) {
     options = typeof options == 'object' ? options : { encoding: options };
     const _handle = promises.open.call(this, path, 'w', options === null || options === void 0 ? void 0 : options.mode);
-    void _handle.then(handle => {
-        if (typeof options.start == 'number')
-            handle.file.position = options.start;
-    });
-    let handle;
-    const { stack } = new Error();
-    const stream = new WriteStream({
-        highWaterMark: options === null || options === void 0 ? void 0 : options.highWaterMark,
-        async write(chunk, encoding, callback) {
-            try {
-                handle || (handle = await _handle);
-                const { bytesWritten } = await handle.write(chunk, null, encoding);
-                if (bytesWritten == chunk.length)
-                    return callback();
-                throw new ErrnoError(Errno.EIO, `Failed to write full chunk of write stream (wrote ${bytesWritten}/${chunk.length} bytes)`, handle.file.path);
-            }
-            catch (error) {
-                await (handle === null || handle === void 0 ? void 0 : handle.close());
-                error.stack += stack === null || stack === void 0 ? void 0 : stack.slice(5);
-                callback(error);
-            }
-        },
-        async destroy(error, callback) {
-            await (handle === null || handle === void 0 ? void 0 : handle.close().catch(callback));
-            callback(error);
-        },
-        async final(callback) {
-            await (handle === null || handle === void 0 ? void 0 : handle.close().catch(nop));
-            callback();
-        },
-    });
-    stream.path = path.toString();
-    return stream;
+    return new WriteStream(options, _handle);
 }
 createWriteStream;
 export function rm(path, options, callback = nop) {

package/dist/vfs/promises.d.ts

@@ -1,7 +1,8 @@
 import type * as fs from 'node:fs';
 import type * as promises from 'node:fs/promises';
+import type { Interface as ReadlineInterface } from 'node:readline';
 import type { Stream } from 'node:stream';
-import type { Interface as ReadlineInterface } from 'readline';
+import type { ReadableStream as NodeReadableStream } from 'node:stream/web';
 import type { V_Context } from '../context.js';
 import type { File } from '../internal/file.js';
 import type { Stats } from '../stats.js';
@@ -88,7 +89,7 @@ export declare class FileHandle implements promises.FileHandle {
      * Read file data using a `ReadableStream`.
      * The handle will not be closed automatically.
      */
-    readableWebStream(options?: promises.ReadableWebStreamOptions): ReadableStream<Uint8Array>;
+    readableWebStream(options?: promises.ReadableWebStreamOptions): NodeReadableStream<Uint8Array>;
     /**
      * @todo Implement
      */

package/dist/vfs/promises.js

@@ -51,6 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Buffer } from 'buffer';
+import { _throw } from 'utilium';
 import { credentials } from '../internal/credentials.js';
 import { Errno, ErrnoError } from '../internal/error.js';
 import { flagToMode, isAppendable, isExclusive, isReadable, isTruncating, isWriteable, parseFlag } from '../internal/file.js';
@@ -64,7 +65,6 @@ import { dirname, join, parse, resolve } from './path.js';
 import { _statfs, fd2file, fdMap, file2fd, fixError, resolveMount } from './shared.js';
 import { ReadStream, WriteStream } from './streams.js';
 import { FSWatcher, emitChange } from './watchers.js';
-import { _throw } from 'utilium';
 export * as constants from './constants.js';
 export class FileHandle {
     constructor(fdOrFile, context) {
@@ -184,23 +184,7 @@ export class FileHandle {
      * The handle will not be closed automatically.
      */
     readableWebStream(options = {}) {
-        return new ReadableStream({
-            start: async (controller) => {
-                const chunkSize = 0x1000;
-                for (let i = 0; i < 1e7; i++) {
-                    const result = await this.read(new Uint8Array(chunkSize), 0, chunkSize).catch(controller.error);
-                    if (!result)
-                        return;
-                    if (!result.bytesRead) {
-                        controller.close();
-                        return;
-                    }
-                    controller.enqueue(result.buffer.subarray(0, result.bytesRead));
-                }
-                controller.error(new ErrnoError(Errno.EFBIG, 'Too many iterations on readable stream', this.file.path, 'readableWebStream'));
-            },
-            type: options.type,
-        });
+        return this.file.fs.streamRead(this.file.path, {});
     }
     /**
      * @todo Implement
@@ -312,59 +296,15 @@ export class FileHandle {
      * Creates a stream for reading from the file.
      * @param options Options for the readable stream
      */
-    createReadStream(options) {
-        var _a, _b;
-        const start = (_a = options === null || options === void 0 ? void 0 : options.start) !== null && _a !== void 0 ? _a : this.file.position;
-        const stream = new ReadStream({
-            highWaterMark: (options === null || options === void 0 ? void 0 : options.highWaterMark) || 64 * 1024,
-            encoding: (_b = options === null || options === void 0 ? void 0 : options.encoding) !== null && _b !== void 0 ? _b : undefined,
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
-            read: async (size) => {
-                try {
-                    if (typeof (options === null || options === void 0 ? void 0 : options.end) === 'number' && start >= options.end) {
-                        stream.push(null);
-                        return;
-                    }
-                    if (typeof (options === null || options === void 0 ? void 0 : options.end) === 'number') {
-                        size = Math.min(size, options.end - start);
-                    }
-                    const result = await this.read(new Uint8Array(size), 0, size, options === null || options === void 0 ? void 0 : options.start);
-                    stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead));
-                }
-                catch (error) {
-                    stream.destroy(error);
-                }
-            },
-        });
-        stream.path = this.file.path;
-        return stream;
+    createReadStream(options = {}) {
+        return new ReadStream(options, this);
     }
     /**
      * Creates a stream for writing to the file.
      * @param options Options for the writeable stream.
      */
-    createWriteStream(options) {
-        if (typeof (options === null || options === void 0 ? void 0 : options.start) == 'number')
-            this.file.position = options.start;
-        const { stack } = new Error();
-        const stream = new WriteStream({
-            highWaterMark: options === null || options === void 0 ? void 0 : options.highWaterMark,
-            // eslint-disable-next-line @typescript-eslint/no-misused-promises
-            write: async (chunk, encoding, callback) => {
-                try {
-                    const { bytesWritten } = await this.write(chunk, null, encoding);
-                    if (bytesWritten == chunk.length)
-                        return callback();
-                    throw new ErrnoError(Errno.EIO, `Failed to write full chunk of write stream (wrote ${bytesWritten}/${chunk.length} bytes)`);
-                }
-                catch (error) {
-                    error.stack += stack === null || stack === void 0 ? void 0 : stack.slice(5);
-                    callback(error);
-                }
-            },
-        });
-        stream.path = this.file.path;
-        return stream;
+    createWriteStream(options = {}) {
+        return new WriteStream(options, this);
     }
 }
 export async function rename(oldPath, newPath) {

package/dist/vfs/shared.js

@@ -46,13 +46,12 @@ export function mount(mountPoint, fs) {
     if (mountPoint[0] != '/')
         mountPoint = '/' + mountPoint;
     mountPoint = resolve(mountPoint);
-    if (mounts.has(mountPoint)) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Mount point ' + mountPoint + ' is already in use'));
-    }
+    if (mounts.has(mountPoint))
+        throw err(new ErrnoError(Errno.EINVAL, 'Mount point is already in use: ' + mountPoint));
     fs._mountPoint = mountPoint;
     mounts.set(mountPoint, fs);
     info(`Mounted ${fs.name} on ${mountPoint}`);
-    debug(`${fs.name} attributes: ${[...fs.attributes].map(([k, v]) => (v !== undefined && v !== null ? k + '=' + v : v)).join(', ')}`);
+    debug(`${fs.name} attributes: ${[...fs.attributes].map(([k, v]) => (v !== undefined && v !== null ? k + '=' + v : k)).join(', ')}`);
 }
 /**
  * Unmounts the file system at `mountPoint`.

package/dist/vfs/streams.d.ts

@@ -1,16 +1,74 @@
+/// <reference path="../../types/readable-stream.d.ts" preserve="true" />
+import type { Abortable } from 'node:events';
 import type * as fs from 'node:fs';
+import type { CreateReadStreamOptions, CreateWriteStreamOptions } from 'node:fs/promises';
 import type { Callback } from '../utils.js';
+import type { FileHandle } from './promises.js';
 import { Readable, Writable } from 'readable-stream';
+interface FSImplementation {
+    open?: (...args: unknown[]) => unknown;
+    close?: (...args: unknown[]) => unknown;
+}
+interface StreamOptions extends Abortable {
+    flags?: string;
+    encoding?: BufferEncoding;
+    fd?: number | FileHandle;
+    mode?: number;
+    autoClose?: boolean;
+    emitClose?: boolean;
+    start?: number;
+    highWaterMark?: number;
+}
+/**
+ * This type is from node:fs but not exported.
+ * @hidden
+ */
+export interface ReadStreamOptions extends StreamOptions {
+    fs?: FSImplementation & {
+        read: (...args: unknown[]) => unknown;
+    };
+    end?: number;
+}
+/**
+ * This type is from node:fs but not exported.
+ * @hidden
+ */
+export interface WriteStreamOptions extends StreamOptions {
+    flush?: boolean;
+    fs?: FSImplementation & {
+        write: (...args: unknown[]) => unknown;
+        writev?: (...args: unknown[]) => unknown;
+    };
+}
+/**
+ * A ReadStream implementation that wraps an underlying global ReadableStream.
+ */
 export declare class ReadStream extends Readable implements fs.ReadStream {
-    close: (callback?: Callback<[void], null>) => void;
-    wrap(oldStream: NodeJS.ReadableStream): this;
-    bytesRead: number;
-    path: string | Buffer;
     pending: boolean;
+    private _path;
+    private _bytesRead;
+    private reader?;
+    constructor(opts: CreateReadStreamOptions | undefined, handleOrPromise: FileHandle | Promise<FileHandle>);
+    _read(): Promise<void>;
+    close(callback?: Callback<[void], null>): void;
+    get path(): string;
+    get bytesRead(): number;
+    wrap(oldStream: NodeJS.ReadableStream): this;
 }
+/**
+ * A WriteStream implementation that wraps an underlying global WritableStream.
+ */
 export declare class WriteStream extends Writable implements fs.WriteStream {
-    close: (callback?: Callback<[void], null>) => void;
-    bytesWritten: number;
-    path: string | Buffer;
     pending: boolean;
+    private _path;
+    private _bytesWritten;
+    private writer?;
+    private ready;
+    constructor(opts: CreateWriteStreamOptions | undefined, handleOrPromise: FileHandle | Promise<FileHandle>);
+    _write(chunk: any, encoding: BufferEncoding | 'buffer', callback: (error?: Error | null) => void): Promise<void>;
+    _final(callback: (error?: Error | null) => void): Promise<void>;
+    close(callback?: Callback<[void], null>): void;
+    get path(): string;
+    get bytesWritten(): number;
 }
+export {};

package/dist/vfs/streams.js

@@ -1,36 +1,120 @@
 import { Readable, Writable } from 'readable-stream';
 import { Errno, ErrnoError } from '../internal/error.js';
+import { warn } from '../internal/log.js';
+/**
+ * A ReadStream implementation that wraps an underlying global ReadableStream.
+ */
 export class ReadStream extends Readable {
-    constructor() {
-        super(...arguments);
-        this.close = (callback = () => null) => {
-            try {
-                super.destroy();
-                super.emit('close');
-                callback(null);
-            }
-            catch (err) {
-                callback(new ErrnoError(Errno.EIO, err.toString()));
-            }
-        };
+    constructor(opts = {}, handleOrPromise) {
+        var _a;
+        super({ ...opts, encoding: (_a = opts.encoding) !== null && _a !== void 0 ? _a : undefined });
+        this.pending = true;
+        this._path = '<unknown>';
+        this._bytesRead = 0;
+        Promise.resolve(handleOrPromise)
+            .then(({ file }) => {
+            this._path = file.path;
+            const internal = file.fs.streamRead(file.path, { start: opts.start, end: opts.end });
+            this.reader = internal.getReader();
+            this.pending = false;
+            return this._read();
+        })
+            .catch(err => this.destroy(err));
+    }
+    async _read() {
+        if (!this.reader)
+            return;
+        const { done, value } = await this.reader.read();
+        if (done) {
+            this.push(null);
+            return;
+        }
+        this._bytesRead += value.byteLength;
+        if (!this.push(value))
+            return;
+        await this._read();
+    }
+    close(callback = () => null) {
+        try {
+            this.destroy();
+            this.emit('close');
+            callback(null);
+        }
+        catch (err) {
+            callback(new ErrnoError(Errno.EIO, err.toString()));
+        }
+    }
+    get path() {
+        return this._path;
+    }
+    get bytesRead() {
+        return this._bytesRead;
     }
     wrap(oldStream) {
         super.wrap(oldStream);
         return this;
     }
 }
+/**
+ * A WriteStream implementation that wraps an underlying global WritableStream.
+ */
 export class WriteStream extends Writable {
-    constructor() {
-        super(...arguments);
-        this.close = (callback = () => null) => {
-            try {
-                super.destroy();
-                super.emit('close');
-                callback(null);
-            }
-            catch (err) {
-                callback(new ErrnoError(Errno.EIO, err.toString()));
-            }
-        };
+    constructor(opts = {}, handleOrPromise) {
+        super(opts);
+        this.pending = true;
+        this._path = '<unknown>';
+        this._bytesWritten = 0;
+        this.ready = Promise.resolve(handleOrPromise)
+            .then(({ file }) => {
+            this._path = file.path;
+            const internal = file.fs.streamWrite(file.path, { start: opts.start });
+            this.writer = internal.getWriter();
+            this.pending = false;
+        })
+            .catch(err => this.destroy(err));
+    }
+    async _write(chunk, encoding, callback) {
+        await this.ready;
+        if (!this.writer)
+            return callback(warn(new ErrnoError(Errno.EAGAIN, 'Underlying writable stream not ready', this._path)));
+        if (encoding != 'buffer')
+            return callback(warn(new ErrnoError(Errno.ENOTSUP, 'Unsupported encoding for stream', this._path)));
+        const data = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        try {
+            await this.writer.write(data);
+            this._bytesWritten += chunk.byteLength;
+            callback();
+        }
+        catch (error) {
+            callback(new ErrnoError(Errno.EIO, error.toString()));
+        }
+    }
+    async _final(callback) {
+        await this.ready;
+        if (!this.writer)
+            return callback();
+        try {
+            await this.writer.close();
+            callback();
+        }
+        catch (error) {
+            callback(new ErrnoError(Errno.EIO, error.toString()));
+        }
+    }
+    close(callback = () => null) {
+        try {
+            this.destroy();
+            this.emit('close');
+            callback(null);
+        }
+        catch (error) {
+            callback(new ErrnoError(Errno.EIO, error.toString()));
+        }
+    }
+    get path() {
+        return this._path;
+    }
+    get bytesWritten() {
+        return this._bytesWritten;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.10.4",
+	"version": "1.11.1",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -40,7 +40,7 @@
 		"url": "https://github.com/zen-fs/core/issues"
 	},
 	"engines": {
-		"node": ">= 16"
+		"node": ">= 18"
 	},
 	"exports": {
 		".": "./dist/index.js",
@@ -49,7 +49,8 @@
 		"./promises": "./dist/vfs/promises.js",
 		"./path": "./dist/vfs/path.js",
 		"./eslint": "./eslint.shared.js",
-		"./tests/*": "./tests/*"
+		"./tests/*": "./tests/*",
+		"./types/*": "./types/*"
 	},
 	"publishConfig": {
 		"access": "public",

package/tests/fs/streams.test.ts

@@ -1,7 +1,6 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { fs } from '../common.js';
-import { promisify } from 'node:util';
 
 // Top-level initialization
 const testFilePath = 'test-file.txt';
@@ -43,30 +42,6 @@ suite('Streams', () => {
 		});
 	});
 
-	test('ReadStream declared properties', () => {
-		const readStream = new fs.ReadStream();
-		assert.equal(readStream.bytesRead, undefined);
-		assert.equal(readStream.path, undefined);
-		assert.equal(readStream.pending, undefined);
-
-		// Assign values
-		readStream.bytesRead = 10;
-		readStream.path = testFilePath;
-		readStream.pending = false;
-
-		assert.equal(readStream.bytesRead, 10);
-		assert.equal(readStream.path, testFilePath);
-		assert(!readStream.pending);
-	});
-
-	test('ReadStream close method can be called multiple times', async () => {
-		const readStream = new fs.ReadStream();
-
-		const close = promisify(readStream.close);
-		await close();
-		await close();
-	});
-
 	test('WriteStream writes data correctly', async () => {
 		const writeStream = fs.createWriteStream(testFilePathWrite);
 
@@ -92,30 +67,6 @@ suite('Streams', () => {
 		});
 	});
 
-	test('WriteStream declared properties', () => {
-		const writeStream = new fs.WriteStream();
-		assert.equal(writeStream.bytesWritten, undefined);
-		assert.equal(writeStream.path, undefined);
-		assert.equal(writeStream.pending, undefined);
-
-		// Assign values
-		writeStream.bytesWritten = 20;
-		writeStream.path = testFilePathWrite;
-		writeStream.pending = true;
-
-		assert.equal(writeStream.bytesWritten, 20);
-		assert.equal(writeStream.path, testFilePathWrite);
-		assert(writeStream.pending);
-	});
-
-	test('WriteStream close method can be called multiple times', async () => {
-		const writeStream = new fs.WriteStream();
-
-		const close = promisify(writeStream.close);
-		await close();
-		await close();
-	});
-
 	test('createReadStream with start', async () => {
 		await fs.promises.writeFile('hello.txt', 'Hello world');
 
@@ -159,6 +110,22 @@ suite('Streams', () => {
 		await fileHandle.close();
 	});
 
+	test('readable web stream', async () => {
+		const fileHandle = await fs.promises.open(testFilePath, 'r');
+		const webStream = fileHandle.readableWebStream();
+
+		let data = '';
+
+		const decoder = new TextDecoder();
+
+		for await (const chunk of webStream) {
+			data += decoder.decode(chunk);
+		}
+
+		assert.equal(data, testData);
+		await fileHandle.close();
+	});
+
 	test('FileHandle.createReadStream after close should give an error', async () => {
 		const fileHandle = await fs.promises.open(testFilePath, 'r');
 		await fileHandle.close();