@zenfs/core 1.7.2 → 1.8.1

package/dist/file.js

@@ -1,8 +1,10 @@
 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
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export function parseFlag(flag) {
     if (typeof flag === 'number') {
@@ -146,7 +148,7 @@ export class PreloadFile extends File {
     /**
      * A buffer containing the entire contents of the file.
      */
-    _buffer = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: c.size_max }))) {
+    _buffer = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength }))) {
         super(fs, path);
         this.flag = flag;
         this.stats = stats;
@@ -171,9 +173,10 @@ export class PreloadFile extends File {
         if (this.stats.size == _buffer.byteLength) {
             return;
         }
-        if (isReadable(this.flag)) {
-            throw new Error(`Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`);
+        if (!isWriteable(this.flag)) {
+            throw new ErrnoError(Errno.EIO, `Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`, path);
         }
+        this.stats.size = _buffer.byteLength;
         this.dirty = true;
     }
     /**
@@ -201,36 +204,32 @@ export class PreloadFile extends File {
         this._position = value;
     }
     async sync() {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.sync');
-        }
-        if (!this.dirty) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'sync');
+        if (!this.dirty)
             return;
-        }
-        await this.fs.sync(this.path, this._buffer, this.stats);
+        if (!this.fs.metadata().readonly)
+            await this.fs.sync(this.path, this._buffer, this.stats);
         this.dirty = false;
     }
     syncSync() {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.sync');
-        }
-        if (!this.dirty) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'sync');
+        if (!this.dirty)
             return;
-        }
-        this.fs.syncSync(this.path, this._buffer, this.stats);
+        if (!this.fs.metadata().readonly)
+            this.fs.syncSync(this.path, this._buffer, this.stats);
         this.dirty = false;
     }
     async close() {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.close');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'close');
         await this.sync();
         this.dispose();
     }
     closeSync() {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.close');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'close');
         this.syncSync();
         this.dispose();
     }
@@ -238,34 +237,26 @@ export class PreloadFile extends File {
      * Cleans up. This will *not* sync the file data to the FS
      */
     dispose(force) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.dispose');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'dispose');
         if (this.dirty && !force) {
-            throw ErrnoError.With('EBUSY', this.path, 'File.dispose');
+            throw ErrnoError.With('EBUSY', this.path, 'dispose');
         }
-        // @ts-expect-error 2790
-        delete this._buffer;
-        // @ts-expect-error 2790
-        delete this.stats;
         this.closed = true;
     }
     stat() {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.stat');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'stat');
         return Promise.resolve(new Stats(this.stats));
     }
     statSync() {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.stat');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'stat');
         return new Stats(this.stats);
     }
     _truncate(length) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.truncate');
-        }
+        if (this.closed)
+            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.');
@@ -279,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);
@@ -291,37 +282,18 @@ export class PreloadFile extends File {
         if (config.syncImmediately)
             this.syncSync();
     }
-    _write(buffer, offset = 0, length = this.stats.size, position = this.position) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.write');
-        }
+    _write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        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.');
         }
         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: c.size_max }));
-                    newBuffer.set(this._buffer);
-                    this._buffer = newBuffer;
-                }
-            }
-        }
         this._buffer.set(slice, position);
         this.stats.mtimeMs = Date.now();
         this.position = position + slice.byteLength;
