@zenfs/core 1.8.0 → 1.8.2

package/dist/backends/store/index_fs.js

@@ -1,5 +1,5 @@
 import { ErrnoError } from '../../error.js';
-import { PreloadFile } from '../../file.js';
+import { LazyFile } from '../../file.js';
 import { Stats } from '../../stats.js';
 import { S_IFREG } from '../../vfs/constants.js';
 import { Index } from './file_index.js';
@@ -43,13 +43,13 @@ export class IndexFS extends StoreFS {
     }
     async createFile(path, flag, mode, options) {
         const node = await this.commitNew(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
-        const file = new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
+        const file = new LazyFile(this, path, flag, node.toStats());
         this.index.set(path, node);
         return file;
     }
     createFileSync(path, flag, mode, options) {
         const node = this.commitNewSync(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
-        const file = new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
+        const file = new LazyFile(this, path, flag, node.toStats());
         this.index.set(path, node);
         return file;
     }

package/dist/backends/store/inode.d.ts

@@ -20,7 +20,7 @@ export declare const _inode_fields: readonly ["ino", "data", "size", "mode", "fl
  * @todo [BREAKING] Remove 58 byte Inode upgrade path
  */
 export declare class Inode implements InodeLike {
-    constructor(data?: ArrayBufferLike | ArrayBufferView | Readonly<InodeLike>);
+    constructor(data?: ArrayBufferLike | ArrayBufferView | Readonly<Partial<InodeLike>>);
     data: number;
     /** For future use */
     __data_old: number;

package/dist/devices.d.ts

@@ -1,7 +1,7 @@
-import type { FileReadResult } from './file.js';
-import type { InodeLike } from './backends/index.js';
+import { Inode } from './backends/index.js';
 import { InMemoryStore } from './backends/memory.js';
 import { StoreFS } from './backends/store/fs.js';
+import type { FileReadResult } from './file.js';
 import { File } from './file.js';
 import type { CreationOptions } from './filesystem.js';
 import { Stats } from './stats.js';
@@ -15,7 +15,7 @@ export interface Device<TData = any> {
     /**
      * The device's driver
      */
-    driver: DeviceDriver;
+    driver: DeviceDriver<TData>;
     /**
      * Which inode the device is assigned
      */
@@ -34,6 +34,12 @@ export interface Device<TData = any> {
      */
     minor: number;
 }
+export interface DeviceInit<TData = any> {
+    data?: TData;
+    minor?: number;
+    major?: number;
+    name?: string;
+}
 /**
  * A device driver
  */
@@ -56,22 +62,36 @@ export interface DeviceDriver<TData = any> {
      * Initializes a new device.
      * @returns `Device.data`
      */
-    init?(ino: number, options: object): {
-        data?: TData;
-        minor?: number;
-        major?: number;
-        name?: string;
-    };
+    init?(ino: number, options: object): DeviceInit<TData>;
     /**
-     * Synchronously read from the device
+     * Synchronously read from a device file
      * @group File operations
+     * @deprecated
+     * @todo [BREAKING] Remove
+     */
+    read?(file: DeviceFile<TData>, buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
+    /**
+     * Synchronously read from a device.
+     * @privateRemarks
+     * For many devices there is no concept of an offset or end.
+     * For example, /dev/random will be "the same" regardless of where you read from- random data.
+     * @group File operations
+     * @todo [BREAKING] Rename to `read`
+     */
+    readD(device: Device<TData>, buffer: Uint8Array, offset: number, end: number): void;
+    /**
+     * Synchronously write to a device file
+     * @group File operations
+     * @deprecated
+     * @todo [BREAKING] Remove
      */
-    read(file: DeviceFile<TData>, buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
+    write?(file: DeviceFile<TData>, buffer: Uint8Array, offset: number, length: number, position?: number): number;
     /**
-     * Synchronously write to the device
+     * Synchronously write to a device
      * @group File operations
+     * @todo [BREAKING] Rename to `write`
      */
-    write(file: DeviceFile<TData>, buffer: Uint8Array, offset: number, length: number, position?: number): number;
+    writeD(device: Device<TData>, buffer: Uint8Array, offset: number): void;
     /**
      * Sync the device
      * @group File operations
@@ -95,7 +115,7 @@ export declare class DeviceFile<TData = any> extends File {
     position: number;
     constructor(fs: DeviceFS, path: string, device: Device<TData>);
     get driver(): DeviceDriver<TData>;
-    protected get stats(): Partial<InodeLike>;
+    protected stats: Inode;
     stat(): Promise<Stats>;
     statSync(): Stats;
     readSync(buffer: ArrayBufferView, offset?: number, length?: number, position?: number): number;
@@ -114,8 +134,6 @@ export declare class DeviceFile<TData = any> extends File {
     chmodSync(): void;
     utimes(): Promise<void>;
     utimesSync(): void;
-    _setType(): Promise<void>;
-    _setTypeSync(): void;
 }
 /**
  * A temporary file system that manages and interfaces with devices
@@ -157,6 +175,10 @@ export declare class DeviceFS extends StoreFS<InMemoryStore> {
     linkSync(target: string, link: string): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
+    readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
+    write(path: string, data: Uint8Array, offset: number): Promise<void>;
+    writeSync(path: string, data: Uint8Array, offset: number): void;
 }
 /**
  * Simulates the `/dev/null` device.
@@ -199,6 +221,6 @@ export declare const devices: {
     full: DeviceDriver<any>;
     random: DeviceDriver<any>;
     console: DeviceDriver<{
-        output: (text: string) => unknown;
+        output: (text: string, offset: number) => unknown;
     }>;
 };

package/dist/devices.js

@@ -53,6 +53,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { Inode } from './backends/index.js';
 import { InMemoryStore } from './backends/memory.js';
 import { StoreFS } from './backends/store/fs.js';
 import { Errno, ErrnoError } from './error.js';
@@ -73,28 +74,40 @@ export class DeviceFile extends File {
         this.fs = fs;
         this.device = device;
         this.position = 0;
+        this.stats = new Inode({
+            mode: (this.driver.isBuffered ? S_IFBLK : S_IFCHR) | 0o666,
+        });
     }
     get driver() {
         return this.device.driver;
     }
-    get stats() {
-        return { mode: (this.driver.isBuffered ? S_IFBLK : S_IFCHR) | 0o666 };
-    }
     async stat() {
         return Promise.resolve(new Stats(this.stats));
     }
     statSync() {
         return new Stats(this.stats);
     }
-    readSync(buffer, offset, length, position) {
-        return this.driver.read(this, buffer, offset, length, position);
+    readSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        this.stats.atimeMs = Date.now();
+        const end = position + length;
+        this.position = end;
+        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        this.driver.readD(this.device, uint8.subarray(offset, length), position, end);
+        return length;
     }
     // eslint-disable-next-line @typescript-eslint/require-await
     async read(buffer, offset, length) {
         return { bytesRead: this.readSync(buffer, offset, length), buffer };
     }
-    writeSync(buffer, offset = 0, length = buffer.length, position) {
-        return this.driver.write(this, buffer, offset, length, position);
+    writeSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        const end = position + length;
+        if (end > this.stats.size)
+            this.stats.size = end;
+        this.stats.mtimeMs = Date.now();
+        this.position = end;
+        const data = buffer.subarray(offset, offset + length);
+        this.driver.writeD(this.device, data, position);
+        return length;
     }
     // eslint-disable-next-line @typescript-eslint/require-await
     async write(buffer, offset, length, position) {
@@ -144,12 +157,6 @@ export class DeviceFile extends File {
     utimesSync() {
         throw ErrnoError.With('ENOTSUP', this.path, 'utimes');
     }
-    _setType() {
-        throw ErrnoError.With('ENOTSUP', this.path, '_setType');
-    }
-    _setTypeSync() {
-        throw ErrnoError.With('ENOTSUP', this.path, '_setType');
-    }
 }
 /**
  * A temporary file system that manages and interfaces with devices
@@ -389,11 +396,41 @@ export class DeviceFS extends StoreFS {
         }
         return super.syncSync(path, data, stats);
     }
+    async read(path, buffer, offset, end) {
+        const device = this.devices.get(path);
+        if (!device) {
+            await super.read(path, buffer, offset, end);
+            return;
+        }
+        device.driver.readD(device, buffer, offset, end);
+    }
+    readSync(path, buffer, offset, end) {
+        const device = this.devices.get(path);
+        if (!device) {
+            super.readSync(path, buffer, offset, end);
+            return;
+        }
+        device.driver.readD(device, buffer, offset, end);
+    }
+    async write(path, data, offset) {
+        const device = this.devices.get(path);
+        if (!device) {
+            return await super.write(path, data, offset);
+        }
+        device.driver.writeD(device, data, offset);
+    }
+    writeSync(path, data, offset) {
+        const device = this.devices.get(path);
+        if (!device) {
+            return super.writeSync(path, data, offset);
+        }
+        device.driver.writeD(device, data, offset);
+    }
 }
-function defaultWrite(file, buffer, offset, length) {
-    file.position += length;
-    return length;
+function defaultWrite(device, data, offset) {
+    return;
 }
+const emptyBuffer = new Uint8Array();
 /**
  * Simulates the `/dev/null` device.
  * - Reads return 0 bytes (EOF).
@@ -409,7 +446,10 @@ export const nullDevice = {
     read() {
         return 0;
     },
-    write: defaultWrite,
+    readD() {
+        return emptyBuffer;
+    },
+    writeD: defaultWrite,
 };
 /**
  * Simulates the `/dev/zero` device
@@ -427,15 +467,10 @@ export const zeroDevice = {
     init() {
         return { major: 1, minor: 5 };
     },
-    read(file, buffer, offset = 0, length = buffer.byteLength) {
-        const data = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        for (let i = offset; i < offset + length; i++) {
-            data[i] = 0;
-        }
-        file.position += length;
-        return length;
+    readD(device, buffer, offset, end) {
+        buffer.fill(0, offset, end);
     },
-    write: defaultWrite,
+    writeD: defaultWrite,
 };
 /**
  * Simulates the `/dev/full` device.
@@ -449,17 +484,15 @@ export const fullDevice = {
     init() {
         return { major: 1, minor: 7 };
     },
-    read(file, buffer, offset = 0, length = buffer.byteLength) {
-        const data = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        for (let i = offset; i < offset + length; i++) {
-            data[i] = 0;
-        }
-        file.position += length;
-        return length;
+    readD(device, buffer, offset, end) {
+        buffer.fill(0, offset, end);
     },
     write(file) {
         throw ErrnoError.With('ENOSPC', file.path, 'write');
     },
+    writeD() {
+        throw ErrnoError.With('ENOSPC', undefined, 'write');
+    },
 };
 /**
  * Simulates the `/dev/random` device.
@@ -473,15 +506,12 @@ export const randomDevice = {
     init() {
         return { major: 1, minor: 8 };
     },
-    read(file, buffer, offset = 0, length = buffer.byteLength) {
-        const data = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-        for (let i = offset; i < offset + length; i++) {
-            data[i] = Math.floor(Math.random() * 256);
+    readD(device, buffer) {
+        for (let i = 0; i < buffer.length; i++) {
+            buffer[i] = Math.floor(Math.random() * 256);
         }
-        file.position += length;
-        return length;
     },
-    write: defaultWrite,
+    writeD: defaultWrite,
 };
 /**
  * Simulates the `/dev/console` device.
@@ -490,17 +520,15 @@ export const randomDevice = {
 const consoleDevice = {
     name: 'console',
     singleton: true,
-    init(ino, { output = console.log } = {}) {
+    init(ino, { output = text => console.log(text) } = {}) {
         return { major: 5, minor: 1, data: { output } };
     },
-    read() {
-        return 0;
+    readD() {
+        return emptyBuffer;
     },
-    write(file, buffer, offset, length) {
-        const text = decodeUTF8(buffer.slice(offset, offset + length));
-        file.device.data.output(text);
-        file.position += length;
-        return length;
+    writeD(device, buffer, offset) {
+        const text = decodeUTF8(buffer);
+        device.data.output(text, offset);
     },
 };
 /**

package/dist/file.js

@@ -1,6 +1,7 @@
 import { Errno, ErrnoError } from './error.js';
 import './polyfills.js';
 import { _chown, Stats } from './stats.js';
+import { growBuffer } from './utils.js';
 import { config } from './vfs/config.js';
 import * as c from './vfs/constants.js';
 const maxByteLength = 0x100000; // 1 MiB
@@ -269,7 +270,7 @@ export class PreloadFile extends File {
         }
         this.stats.size = length;
         // Truncate.
-        this._buffer = length ? this._buffer.slice(0, length) : new Uint8Array();
+        this._buffer = length ? this._buffer.subarray(0, length) : new Uint8Array();
     }
     async truncate(length) {
         this._truncate(length);
@@ -289,28 +290,10 @@ export class PreloadFile extends File {
         }
         this.dirty = true;
         const end = position + length;
-        const slice = buffer.slice(offset, offset + length);
-        if (end > this.stats.size) {
+        const slice = buffer.subarray(offset, offset + length);
+        this._buffer = growBuffer(this._buffer, end);
+        if (end > this.stats.size)
             this.stats.size = end;
-            if (end > this._buffer.byteLength) {
-                const { buffer } = this._buffer;
-                if ('resizable' in buffer && buffer.resizable && buffer.maxByteLength <= end) {
-                    buffer.resize(end);
-                }
-                else if ('growable' in buffer && buffer.growable && buffer.maxByteLength <= end) {
-                    buffer.grow(end);
-                }
-                else if (config.unsafeBufferReplace) {
-                    this._buffer = slice;
-                }
-                else {
-                    // Extend the buffer!
-                    const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength }));
-                    newBuffer.set(this._buffer);
-                    this._buffer = newBuffer;
-                }
-            }
-        }
         this._buffer.set(slice, position);
         this.stats.mtimeMs = Date.now();
         this.position = position + slice.byteLength;
@@ -366,7 +349,7 @@ export class PreloadFile extends File {
             // No copy/read. Return immediately for better performance
             return bytesRead;
         }
-        const slice = this._buffer.slice(position, end);
+        const slice = this._buffer.subarray(position, end);
         new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength).set(slice, offset);
         return bytesRead;
     }
@@ -589,10 +572,9 @@ export class LazyFile extends File {
         }
         this.dirty = true;
         const end = position + length;
-        const slice = buffer.slice(offset, offset + length);
-        if (end > this.stats.size) {
+        const slice = buffer.subarray(offset, offset + length);
+        if (end > this.stats.size)
             this.stats.size = end;
-        }
         this.stats.mtimeMs = Date.now();
         this._position = position + slice.byteLength;
         return slice;
@@ -607,7 +589,7 @@ export class LazyFile extends File {
      */
     async write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         const slice = this.prepareWrite(buffer, offset, length, position);
-        await this.fs.write(this.path, slice, offset);
+        await this.fs.write(this.path, slice, position);
         if (config.syncImmediately)
             await this.sync();
         return slice.byteLength;
@@ -623,7 +605,7 @@ export class LazyFile extends File {
      */
     writeSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         const slice = this.prepareWrite(buffer, offset, length, position);
-        this.fs.writeSync(this.path, slice, offset);
+        this.fs.writeSync(this.path, slice, position);
         if (config.syncImmediately)
             this.syncSync();
         return slice.byteLength;
@@ -656,7 +638,8 @@ export class LazyFile extends File {
      */
     async read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         const bytesRead = this.prepareRead(length, position);
-        new Uint8Array(buffer.buffer, offset, length).set(await this.fs.read(this.path, position, bytesRead));
+        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        await this.fs.read(this.path, uint8.subarray(offset, offset + length), position, bytesRead);
         if (config.syncImmediately)
             await this.sync();
         return { bytesRead, buffer };
@@ -672,7 +655,8 @@ export class LazyFile extends File {
      */
     readSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         const bytesRead = this.prepareRead(length, position);
-        new Uint8Array(buffer.buffer, offset, length).set(this.fs.readSync(this.path, position, bytesRead));
+        const uint8 = new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+        this.fs.readSync(this.path, uint8.subarray(offset, offset + length), position, bytesRead);
         if (config.syncImmediately)
             this.syncSync();
         return bytesRead;

package/dist/filesystem.d.ts

@@ -151,8 +151,30 @@ export declare abstract class FileSystem {
     abstract linkSync(target: string, link: string): void;
     abstract sync(path: string, data?: Uint8Array, stats?: Partial<Readonly<StatsLike>>): Promise<void>;
     abstract syncSync(path: string, data?: Uint8Array, stats?: Partial<Readonly<StatsLike>>): void;
-    abstract read(path: string, offset: number, length: number): Promise<Uint8Array>;
-    abstract readSync(path: string, offset: number, length: number): Uint8Array;
+    /**
+     * Reads into a buffer
+     * @param buffer The buffer to read into. You must set the `byteOffset` and `byteLength` appropriately!
+     * @param offset The offset into the file to start reading from
+     * @param end The position in the file to stop reading
+     */
+    abstract read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
+    /**
+     * Reads into a buffer
+     * @param buffer The buffer to read into. You must set the `byteOffset` and `byteLength` appropriately!
+     * @param offset The offset into the file to start reading from
+     * @param end The position in the file to stop reading
+     */
+    abstract readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
+    /**
+     * Writes a buffer to a file
+     * @param buffer The buffer to write. You must set the `byteOffset` and `byteLength` appropriately!
+     * @param offset The offset in the file to start writing
+     */
     abstract write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
+    /**
+     * Writes a buffer to a file
+     * @param buffer The buffer to write. You must set the `byteOffset` and `byteLength` appropriately!
+     * @param offset The offset in the file to start writing
+     */
     abstract writeSync(path: string, buffer: Uint8Array, offset: number): void;
 }

package/dist/mixins/async.js

@@ -52,7 +52,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { StoreFS } from '../backends/store/fs.js';
 import { Errno, ErrnoError } from '../error.js';
-import { parseFlag, PreloadFile } from '../file.js';
+import { LazyFile, parseFlag } from '../file.js';
 import { join } from '../vfs/path.js';
 /**
  * Async() implements synchronous methods on an asynchronous file system
@@ -138,11 +138,8 @@ export function Async(FS) {
         }
         openFileSync(path, flag) {
             this.checkSync(path, 'openFile');
-            const file = this._sync.openFileSync(path, flag + '+');
-            const stats = file.statSync();
-            const buffer = new Uint8Array(stats.size);
-            file.readSync(buffer);
-            return new PreloadFile(this, path, flag, stats, buffer);
+            const stats = this._sync.statSync(path);
+            return new LazyFile(this, path, flag, stats);
         }
         unlinkSync(path) {
             this.checkSync(path, 'unlinkSync');
@@ -177,6 +174,15 @@ export function Async(FS) {
             this.checkSync(path, 'exists');
             return this._sync.existsSync(path);
         }
+        readSync(path, buffer, offset, end) {
+            this.checkSync(path, 'read');
+            this._sync.readSync(path, buffer, offset, end);
+        }
+        writeSync(path, buffer, offset) {
+            this.checkSync(path, 'write');
+            this._sync.writeSync(path, buffer, offset);
+            this.queue('write', path, buffer, offset);
+        }
         /**
          * @internal
          */

package/dist/mixins/mutexed.d.ts

@@ -71,8 +71,8 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     linkSync(srcpath: string, dstpath: string): void;
     sync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): Promise<void>;
     syncSync(path: string, data?: Uint8Array, stats?: Readonly<InodeLike>): void;
-    read(path: string, offset: number, length: number): Promise<Uint8Array>;
-    readSync(path: string, offset: number, length: number): Uint8Array;
+    read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
+    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;
 }
@@ -81,7 +81,7 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
  * For example, on an OverlayFS instance with an async lower
  * directory operations like rename and rmdir may involve multiple
  * requests involving both the upper and lower file systems -- they
- * are not executed in a single atomic step. OverlayFS uses this
+ * are not executed in a single atomic step. OverlayFS used to use this
  * to avoid having to reason about the correctness of
  * multiple requests interleaving.
  *

package/dist/mixins/mutexed.js

@@ -448,11 +448,11 @@ export class _MutexedFS {
             __disposeResources(env_22);
         }
     }
-    async read(path, offset, length) {
+    async read(path, buffer, offset, end) {
         const env_23 = { stack: [], error: void 0, hasError: false };
         try {
             const _ = __addDisposableResource(env_23, await this.lock(path, 'read'), false);
-            return await this._fs.read(path, offset, length);
+            return await this._fs.read(path, buffer, offset, end);
         }
         catch (e_23) {
             env_23.error = e_23;
@@ -462,11 +462,11 @@ export class _MutexedFS {
             __disposeResources(env_23);
         }
     }
-    readSync(path, offset, length) {
+    readSync(path, buffer, offset, end) {
         const env_24 = { stack: [], error: void 0, hasError: false };
         try {
             const _ = __addDisposableResource(env_24, this.lockSync(path, 'read'), false);
-            return this._fs.readSync(path, offset, length);
+            return this._fs.readSync(path, buffer, offset, end);
         }
         catch (e_24) {
             env_24.error = e_24;
@@ -510,7 +510,7 @@ export class _MutexedFS {
  * For example, on an OverlayFS instance with an async lower
  * directory operations like rename and rmdir may involve multiple
  * requests involving both the upper and lower file systems -- they
- * are not executed in a single atomic step. OverlayFS uses this
+ * are not executed in a single atomic step. OverlayFS used to use this
  * to avoid having to reason about the correctness of
  * multiple requests interleaving.
  *

package/dist/mixins/readonly.d.ts

@@ -1,26 +1,27 @@
-import type { File } from '../file.js';
 import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
-import type { Stats } from '../stats.js';
+import type { StatsLike } from '../stats.js';
 import type { Mixin } from './shared.js';
 /**
  * @internal
  */
 export interface ReadonlyMixin {
     metadata(): FileSystemMetadata;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    renameSync(oldPath: string, newPath: string): void;
-    createFile(path: string, flag: string, mode: number): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number): File;
-    unlink(path: string): Promise<void>;
-    unlinkSync(path: string): void;
-    rmdir(path: string): Promise<void>;
-    rmdirSync(path: string): void;
-    mkdir(path: string, mode: number): Promise<void>;
-    mkdirSync(path: string, mode: number): void;
-    link(srcpath: string, dstpath: string): Promise<void>;
-    linkSync(srcpath: string, dstpath: string): void;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    rename(oldPath: string, newPath: string): Promise<never>;
+    renameSync(oldPath: string, newPath: string): never;
+    createFile(path: string, flag: string, mode: number): Promise<never>;
+    createFileSync(path: string, flag: string, mode: number): never;
+    unlink(path: string): Promise<never>;
+    unlinkSync(path: string): never;
+    rmdir(path: string): Promise<never>;
+    rmdirSync(path: string): never;
+    mkdir(path: string, mode: number): Promise<never>;
+    mkdirSync(path: string, mode: number): never;
+    link(srcpath: string, dstpath: string): Promise<never>;
+    linkSync(srcpath: string, dstpath: string): never;
+    sync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): Promise<never>;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<StatsLike<number>>): never;
+    write(path: string, buffer: Uint8Array, offset: number): Promise<never>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): Promise<never>;
 }
 /**
  * Implements the non-readonly methods to throw `EROFS`

package/dist/mixins/readonly.js

@@ -50,6 +50,12 @@ export function Readonly(FS) {
         syncSync() {
             throw new ErrnoError(Errno.EROFS);
         }
+        async write() {
+            throw new ErrnoError(Errno.EROFS);
+        }
+        writeSync() {
+            throw new ErrnoError(Errno.EROFS);
+        }
     }
     return ReadonlyFS;
 }

package/dist/utils.d.ts

@@ -89,3 +89,9 @@ export declare function canary(path?: string, syscall?: string): () => void;
  * @internal @hidden
  */
 export declare function _throw(e: unknown): never;
+/**
+ * Grows a buffer if it isn't large enough
+ * @returns The original buffer if resized successfully, or a newly created buffer
+ * @internal Not for external use!
+ */
+export declare function growBuffer<T extends ArrayBufferLike | ArrayBufferView>(buffer: T, newByteLength: number): T;