@zenfs/core 1.7.2 → 1.8.0

package/dist/file.js

@@ -3,6 +3,7 @@ import './polyfills.js';
 import { _chown, Stats } from './stats.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 +147,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 +172,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 +203,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 +236,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.');
@@ -291,10 +281,9 @@ 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.');
         }
@@ -316,7 +305,7 @@ export class PreloadFile extends File {
                 }
                 else {
                     // Extend the buffer!
-                    const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength: c.size_max }));
+                    const newBuffer = new Uint8Array(new ArrayBuffer(end, this.fs.metadata().noResizableBuffers ? {} : { maxByteLength }));
                     newBuffer.set(this._buffer);
                     this._buffer = newBuffer;
                 }
@@ -350,16 +339,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 +366,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.slice(position, end);
+        new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength).set(slice, offset);
         return bytesRead;
     }
     /**
@@ -411,65 +400,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 +465,266 @@ 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.slice(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, offset);
+        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, offset);
+        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);
+        new Uint8Array(buffer.buffer, offset, length).set(await this.fs.read(this.path, 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);
+        new Uint8Array(buffer.buffer, offset, length).set(this.fs.readSync(this.path, 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,10 @@ 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;
+    abstract read(path: string, offset: number, length: number): Promise<Uint8Array>;
+    abstract readSync(path: string, offset: number, length: number): Uint8Array;
+    abstract write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
+    abstract writeSync(path: string, buffer: Uint8Array, offset: number): void;
 }

package/dist/mixins/mutexed.d.ts

@@ -3,6 +3,7 @@ import type { CreationOptions, FileSystem, FileSystemMetadata } from '../filesys
 import type { Stats } from '../stats.js';
 import type { Concrete } from '../utils.js';
 import '../polyfills.js';
+import type { InodeLike } from '../backends/index.js';
 export declare class MutexLock {
     protected readonly previous?: MutexLock | undefined;
     protected current: PromiseWithResolvers<void>;
@@ -68,8 +69,12 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     existsSync(path: string): boolean;
     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;
+    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;
+    write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
+    writeSync(path: string, buffer: Uint8Array, offset: number): void;
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/mutexed.js

@@ -448,6 +448,62 @@ export class _MutexedFS {
             __disposeResources(env_22);
         }
     }
+    async read(path, offset, length) {
+        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);
+        }
+        catch (e_23) {
+            env_23.error = e_23;
+            env_23.hasError = true;
+        }
+        finally {
+            __disposeResources(env_23);
+        }
+    }
+    readSync(path, offset, length) {
+        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);
+        }
+        catch (e_24) {
+            env_24.error = e_24;
+            env_24.hasError = true;
+        }
+        finally {
+            __disposeResources(env_24);
+        }
+    }
+    async write(path, buffer, offset) {
+        const env_25 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_25, await this.lock(path, 'write'), false);
+            return await this._fs.write(path, buffer, offset);
+        }
+        catch (e_25) {
+            env_25.error = e_25;
+            env_25.hasError = true;
+        }
+        finally {
+            __disposeResources(env_25);
+        }
+    }
+    writeSync(path, buffer, offset) {
+        const env_26 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _ = __addDisposableResource(env_26, this.lockSync(path, 'write'), false);
+            return this._fs.writeSync(path, buffer, offset);
+        }
+        catch (e_26) {
+            env_26.error = e_26;
+            env_26.hasError = true;
+        }
+        finally {
+            __disposeResources(env_26);
+        }
+    }
 }
 /**
  * This serializes access to an underlying async filesystem.

package/dist/mixins/sync.d.ts

@@ -1,5 +1,5 @@
 import type { FileSystem } from '../filesystem.js';
-import type { Mixin, AsyncFSMethods } from './shared.js';
+import type { AsyncFSMethods, Mixin } from './shared.js';
 /**
  * Implements the asynchronous API in terms of the synchronous API.
  */