@@ -350,16 +322,15 @@ export class PreloadFile extends File {
      * If position is null, the data will be written at  the current position.
      * @returns bytes written
      */
-    writeSync(buffer, offset = 0, length = this.stats.size, position = this.position) {
+    writeSync(buffer, offset, length, position) {
         const bytesWritten = this._write(buffer, offset, length, position);
         if (config.syncImmediately)
             this.syncSync();
         return bytesWritten;
     }
-    _read(buffer, offset = 0, length = this.stats.size, position) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.read');
-        }
+    _read(buffer, offset = 0, length = buffer.byteLength - offset, position) {
+        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.');
         }
@@ -378,7 +349,8 @@ export class PreloadFile extends File {
             // No copy/read. Return immediately for better performance
             return bytesRead;
         }
-        new Uint8Array(buffer.buffer, offset, length).set(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;
     }
     /**
@@ -411,65 +383,61 @@ export class PreloadFile extends File {
         return bytesRead;
     }
     async chmod(mode) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.chmod');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chmod');
         this.dirty = true;
         this.stats.mode = (this.stats.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
         if (config.syncImmediately || mode > c.S_IFMT)
             await this.sync();
     }
     chmodSync(mode) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.chmod');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chmod');
         this.dirty = true;
         this.stats.mode = (this.stats.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
         if (config.syncImmediately || mode > c.S_IFMT)
             this.syncSync();
     }
     async chown(uid, gid) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.chown');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chown');
         this.dirty = true;
         _chown(this.stats, uid, gid);
         if (config.syncImmediately)
             await this.sync();
     }
     chownSync(uid, gid) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.chown');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chown');
         this.dirty = true;
         _chown(this.stats, uid, gid);
         if (config.syncImmediately)
             this.syncSync();
     }
     async utimes(atime, mtime) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.utimes');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'utimes');
         this.dirty = true;
-        this.stats.atime = atime;
-        this.stats.mtime = mtime;
+        this.stats.atimeMs = atime;
+        this.stats.mtimeMs = mtime;
         if (config.syncImmediately)
             await this.sync();
     }
     utimesSync(atime, mtime) {
-        if (this.closed) {
-            throw ErrnoError.With('EBADF', this.path, 'File.utimes');
-        }
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'utimes');
         this.dirty = true;
-        this.stats.atime = atime;
-        this.stats.mtime = mtime;
+        this.stats.atimeMs = atime;
+        this.stats.mtimeMs = mtime;
         if (config.syncImmediately)
             this.syncSync();
     }
 }
 /**
  * For the file systems which do not sync to anything.
+ * @deprecated
  */
+/* node:coverage disable */
 export class NoSyncFile extends PreloadFile {
     sync() {
         return Promise.resolve();
@@ -480,3 +448,267 @@ export class NoSyncFile extends PreloadFile {
     }
     closeSync() { }
 }
+/* node:coverage enable */
+/**
+ * An implementation of `File` that uses the FS
+ */
+export class LazyFile extends File {
+    /**
+     * Get the current file position.
+     *
+     * We emulate the following bug mentioned in the Node documentation:
+     *
+     * On Linux, positional writes don't work when the file is opened in append mode.
+     * The kernel ignores the position argument and always appends the data to the end of the file.
+     * @returns The current file position.
+     */
+    get position() {
+        return isAppendable(this.flag) ? this.stats.size : this._position;
+    }
+    set position(value) {
+        this._position = value;
+    }
+    /**
+     * Creates a file with `path` and, optionally, the given contents.
+     * Note that, if contents is specified, it will be mutated by the file.
+     */
+    constructor(fs, path, flag, stats) {
+        super(fs, path);
+        this.flag = flag;
+        this.stats = stats;
+        /**
+         * Current position
+         */
+        this._position = 0;
+        /**
+         * Whether the file has changes which have not been written to the FS
+         */
+        this.dirty = false;
+        /**
+         * Whether the file is open or closed
+         */
+        this.closed = false;
+        this.dirty = true;
+    }
+    async sync() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'sync');
+        if (!this.dirty)
+            return;
+        if (!this.fs.metadata().readonly)
+            await this.fs.sync(this.path, undefined, this.stats);
+        this.dirty = false;
+    }
+    syncSync() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'sync');
+        if (!this.dirty)
+            return;
+        if (!this.fs.metadata().readonly)
+            this.fs.syncSync(this.path, undefined, this.stats);
+        this.dirty = false;
+    }
+    async close() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'close');
+        await this.sync();
+        this.dispose();
+    }
+    closeSync() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'close');
+        this.syncSync();
+        this.dispose();
+    }
+    /**
+     * Cleans up. This will *not* sync the file data to the FS
+     */
+    dispose(force) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'dispose');
+        if (this.dirty && !force)
+            throw ErrnoError.With('EBUSY', this.path, 'dispose');
+        this.closed = true;
+    }
+    stat() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'stat');
+        return Promise.resolve(new Stats(this.stats));
+    }
+    statSync() {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'stat');
+        return new Stats(this.stats);
+    }
+    async truncate(length) {
+        if (this.closed)
+            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.');
+        }
+        this.stats.mtimeMs = Date.now();
+        this.stats.size = length;
+        if (config.syncImmediately)
+            await this.sync();
+    }
+    truncateSync(length) {
+        if (this.closed)
+            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.');
+        }
+        this.stats.mtimeMs = Date.now();
+        this.stats.size = length;
+        if (config.syncImmediately)
+            this.syncSync();
+    }
+    prepareWrite(buffer, offset, length, position) {
+        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.');
+        }
+        this.dirty = true;
+        const end = position + length;
+        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;
+    }
+    /**
+     * Write buffer to the file.
+     * @param buffer Uint8Array containing the data to write to the file.
+     * @param offset Offset in the buffer to start reading data from.
+     * @param length The amount of bytes to write to the file.
+     * @param position Offset from the beginning of the file where this data should be written.
+     * If position is null, the data will be written at  the current position.
+     */
+    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, position);
+        if (config.syncImmediately)
+            await this.sync();
+        return slice.byteLength;
+    }
+    /**
+     * Write buffer to the file.
+     * @param buffer Uint8Array containing the data to write to the file.
+     * @param offset Offset in the buffer to start reading data from.
+     * @param length The amount of bytes to write to the file.
+     * @param position Offset from the beginning of the file where this data should be written.
+     * If position is null, the data will be written at  the current position.
+     * @returns bytes written
+     */
+    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, position);
+        if (config.syncImmediately)
+            this.syncSync();
+        return slice.byteLength;
+    }
+    /**
+     * Computes position information for reading
+     */
+    prepareRead(length, position) {
+        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.');
+        if (config.updateOnRead)
+            this.dirty = true;
+        this.stats.atimeMs = Date.now();
+        let end = position + length;
+        if (end > this.stats.size) {
+            end = position + Math.max(this.stats.size - position, 0);
+        }
+        this._position = end;
+        return end - position;
+    }
+    /**
+     * Read data from the file.
+     * @param buffer The buffer that the data will be written to.
+     * @param offset The offset within the buffer where writing will start.
+     * @param length An integer specifying the number of bytes to read.
+     * @param position An integer specifying where to begin reading from in the file.
+     * If position is unset, data will be read from the current file position.
+     */
+    async read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        const bytesRead = this.prepareRead(length, position);
+        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 };
+    }
+    /**
+     * Read data from the file.
+     * @param buffer The buffer that the data will be written to.
+     * @param offset The offset within the buffer where writing will start.
+     * @param length An integer specifying the number of bytes to read.
+     * @param position An integer specifying where to begin reading from in the file.
+     * If position is null, data will be read from the current file position.
+     * @returns number of bytes written
+     */
+    readSync(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
+        const bytesRead = this.prepareRead(length, position);
+        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;
+    }
+    async chmod(mode) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chmod');
+        this.dirty = true;
+        this.stats.mode = (this.stats.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+        if (config.syncImmediately || mode > c.S_IFMT)
+            await this.sync();
+    }
+    chmodSync(mode) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chmod');
+        this.dirty = true;
+        this.stats.mode = (this.stats.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
+        if (config.syncImmediately || mode > c.S_IFMT)
+            this.syncSync();
+    }
+    async chown(uid, gid) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chown');
+        this.dirty = true;
+        _chown(this.stats, uid, gid);
+        if (config.syncImmediately)
+            await this.sync();
+    }
+    chownSync(uid, gid) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'chown');
+        this.dirty = true;
+        _chown(this.stats, uid, gid);
+        if (config.syncImmediately)
+            this.syncSync();
+    }
+    async utimes(atime, mtime) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'utimes');
+        this.dirty = true;
+        this.stats.atimeMs = atime;
+        this.stats.mtimeMs = mtime;
+        if (config.syncImmediately)
+            await this.sync();
+    }
+    utimesSync(atime, mtime) {
+        if (this.closed)
+            throw ErrnoError.With('EBADF', this.path, 'utimes');
+        this.dirty = true;
+        this.stats.atimeMs = atime;
+        this.stats.mtimeMs = mtime;
+        if (config.syncImmediately)
+            this.syncSync();
+    }
+}

