@zenfs/core 1.10.0 → 1.10.2

package/dist/backends/index.d.ts

@@ -1,7 +1,7 @@
 export * from './backend.js';
+export * from './cow.js';
 export * from './fetch.js';
 export * from './memory.js';
-export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
 export * from './single_buffer.js';

package/dist/backends/index.js

@@ -1,7 +1,7 @@
 export * from './backend.js';
+export * from './cow.js';
 export * from './fetch.js';
 export * from './memory.js';
-export * from './overlay.js';
 export * from './passthrough.js';
 export * from './port/fs.js';
 export * from './single_buffer.js';

package/dist/backends/port/fs.js

@@ -124,7 +124,7 @@ const _Port = {
             validator(port) {
                 // Check for a `postMessage` function.
                 if (typeof (port === null || port === void 0 ? void 0 : port.postMessage) != 'function') {
-                    throw err(new ErrnoError(Errno.EINVAL, 'option must be a port.'));
+                    throw err(new ErrnoError(Errno.EINVAL, 'option must be a port'));
                 }
             },
         },

package/dist/backends/single_buffer.js

@@ -265,7 +265,7 @@ let SuperBlock = (() => {
             __runInitializers(this, __padding_extraInitializers);
             this.store = store;
             if (store._view.getUint32(offsetof(SuperBlock, 'magic'), true) != sb_magic) {
-                warn('SingleBuffer: Invalid magic value. Assuming this is a fresh super block.');
+                warn('SingleBuffer: Invalid magic value, assuming this is a fresh super block');
                 this.metadata = new MetadataBlock(this);
                 this.used_bytes = BigInt(sizeof(SuperBlock) + sizeof(MetadataBlock));
                 this.total_bytes = BigInt(store._buffer.byteLength);
@@ -371,7 +371,7 @@ export class SingleBufferStore {
         this.name = 'sbfs';
         this.id = 0x73626673; // 'sbfs'
         if (buffer.byteLength < sizeof(SuperBlock) + sizeof(MetadataBlock))
-            throw crit(new ErrnoError(Errno.EINVAL, 'SingleBuffer: Buffer is too small for a file system.'));
+            throw crit(new ErrnoError(Errno.EINVAL, 'SingleBuffer: Buffer is too small for a file system'));
         this._view = !ArrayBuffer.isView(buffer) ? new DataView(buffer) : new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
         this._buffer = !ArrayBuffer.isView(buffer) ? new Uint8Array(buffer) : new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
         this.superblock = new SuperBlock(this);
@@ -467,8 +467,8 @@ export class SingleBufferStore {
             }
         }
     }
-    async sync() {
-        return;
+    sync() {
+        return Promise.resolve();
     }
     usage() {
         return {

package/dist/backends/store/fs.js

@@ -792,11 +792,11 @@ export class StoreFS extends FileSystem {
                 warn('Attempted to populate tables after initialization');
                 return;
             }
-            debug('Populating tables with existing store metadata.');
+            debug('Populating tables with existing store metadata');
             const tx = __addDisposableResource(env_23, this.transaction(), true);
             const rootData = await tx.get(rootIno);
             if (!rootData) {
-                notice('Store does not have a root inode.');
+                notice('Store does not have a root inode');
                 const inode = new Inode({ ino: rootIno, data: 1, mode: 0o777 | S_IFDIR });
                 await tx.set(inode.data, encodeUTF8('{}'));
                 this._add(rootIno, '/');
@@ -805,7 +805,7 @@ export class StoreFS extends FileSystem {
                 return;
             }
             if (rootData.length != __inode_sz) {
-                crit('Store contains an invalid root inode. Refusing to populate tables.');
+                crit('Store contains an invalid root inode. Refusing to populate tables');
                 return;
             }
             // Keep track of directories we have already traversed to avoid loops

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference path="../types/readable-stream.d.ts" preserve="true" />
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';
@@ -9,10 +10,3 @@ export * from './vfs/index.js';
 export { fs };
 import * as fs from './vfs/index.js';
 export default fs;
-declare global {
-    /**
-     * Global VFS. Do not use unless absolutely needed.
-     * @hidden
-     */
-    var __zenfs__: typeof fs;
-}

package/dist/index.js

@@ -1,3 +1,5 @@
+// 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/devices.js

@@ -241,7 +241,7 @@ export class DeviceFS extends StoreFS {
         this._createDevice(fullDevice);
         this._createDevice(randomDevice);
         this._createDevice(consoleDevice);
-        debug('Added default devices.');
+        debug('Added default devices');
     }
     constructor() {
         // Please don't store your temporary files in /dev.

package/dist/internal/file.js

@@ -280,7 +280,7 @@ export class PreloadFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'truncate');
         this.dirty = true;
         if (!isWriteable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode');
         }
         this.stats.mtimeMs = Date.now();
         if (length > this._buffer.length) {
@@ -307,7 +307,7 @@ export class PreloadFile extends File {
         if (this.closed)
             throw ErrnoError.With('EBADF', this.path, 'write');
         if (!isWriteable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode');
         }
         this.dirty = true;
         const end = position + length;
@@ -353,7 +353,7 @@ export class PreloadFile extends File {
         if (this.closed)
             throw ErrnoError.With('EBADF', this.path, 'read');
         if (!isReadable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode');
         }
         if (config.updateOnRead) {
             this.dirty = true;
@@ -572,7 +572,7 @@ export class LazyFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'truncate');
         this.dirty = true;
         if (!isWriteable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode');
         }
         this.stats.mtimeMs = Date.now();
         this.stats.size = length;
@@ -584,7 +584,7 @@ export class LazyFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'truncate');
         this.dirty = true;
         if (!isWriteable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode');
         }
         this.stats.mtimeMs = Date.now();
         this.stats.size = length;
@@ -595,7 +595,7 @@ export class LazyFile extends File {
         if (this.closed)
             throw ErrnoError.With('EBADF', this.path, 'write');
         if (!isWriteable(this.flag)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode.');
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode');
         }
         this.dirty = true;
         const end = position + length;
@@ -644,7 +644,7 @@ export class LazyFile extends File {
         if (this.closed)
             throw ErrnoError.With('EBADF', this.path, 'read');
         if (!isReadable(this.flag))
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode.');
+            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode');
         if (config.updateOnRead)
             this.dirty = true;
         this.stats.atimeMs = Date.now();

package/dist/internal/log.d.ts

@@ -88,16 +88,17 @@ export declare function log_deprecated(symbol: string): void;
  */
 export declare const formats: {
     /** Format with a timestamp and the level, colorized with ANSI escape codes */
-    readonly ansi_level: (this: void, entry: Entry) => string;
+    readonly ansi_level: (this: void, entry: Entry) => string[];
     /**
      * Format with a timestamp and colorize the message with ANSI escape codes.
      * For EMERG and ALERT, the levels are included
      */
     readonly ansi_message: (this: void, entry: Entry) => string;
-    /** Uncolored format with a timestamp */
+    readonly css_level: (this: void, entry: Entry) => string[];
+    readonly css_message: (this: void, entry: Entry) => string[];
     readonly default: (this: void, entry: Entry) => string;
 };
-export declare function format(entry: Entry): string;
+export declare function format(entry: Entry): string[];
 /** Whether log entries are being recorded */
 export declare let isEnabled: boolean;
 export interface LogConfiguration {
@@ -115,12 +116,12 @@ export interface LogConfiguration {
      * Formats a log entry into a string
      * @default `[${ms / 1000}] ${message}`
      */
-    format?(this: void, entry: Entry): string;
+    format?(this: void, entry: Entry): string | string[];
     /**
      * Outputs a log message
      * @default console.error()
      */
-    output?(this: void, message: string): unknown;
+    output?(this: void, ...message: string[]): unknown;
     /**
      * If set, output() all current entries after `configure` is done
      * @default false

package/dist/internal/log.js

@@ -97,9 +97,16 @@ export function log_deprecated(symbol) {
 function ansi(text, format) {
     return `\x1b[${format}m${text}\x1b[0m`;
 }
-function _prettyMs(entry, useANSI = false) {
+function _prettyMs(entry, style) {
     const text = '[' + (entry.elapsedMs / 1000).toFixed(3).padStart(10) + '] ';
-    return useANSI ? ansi(text, '2;37') : text;
+    switch (style) {
+        case 'ansi':
+            return ansi(text, '2;37');
+        case 'css':
+            return ['%c' + text, 'opacity: 0.8; color: white;'];
+        default:
+            return text;
+    }
 }
 const _ansiLevelColor = {
     [Level.EMERG]: '1;4;37;41',
@@ -121,6 +128,26 @@ const _ansiMessageColor = {
     [Level.INFO]: '37',
     [Level.DEBUG]: '2;37',
 };
+const _cssLevelColor = {
+    [Level.EMERG]: 'font-weight: bold; text-decoration: underline; color: white; background-color: red;',
+    [Level.ALERT]: 'font-weight: bold; color: white; background-color: red;',
+    [Level.CRIT]: 'font-weight: bold; color: magenta;',
+    [Level.ERR]: 'font-weight: bold; color: red;',
+    [Level.WARN]: 'font-weight: bold; color: yellow;',
+    [Level.NOTICE]: 'font-weight: bold; color: cyan;',
+    [Level.INFO]: 'font-weight: bold; color: white;',
+    [Level.DEBUG]: 'opacity: 0.8; color: white;',
+};
+const _cssMessageColor = {
+    [Level.EMERG]: 'font-weight: bold; color: red;',
+    [Level.ALERT]: 'font-weight: bold; color: red;',
+    [Level.CRIT]: 'font-weight: bold; color: red;',
+    [Level.ERR]: 'color: red;',
+    [Level.WARN]: 'color: yellow;',
+    [Level.NOTICE]: 'font-weight: bold; color: white;',
+    [Level.INFO]: 'color: white;',
+    [Level.DEBUG]: 'opacity: 0.8; color: white;',
+};
 /**
  * Various format functions included to make using the logger easier.
  * These are not the only formats you can use.
@@ -129,34 +156,48 @@ export const formats = {
     /** Format with a timestamp and the level, colorized with ANSI escape codes */
     ansi_level(entry) {
         const levelText = ansi(levels[entry.level].toUpperCase(), _ansiLevelColor[entry.level]);
-        return [_prettyMs(entry, true), levelText, entry.message].join(' ');
+        return [_prettyMs(entry, 'ansi'), levelText, entry.message];
     },
     /**
      * Format with a timestamp and colorize the message with ANSI escape codes.
      * For EMERG and ALERT, the levels are included
      */
     ansi_message(entry) {
-        let msg = _prettyMs(entry, true);
+        let msg = _prettyMs(entry, 'ansi');
         const isImportant = entry.level < Level.CRIT;
         if (isImportant)
             msg += ansi(levels[entry.level].toUpperCase(), _ansiLevelColor[entry.level]) + ': ';
         msg += ansi(entry.message, _ansiMessageColor[entry.level]);
         return msg;
     },
-    /** Uncolored format with a timestamp */
+    css_level(entry) {
+        const levelLabel = levels[entry.level].toUpperCase();
+        return [..._prettyMs(entry, 'css'), `%c${levelLabel}%c ${entry.message}`, _cssLevelColor[entry.level], ''];
+    },
+    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' + entry.message, _cssMessageColor[entry.level]);
+        return text;
+    },
     default(entry) {
         return `[${_prettyMs(entry)}] ${entry.message}`;
     },
 };
 let _format = formats.default;
 export function format(entry) {
-    return _format(entry);
+    const formatted = _format(entry);
+    return Array.isArray(formatted) ? formatted : [formatted];
 }
 let _output = console.error;
 function output(entry) {
     if (entry.level > minLevel)
         return;
-    _output(format(entry));
+    _output(...format(entry));
 }
 let minLevel = Level.ALERT;
 // Configuration

package/dist/mixins/async.js

@@ -50,10 +50,11 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { getAllPrototypes } from 'utilium';
 import { StoreFS } from '../backends/store/fs.js';
 import { Errno, ErrnoError } from '../internal/error.js';
 import { LazyFile, parseFlag } from '../internal/file.js';
-import { crit, err, notice } from '../internal/log.js';
+import { crit, debug, err } from '../internal/log.js';
 import { join } from '../vfs/path.js';
 /**
  * Async() implements synchronous methods on an asynchronous file system
@@ -80,6 +81,8 @@ export function Async(FS) {
             super(...args);
             this._promise = Promise.resolve();
             this._isInitialized = false;
+            /** Tracks how many updates to the sync. cache we skipped during initialization */
+            this._skippedCacheUpdates = 0;
             this._patchAsync();
         }
         async ready() {
@@ -103,6 +106,7 @@ export function Async(FS) {
             }
             try {
                 await this.crossCopy('/');
+                debug(`Skipped ${this._skippedCacheUpdates} updates to the sync cache during initialization`);
                 this._isInitialized = true;
             }
             catch (e) {
@@ -131,9 +135,9 @@ export function Async(FS) {
         }
         createFileSync(path, flag, mode, options) {
             this.checkSync(path, 'createFile');
-            this._sync.createFileSync(path, flag, mode, options);
+            const file = this._sync.createFileSync(path, flag, mode, options);
             this._async(this.createFile(path, flag, mode, options));
-            return this.openFileSync(path, flag);
+            return new LazyFile(this, path, flag, file.statSync());
         }
         openFileSync(path, flag) {
             this.checkSync(path, 'openFile');
@@ -220,38 +224,30 @@ export function Async(FS) {
         }
         /**
          * @internal
-         * Patch all async methods to also call their synchronous counterparts unless called from the queue
+         * Patch all async methods to also call their synchronous counterparts unless called from themselves (either sync or async)
          */
         _patchAsync() {
-            const asyncFSMethodKeys = [
-                'rename',
-                'stat',
-                'createFile',
-                'openFile',
-                'unlink',
-                'rmdir',
-                'mkdir',
-                'readdir',
-                'link',
-                'sync',
-                'exists',
-            ];
-            for (const key of asyncFSMethodKeys) {
-                if (typeof this[key] !== 'function')
-                    continue;
+            const methods = Array.from(getAllPrototypes(this))
+                .flatMap(Object.getOwnPropertyNames)
+                .filter(key => typeof this[key] == 'function' && `${key}Sync` in this);
+            debug('Async: patching methods: ' + methods.join(', '));
+            for (const key of methods) {
+                // TS does not narrow the union based on the key
                 const originalMethod = this[key];
                 this[key] = async (...args) => {
-                    var _a, _b;
+                    var _a, _b, _c;
                     const result = await originalMethod.apply(this, args);
-                    if (new Error().stack.includes(`at <computed> [as ${key}]`))
+                    const stack = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split('\n').slice(2).join('\n');
+                    // !stack == From the async queue
+                    if ((stack === null || stack === void 0 ? void 0 : stack.includes(`at <computed> [as ${key}]`)) || (stack === null || stack === void 0 ? void 0 : stack.includes(`${key}Sync `)) || !stack)
                         return result;
                     if (!this._isInitialized) {
-                        notice('Skipping sync cache update for Async#' + key);
+                        this._skippedCacheUpdates++;
                         return result;
                     }
                     try {
-                        // @ts-expect-error 2556
-                        (_b = (_a = this._sync) === null || _a === void 0 ? void 0 : _a[`${key}Sync`]) === null || _b === void 0 ? void 0 : _b.call(_a, ...args);
+                        // @ts-expect-error 2556 - The type of `args` is not narrowed
+                        (_c = (_b = this._sync) === null || _b === void 0 ? void 0 : _b[`${key}Sync`]) === null || _c === void 0 ? void 0 : _c.call(_b, ...args);
                     }
                     catch (e) {
                         throw err(new ErrnoError(e.errno, e.message + ' (Out of sync!)', e.path, key), { fs: this });

package/dist/mixins/shared.d.ts

@@ -8,12 +8,12 @@ import type { FileSystem } from '../internal/filesystem.js';
 export type Mixin<TBase extends typeof FileSystem, TMixin> = (abstract new (...args: any[]) => TMixin) & TBase;
 /**
  * @internal @hidden
- * Note this include `existsSync`, even though it is a concrete method.
+ * Note this includes `existsSync`, even though it is a concrete method.
  */
 export type _SyncFSKeys = Exclude<Extract<keyof FileSystem, `${string}Sync`>, '_disableSync'>;
 /**
  * @internal @hidden
- * Note this include `exists`, even though it is a concrete method.
+ * Note this includes `exists`, even though it is a concrete method.
  */
 export type _AsyncFSKeys = {
     [K in _SyncFSKeys]: K extends `${infer T}Sync` ? T : never;

package/dist/polyfills.d.ts

@@ -1,5 +1 @@
-declare global {
-    interface AsyncIterator<T, TReturn, TNext> extends AsyncDisposable {
-    }
-}
 export {};

package/dist/polyfills.js

@@ -1,17 +1,20 @@
+/* node:coverage disable */
 var _a, _b, _c;
+import { warn } from './internal/log.js';
 // eslint-disable-next-line @typescript-eslint/unbound-method
-(_a = Promise.withResolvers) !== null && _a !== void 0 ? _a : (Promise.withResolvers = function () {
-    let _resolve, 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _reject;
-    const promise = new Promise((resolve, reject) => {
-        _resolve = resolve;
-        _reject = reject;
-    });
-    return { promise, resolve: _resolve, reject: _reject };
-});
+(_a = Promise.withResolvers) !== null && _a !== void 0 ? _a : (Promise.withResolvers = (warn('Using a polyfill of Promise.withResolvers'),
+    function () {
+        let _resolve, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        _reject;
+        const promise = new Promise((resolve, reject) => {
+            _resolve = resolve;
+            _reject = reject;
+        });
+        return { promise, resolve: _resolve, reject: _reject };
+    }));
 // @ts-expect-error 2540
-(_b = Symbol['dispose']) !== null && _b !== void 0 ? _b : (Symbol['dispose'] = Symbol('Symbol.dispose'));
+(_b = Symbol['dispose']) !== null && _b !== void 0 ? _b : (Symbol['dispose'] = (warn('Using a polyfill of Symbol.dispose'), Symbol('Symbol.dispose')));
 // @ts-expect-error 2540
-(_c = Symbol['asyncDispose']) !== null && _c !== void 0 ? _c : (Symbol['asyncDispose'] = Symbol('Symbol.asyncDispose'));
-export {};
+(_c = Symbol['asyncDispose']) !== null && _c !== void 0 ? _c : (Symbol['asyncDispose'] = (warn('Using a polyfill of Symbol.asyncDispose'), Symbol('Symbol.asyncDispose')));
+/* node:coverage enable */

package/dist/vfs/async.js

@@ -166,7 +166,7 @@ export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
             default:
                 // ...try to find the callback and get out of here!
                 cb = (typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-                cb(new ErrnoError(Errno.EINVAL, 'Invalid arguments.'));
+                cb(new ErrnoError(Errno.EINVAL, 'Invalid arguments'));
                 return;
         }
         buffer = Buffer.from(data);
@@ -421,29 +421,43 @@ watch;
  * @returns A ReadStream object for interacting with the file's contents.
  */
 export function createReadStream(path, options) {
-    const context = this;
+    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 || 64 * 1024,
-        encoding: options.encoding || 'utf8',
+        highWaterMark: options.highWaterMark || 0x1000,
+        encoding: (_a = options.encoding) !== null && _a !== void 0 ? _a : undefined,
         async read(size) {
+            var _a;
             try {
-                handle || (handle = await promises.open.call(context, path, 'r', options === null || options === void 0 ? void 0 : options.mode));
-                const result = await handle.read(new Uint8Array(size), 0, size, handle.file.position);
-                stream.push(!result.bytesRead ? null : result.buffer.subarray(0, result.bytesRead));
-                handle.file.position += result.bytesRead;
-                if (!result.bytesRead) {
+                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);
             }
         },
-        destroy(error, callback) {
-            handle === null || handle === void 0 ? void 0 : handle.close().then(() => callback(error)).catch(nop);
+        async destroy(error, callback) {
+            await (handle === null || handle === void 0 ? void 0 : handle.close().catch(nop));
+            callback(error);
         },
     });
     stream.path = path.toString();
@@ -458,28 +472,37 @@ createReadStream;
  * @returns A WriteStream object for writing to the file.
  */
 export function createWriteStream(path, options) {
-    const context = this;
     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 promises.open.call(context, path, 'w', (options === null || options === void 0 ? void 0 : options.mode) || 0o666));
-                await handle.write(chunk, 0, encoding);
-                callback(undefined);
+                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);
             }
         },
-        destroy(error, callback) {
+        async destroy(error, callback) {
+            await (handle === null || handle === void 0 ? void 0 : handle.close().catch(callback));
             callback(error);
-            void (handle === null || handle === void 0 ? void 0 : handle.close().then(() => callback(error)).catch(callback));
         },
-        final(callback) {
-            void (handle === null || handle === void 0 ? void 0 : handle.close().then(() => callback()).catch(callback));
+        async final(callback) {
+            await (handle === null || handle === void 0 ? void 0 : handle.close().catch(nop));
+            callback();
         },
     });
     stream.path = path.toString();

package/dist/vfs/promises.d.ts

@@ -1,7 +1,6 @@
 import type * as fs from 'node:fs';
 import type * as promises from 'node:fs/promises';
 import type { Stream } from 'node:stream';
-import type { ReadableStream as TReadableStream } from 'node:stream/web';
 import type { Interface as ReadlineInterface } from 'readline';
 import type { V_Context } from '../context.js';
 import type { File } from '../internal/file.js';
@@ -86,15 +85,10 @@ export declare class FileHandle implements promises.FileHandle {
     }): Promise<Buffer>;
     readFile(_options: (fs.ObjectEncodingOptions & promises.FlagAndOpenMode) | BufferEncoding): Promise<string>;
     /**
-     * Returns a `ReadableStream` that may be used to read the files data.
-     *
-     * An error will be thrown if this method is called more than once or is called after the `FileHandle` is closed or closing.
-     *
-     * While the `ReadableStream` will read the file to completion,
-     * it will not close the `FileHandle` automatically.
-     * User code must still call the `fileHandle.close()` method.
+     * Read file data using a `ReadableStream`.
+     * The handle will not be closed automatically.
      */
-    readableWebStream(options?: promises.ReadableWebStreamOptions): TReadableStream<Uint8Array>;
+    readableWebStream(options?: promises.ReadableWebStreamOptions): ReadableStream<Uint8Array>;
     /**
      * @todo Implement
      */
@@ -111,7 +105,7 @@ export declare class FileHandle implements promises.FileHandle {
      * Asynchronously writes `string` to the file.
      * The `FileHandle` must have been opened for writing.
      * It is unsafe to call `write()` multiple times on the same file without waiting for the `Promise`
-     * to be resolved (or rejected). For this scenario, `fs.createWriteStream` is strongly recommended.
+     * to be resolved (or rejected). For this scenario, `createWriteStream` is strongly recommended.
      */
     write<T extends FileContents>(data: T, options?: number | null | {
         offset?: number;
@@ -296,9 +290,9 @@ export declare function lutimes(this: V_Context, path: fs.PathLike, atime: fs.Ti
  */
 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.EncodingOption | BufferEncoding): Promise<string>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIterableIterator<promises.FileChangeInfo<string>>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIterableIterator<promises.FileChangeInfo<Buffer>>;
-export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIterableIterator<promises.FileChangeInfo<string>> | AsyncIterableIterator<promises.FileChangeInfo<Buffer>>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | BufferEncoding): AsyncIteratorObject<promises.FileChangeInfo<string>>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options: fs.WatchOptions | fs.BufferEncodingOption): AsyncIteratorObject<promises.FileChangeInfo<Buffer>>;
+export declare function watch(this: V_Context, filename: fs.PathLike, options?: fs.WatchOptions | string): AsyncIteratorObject<promises.FileChangeInfo<string>> | AsyncIteratorObject<promises.FileChangeInfo<Buffer>>;
 export declare function access(this: V_Context, path: fs.PathLike, mode?: number): Promise<void>;
 /**
  * Asynchronous `rm`. Removes files or directories (recursively).