@zenfs/core 1.8.0 → 1.8.1

package/dist/backends/overlay.d.ts

@@ -24,7 +24,7 @@ export interface OverlayOptions {
  *
  * @internal
  */
-export declare class UnmutexedOverlayFS extends FileSystem {
+export declare class OverlayFS extends FileSystem {
     ready(): Promise<void>;
     readonly writable: FileSystem;
     readonly readable: FileSystem;
@@ -39,8 +39,8 @@ export declare class UnmutexedOverlayFS extends FileSystem {
     metadata(): FileSystemMetadata;
     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;
     /**
@@ -97,17 +97,6 @@ export declare class UnmutexedOverlayFS extends FileSystem {
     private copyToWritableSync;
     private copyToWritable;
 }
-declare const OverlayFS_base: {
-    new (): import("../mixins/mutexed.js")._MutexedFS<UnmutexedOverlayFS>;
-} & (new (args_0: OverlayOptions) => import("../mixins/mutexed.js")._MutexedFS<UnmutexedOverlayFS>);
-/**
- * OverlayFS makes a read-only filesystem writable by storing writes on a second,
- * writable file system. Deletes are persisted via metadata stored on the writable
- * file system.
- * @internal
- */
-export declare class OverlayFS extends OverlayFS_base {
-}
 declare const _Overlay: {
     readonly name: "Overlay";
     readonly options: {

package/dist/backends/overlay.js

@@ -51,9 +51,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { Errno, ErrnoError } from '../error.js';
-import { PreloadFile, parseFlag } from '../file.js';
+import { LazyFile, parseFlag } from '../file.js';
 import { FileSystem } from '../filesystem.js';
-import { Mutexed } from '../mixins/mutexed.js';
 import { canary, decodeUTF8, encodeUTF8 } from '../utils.js';
 import { dirname, join } from '../vfs/path.js';
 /** @internal */
@@ -66,7 +65,7 @@ const deletionLogPath = '/.deleted';
  *
  * @internal
  */
-export class UnmutexedOverlayFS extends FileSystem {
+export class OverlayFS extends FileSystem {
     async ready() {
         await this.readable.ready();
         await this.writable.ready();
@@ -103,11 +102,11 @@ export class UnmutexedOverlayFS extends FileSystem {
         this.copyForWriteSync(path);
         this.writable.syncSync(path, data, stats);
     }
-    async read(path, offset, length) {
-        return (await this.writable.exists(path)) ? await this.writable.read(path, offset, length) : await this.readable.read(path, offset, length);
+    async read(path, buffer, offset, end) {
+        return (await this.writable.exists(path)) ? await this.writable.read(path, buffer, offset, end) : await this.readable.read(path, buffer, offset, end);
     }
-    readSync(path, offset, length) {
-        return this.writable.existsSync(path) ? this.writable.readSync(path, offset, length) : this.readable.readSync(path, offset, length);
+    readSync(path, buffer, offset, end) {
+        return this.writable.existsSync(path) ? this.writable.readSync(path, buffer, offset, end) : this.readable.readSync(path, buffer, offset, end);
     }
     async write(path, buffer, offset) {
         await this.copyForWrite(path);
@@ -210,22 +209,15 @@ export class UnmutexedOverlayFS extends FileSystem {
         if (await this.writable.exists(path)) {
             return this.writable.openFile(path, flag);
         }
-        // Create an OverlayFile.
-        const file = await this.readable.openFile(path, parseFlag('r'));
-        const stats = await file.stat();
-        const { buffer } = await file.read(new Uint8Array(stats.size));
-        return new PreloadFile(this, path, flag, stats, buffer);
+        const stats = await this.readable.stat(path);
+        return new LazyFile(this, path, flag, stats);
     }
     openFileSync(path, flag) {
         if (this.writable.existsSync(path)) {
             return this.writable.openFileSync(path, flag);
         }
-        // Create an OverlayFile.
-        const file = this.readable.openFileSync(path, parseFlag('r'));
-        const stats = file.statSync();
-        const data = new Uint8Array(stats.size);
-        file.readSync(data);
-        return new PreloadFile(this, path, flag, stats, data);
+        const stats = this.readable.statSync(path);
+        return new LazyFile(this, path, flag, stats);
     }
     async createFile(path, flag, mode, options) {
         this.checkInitialized();
@@ -547,14 +539,6 @@ export class UnmutexedOverlayFS extends FileSystem {
         }
     }
 }
-/**
- * OverlayFS makes a read-only filesystem writable by storing writes on a second,
- * writable file system. Deletes are persisted via metadata stored on the writable
- * file system.
- * @internal
- */
-export class OverlayFS extends Mutexed(UnmutexedOverlayFS) {
-}
 const _Overlay = {
     name: 'Overlay',
     options: {

package/dist/backends/passthrough.d.ts

@@ -1,7 +1,8 @@
 import type * as fs from 'node:fs';
+import { File } from '../file.js';
 import { FileSystem } from '../filesystem.js';
 import { Stats } from '../stats.js';
-import { File } from '../file.js';
+import type { InodeLike } from './store/inode.js';
 export type NodeFS = typeof fs;
 export interface PassthroughOptions {
     fs: NodeFS;
@@ -80,11 +81,11 @@ export declare class PassthroughFS extends FileSystem {
     /**
      * Synchronize data to the file system.
      */
-    sync(path: string, data: Uint8Array, stats: Stats): Promise<void>;
+    sync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): Promise<void>;
     /**
      * Synchronize data to the file system synchronously.
      */
-    syncSync(path: string, data: Uint8Array, stats: Stats): void;
+    syncSync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): void;
     /**
      * Create a hard link.
      */
@@ -93,8 +94,8 @@ export declare class PassthroughFS extends FileSystem {
      * Create a hard link synchronously.
      */
     linkSync(target: string, link: string): 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;
 }

package/dist/backends/passthrough.js

@@ -50,10 +50,10 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { FileSystem } from '../filesystem.js';
 import { ErrnoError } from '../error.js';
-import { Stats } from '../stats.js';
 import { File } from '../file.js';
+import { FileSystem } from '../filesystem.js';
+import { Stats } from '../stats.js';
 import { join, resolve } from '../vfs/path.js';
 class PassthroughFile extends File {
     constructor(fs, path, fd) {
@@ -333,7 +333,23 @@ export class PassthroughFS extends FileSystem {
      */
     async sync(path, data, stats) {
         try {
-            await this.nodeFS.promises.writeFile(this.path(path), data);
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const handle = __addDisposableResource(env_1, await this.nodeFS.promises.open(this.path(path), 'w'), true);
+                await handle.writeFile(data);
+                await handle.chmod(stats.mode);
+                await handle.chown(stats.uid, stats.gid);
+                await handle.utimes(stats.atimeMs, stats.mtimeMs);
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
         }
         catch (err) {
             this.error(err, path);
@@ -344,7 +360,11 @@ export class PassthroughFS extends FileSystem {
      */
     syncSync(path, data, stats) {
         try {
-            this.nodeFS.writeFileSync(this.path(path), data);
+            const p = this.path(path);
+            this.nodeFS.writeFileSync(p, data);
+            this.nodeFS.chmodSync(p, stats.mode);
+            this.nodeFS.chownSync(p, stats.uid, stats.gid);
+            this.nodeFS.utimesSync(p, stats.atimeMs, stats.mtimeMs);
         }
         catch (err) {
             this.error(err, path);
@@ -372,36 +392,32 @@ export class PassthroughFS extends FileSystem {
             this.error(err, target);
         }
     }
-    async read(path, offset, length) {
+    async read(path, buffer, offset, end) {
         try {
-            const env_1 = { stack: [], error: void 0, hasError: false };
+            const env_2 = { stack: [], error: void 0, hasError: false };
             try {
-                const handle = __addDisposableResource(env_1, await this.nodeFS.promises.open(this.path(path), 'r'), true);
-                const buffer = new Uint8Array(length);
-                await handle.read({ buffer, offset, length });
-                return buffer;
+                const handle = __addDisposableResource(env_2, await this.nodeFS.promises.open(this.path(path), 'r'), true);
+                await handle.read({ buffer, offset, length: end - offset });
             }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
             }
             finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
+                const result_2 = __disposeResources(env_2);
+                if (result_2)
+                    await result_2;
             }
         }
         catch (err) {
             this.error(err, path);
         }
     }
-    readSync(path, offset, length) {
+    readSync(path, buffer, offset, end) {
         let fd;
         try {
             fd = this.nodeFS.openSync(this.path(path), 'r');
-            const buffer = new Uint8Array(length);
-            this.nodeFS.readSync(fd, buffer, { offset, length });
-            return buffer;
+            this.nodeFS.readSync(fd, buffer, { offset, length: end - offset });
         }
         catch (err) {
             this.error(err, path);
@@ -415,19 +431,19 @@ export class PassthroughFS extends FileSystem {
     }
     async write(path, buffer, offset) {
         try {
-            const env_2 = { stack: [], error: void 0, hasError: false };
+            const env_3 = { stack: [], error: void 0, hasError: false };
             try {
-                const handle = __addDisposableResource(env_2, await this.nodeFS.promises.open(this.path(path), 'w'), true);
+                const handle = __addDisposableResource(env_3, await this.nodeFS.promises.open(this.path(path), 'w'), true);
                 await handle.write(buffer, offset);
             }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
             }
             finally {
-                const result_2 = __disposeResources(env_2);
-                if (result_2)
-                    await result_2;
+                const result_3 = __disposeResources(env_3);
+                if (result_3)
+                    await result_3;
             }
         }
         catch (err) {

package/dist/backends/port/fs.d.ts

@@ -1,19 +1,20 @@
-import { type ExtractProperties } from 'utilium';
+import type { ExtractProperties } from 'utilium';
 import type { MountConfiguration } from '../../config.js';
 import type { CreationOptions, FileSystemMetadata } from '../../filesystem.js';
 import type { Backend, FilesystemOf } from '../backend.js';
-import { File } from '../../file.js';
+import type { Inode, InodeLike } from '../store/inode.js';
+import type { File } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 import { Stats } from '../../stats.js';
-import type { Inode, InodeLike } from '../store/inode.js';
 import * as RPC from './rpc.js';
 type FSMethods = ExtractProperties<FileSystem, (...args: any[]) => Promise<any> | FileSystemMetadata>;
 type FSMethod = keyof FSMethods;
-/** @internal */
-export interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Request {
-    method: TMethod;
-    args: Parameters<FSMethods[TMethod]>;
-}
+export type FSRequest<TMethod extends FSMethod = FSMethod> = RPC.Message & {
+    [M in TMethod]: {
+        method: M;
+        args: Parameters<FSMethods[M]>;
+    };
+}[TMethod];
 declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, import("../../mixins/async.js").AsyncMixin>;
 /**
  * PortFS lets you access an FS instance that is running in a port, or the other way around.
@@ -46,7 +47,7 @@ export declare class PortFS extends PortFS_base {
     readdir(path: string): Promise<string[]>;
     exists(path: string): Promise<boolean>;
     link(srcpath: string, dstpath: string): Promise<void>;
-    read(path: string, offset: number, length: number): Promise<Uint8Array>;
+    read(path: string, buffer: Uint8Array, offset: number, length: number): Promise<void>;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
 }
 /** @internal */

package/dist/backends/port/fs.js

@@ -1,60 +1,6 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import { pick } from 'utilium';
 import { resolveMountConfig } from '../../config.js';
 import { Errno, ErrnoError } from '../../error.js';
-import { File } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
 import { Async } from '../../mixins/async.js';
 import { Stats } from '../../stats.js';
@@ -127,8 +73,9 @@ export class PortFS extends Async(FileSystem) {
     link(srcpath, dstpath) {
         return this.rpc('link', srcpath, dstpath);
     }
-    read(path, offset, length) {
-        return this.rpc('read', path, offset, length);
+    async read(path, buffer, offset, length) {
+        const _buf = (await this.rpc('read', path, buffer, offset, length));
+        buffer.set(_buf);
     }
     write(path, buffer, offset) {
         return this.rpc('write', path, buffer, offset);
@@ -140,41 +87,29 @@ export async function handleRequest(port, fs, request) {
         return;
     const { method, args, id, stack } = request;
     let value, error = false;
-    const transfer = [];
     try {
         // @ts-expect-error 2556
         value = await fs[method](...args);
-        if (value instanceof File) {
-            const env_1 = { stack: [], error: void 0, hasError: false };
-            try {
-                const file = __addDisposableResource(env_1, await fs.openFile(args[0], 'r+'), true);
-                const stats = await file.stat();
-                const data = new Uint8Array(stats.size);
-                await file.read(data);
+        switch (method) {
+            case 'openFile':
+            case 'createFile': {
                 value = {
-                    path: value.path,
+                    path: args[0],
                     flag: args[1],
-                    stats,
-                    buffer: data.buffer,
+                    stats: await fs.stat(args[0]),
                 };
-                transfer.push(data.buffer);
-            }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
-            }
-            finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
+                break;
             }
+            case 'read':
+                value = args[1];
+                break;
         }
     }
     catch (e) {
         value = e instanceof ErrnoError ? e.toJSON() : pick(e, 'message', 'stack');
         error = true;
     }
-    port.postMessage({ _zenfs: true, id, error, method, stack, value }, transfer);
+    port.postMessage({ _zenfs: true, id, error, method, stack, value });
 }
 export function attachFS(port, fs) {
     RPC.attach(port, request => handleRequest(port, fs, request));

package/dist/backends/port/rpc.d.ts

@@ -45,12 +45,16 @@ interface _ResponseWithValue<T> extends Message {
     error: false;
     value: Awaited<T> extends File ? FileData : Awaited<T>;
 }
-export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T>;
+interface _ResponseRead extends Message {
+    error: false;
+    method: 'read';
+    value: Uint8Array;
+}
+export type Response<T = unknown> = _ResponseWithError | _ResponseWithValue<T> | _ResponseRead;
 export interface FileData {
     path: string;
     flag: string;
     stats: StatsLike<number>;
-    buffer: ArrayBuffer;
 }
 export { FileData as File };
 export declare function isMessage(arg: unknown): arg is Message;

package/dist/backends/port/rpc.js

@@ -1,5 +1,5 @@
 import { Errno, ErrnoError } from '../../error.js';
-import { PreloadFile } from '../../file.js';
+import { LazyFile } from '../../file.js';
 import { Stats } from '../../stats.js';
 import { handleRequest } from './fs.js';
 function isFileData(value) {
@@ -47,8 +47,8 @@ export function handleResponse(response) {
         return;
     }
     if (isFileData(value)) {
-        const { path, flag, stats, buffer } = value;
-        const file = new PreloadFile(fs, path, flag, new Stats(stats), new Uint8Array(buffer));
+        const { path, flag, stats } = value;
+        const file = new LazyFile(fs, path, flag, new Stats(stats));
         resolve(file);
         executors.delete(id);
         return;

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

@@ -73,25 +73,9 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     syncSync(path: string, data?: Uint8Array, metadata?: Readonly<InodeLike>): void;
     link(target: string, link: string): Promise<void>;
     linkSync(target: string, link: string): void;
-    /**
-     * Used by lazy file
-     * @internal
-     */
-    read(path: string, offset: number, length: number): Promise<Uint8Array>;
-    /**
-     * Used by lazy file
-     * @internal
-     */
-    readSync(path: string, offset: number, length: number): Uint8Array;
-    /**
-     * Used by lazy file
-     * @internal
-     */
+    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>;
-    /**
-     * Used by lazy file
-     * @internal
-     */
     writeSync(path: string, data: Uint8Array, offset: number): void;
     /**
      * Checks if the root directory exists. Creates it if it doesn't.

package/dist/backends/store/fs.js

@@ -52,9 +52,9 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { randomInt, serialize } from 'utilium';
 import { Errno, ErrnoError } from '../../error.js';
-import { PreloadFile } from '../../file.js';
+import { LazyFile } from '../../file.js';
 import { FileSystem } from '../../filesystem.js';
-import { _throw, canary, decodeDirListing, encodeDirListing, encodeUTF8 } from '../../utils.js';
+import { _throw, canary, decodeDirListing, encodeDirListing, encodeUTF8, growBuffer } from '../../utils.js';
 import { S_IFDIR, S_IFREG, S_ISGID, S_ISUID, size_max } from '../../vfs/constants.js';
 import { basename, dirname, join, parse, resolve } from '../../vfs/path.js';
 import { Index } from './file_index.js';
@@ -354,20 +354,19 @@ export class StoreFS extends FileSystem {
     }
     async createFile(path, flag, mode, options) {
         const node = await this.commitNew(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
-        return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
+        return new LazyFile(this, path, flag, node.toStats());
     }
     createFileSync(path, flag, mode, options) {
         const node = this.commitNewSync(path, S_IFREG, { mode, ...options }, new Uint8Array(), 'createFile');
-        return new PreloadFile(this, path, flag, node.toStats(), new Uint8Array());
+        return new LazyFile(this, path, flag, node.toStats());
     }
     async openFile(path, flag) {
-        var _a;
         const env_9 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_9, this.store.transaction(), true);
             const node = await this.findInode(tx, path, 'openFile');
-            const data = (_a = (await tx.get(node.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'openFile'));
-            return new PreloadFile(this, path, flag, node.toStats(), data);
+            //const data = (await tx.get(node.data)) ?? _throw(ErrnoError.With('ENODATA', path, 'openFile'));
+            return new LazyFile(this, path, flag, node.toStats());
         }
         catch (e_9) {
             env_9.error = e_9;
@@ -380,13 +379,12 @@ export class StoreFS extends FileSystem {
         }
     }
     openFileSync(path, flag) {
-        var _a;
         const env_10 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_10, this.store.transaction(), false);
             const node = this.findInodeSync(tx, path, 'openFile');
-            const data = (_a = tx.getSync(node.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENOENT', path, 'openFile'));
-            return new PreloadFile(this, path, flag, node.toStats(), data);
+            //const data = tx.getSync(node.data) ?? _throw(ErrnoError.With('ENODATA', path, 'openFile'));
+            return new LazyFile(this, path, flag, node.toStats());
         }
         catch (e_10) {
             env_10.error = e_10;
@@ -546,18 +544,14 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_16);
         }
     }
-    /**
-     * Used by lazy file
-     * @internal
-     */
-    async read(path, offset, length) {
+    async read(path, buffer, offset, end) {
         var _a;
         const env_17 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_17, this.store.transaction(), true);
             const inode = await this.findInode(tx, path, 'read');
-            const buffer = (_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
-            return buffer.slice(offset, offset + length);
+            const data = (_a = (await tx.get(inode.data))) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
+            buffer.set(data.subarray(offset, end));
         }
         catch (e_17) {
             env_17.error = e_17;
@@ -569,18 +563,14 @@ export class StoreFS extends FileSystem {
                 await result_9;
         }
     }
-    /**
-     * Used by lazy file
-     * @internal
-     */
-    readSync(path, offset, length) {
+    readSync(path, buffer, offset, end) {
         var _a;
         const env_18 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_18, this.store.transaction(), false);
             const inode = this.findInodeSync(tx, path, 'read');
-            const buffer = (_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
-            return buffer.slice(offset, offset + length);
+            const data = (_a = tx.getSync(inode.data)) !== null && _a !== void 0 ? _a : _throw(ErrnoError.With('ENODATA', path, 'read'));
+            buffer.set(data.subarray(offset, end));
         }
         catch (e_18) {
             env_18.error = e_18;
@@ -590,18 +580,17 @@ export class StoreFS extends FileSystem {
             __disposeResources(env_18);
         }
     }
-    /**
-     * Used by lazy file
-     * @internal
-     */
     async write(path, data, offset) {
         const env_19 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_19, this.store.transaction(), true);
             const inode = await this.findInode(tx, path, 'write');
-            const buffer = await tx.get(inode.data);
+            const buffer = growBuffer(await tx.get(inode.data), offset + data.byteLength);
             buffer.set(data, offset);
-            await this.sync(path, buffer, inode);
+            inode.update({ mtimeMs: Date.now(), size: buffer.byteLength });
+            await tx.set(inode.ino, serialize(inode));
+            await tx.set(inode.data, buffer);
+            await tx.commit();
         }
         catch (e_19) {
             env_19.error = e_19;
@@ -613,18 +602,14 @@ export class StoreFS extends FileSystem {
                 await result_10;
         }
     }
-    /**
-     * Used by lazy file
-     * @internal
-     */
     writeSync(path, data, offset) {
         const env_20 = { stack: [], error: void 0, hasError: false };
         try {
             const tx = __addDisposableResource(env_20, this.store.transaction(), false);
             const inode = this.findInodeSync(tx, path, 'write');
-            inode.update({ mtimeMs: Date.now() });
-            const buffer = tx.getSync(inode.data);
+            const buffer = growBuffer(tx.getSync(inode.data), offset + data.byteLength);
             buffer.set(data, offset);
+            inode.update({ mtimeMs: Date.now(), size: buffer.byteLength });
             tx.setSync(inode.ino, serialize(inode));
             tx.setSync(inode.data, buffer);
             tx.commitSync();