package/dist/filesystem.d.ts

@@ -1,5 +1,5 @@
 import type { File } from './file.js';
-import type { Stats } from './stats.js';
+import type { Stats, StatsLike } from './stats.js';
 export type FileContents = ArrayBufferView | string;
 /**
  * Metadata about a FileSystem
@@ -58,7 +58,8 @@ export interface FileSystemMetadata {
     features?: ('setid' | '')[];
 }
 /**
- * Options used when creating files and directories
+ * Options used when creating files and directories.
+ * This weird naming and such is to preserve backward compatibility.
  * @todo [BREAKING] Move the `mode` parameter of `createFile` and `mkdir` into this
  * @internal
  */
@@ -73,6 +74,19 @@ export interface CreationOptions {
      * This is ignored if the FS supports setgid and the setgid bit is set
      */
     gid: number;
+    /**
+     * The mode to create the file with.
+     */
+    mode?: number;
+}
+/**
+ * This is the correct type that will be used when the API is updated in a breaking release
+ */
+export interface PureCreationOptions extends CreationOptions {
+    /**
+     * The mode to create the file with.
+     */
+    mode: number;
 }
 /**
  * Provides a consistent and easy to use internal API.
@@ -135,6 +149,32 @@ export declare abstract class FileSystem {
     existsSync(path: string): boolean;
     abstract link(target: string, link: string): Promise<void>;
     abstract linkSync(target: string, link: string): void;
-    abstract sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    abstract syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    abstract sync(path: string, data?: Uint8Array, stats?: Partial<Readonly<StatsLike>>): Promise<void>;
+    abstract syncSync(path: string, data?: Uint8Array, stats?: Partial<Readonly<StatsLike>>): 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 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
          */