@zenfs/core 2.7.7 → 2.8.1

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

@@ -123,7 +123,7 @@ export declare class StoreFS<T extends Store = Store> extends FileSystem {
     protected findInodeSync(tx: WrappedTransaction, path: string): Inode;
     private _lastID?;
     /** Allocates a new ID and adds the ID/path */
-    protected allocNew(path: string): number;
+    protected allocNew(path: string): [number, number];
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
      * Note: This will commit the transaction.

package/dist/backends/store/fs.js

@@ -616,13 +616,20 @@ export class StoreFS extends FileSystem {
             const tx = __addDisposableResource(env_17, this.transaction(), true);
             const inode = await this.findInode(tx, path);
             const end = offset + data.byteLength;
-            let buffer = data;
             if (!tx.flag('partial')) {
-                buffer = extendBuffer((await tx.get(inode.data)) ?? new Uint8Array(), end);
+                const buffer = extendBuffer((await tx.get(inode.data)) ?? new Uint8Array(), end);
                 buffer.set(data, offset);
-                offset = 0;
+                await tx.set(inode.data, buffer);
+            }
+            else if (offset <= inode.size) {
+                await tx.set(inode.data, data, offset);
+            }
+            else {
+                // Writes past the end of the file also zero the bytes before them
+                const extended = new Uint8Array(end - inode.size);
+                extended.set(data, offset - inode.size);
+                await tx.set(inode.data, extended, inode.size);
             }
-            await tx.set(inode.data, buffer, offset);
             // Update the inode in the same transaction, so data and metadata can not get out of sync (#286)
             inode.update({ size: Math.max(inode.size, end), mtimeMs: Date.now() });
             await tx.set(inode.ino, inode);
@@ -645,13 +652,20 @@ export class StoreFS extends FileSystem {
             const tx = __addDisposableResource(env_18, this.transaction(), false);
             const inode = this.findInodeSync(tx, path);
             const end = offset + data.byteLength;
-            let buffer = data;
             if (!tx.flag('partial')) {
-                buffer = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array(), end);
+                const buffer = extendBuffer(tx.getSync(inode.data) ?? new Uint8Array(), end);
                 buffer.set(data, offset);
-                offset = 0;
+                tx.setSync(inode.data, buffer);
+            }
+            else if (offset <= inode.size) {
+                tx.setSync(inode.data, data, offset);
+            }
+            else {
+                // Writes past the end of the file also zero the bytes before them
+                const extended = new Uint8Array(end - inode.size);
+                extended.set(data, offset - inode.size);
+                tx.setSync(inode.data, extended, inode.size);
             }
-            tx.setSync(inode.data, buffer, offset);
             // Update the inode in the same transaction, so data and metadata can not get out of sync (#286)
             inode.update({ size: Math.max(inode.size, end), mtimeMs: Date.now() });
             tx.setSync(inode.ino, inode);
@@ -915,6 +929,11 @@ export class StoreFS extends FileSystem {
     _lastID;
     /** Allocates a new ID and adds the ID/path */
     allocNew(path) {
+        if (this.store.allocId) {
+            const ids = this.store.allocId();
+            this._add(ids[0], path);
+            return ids;
+        }
         // @todo use `Iterator` helper #296
         this._lastID ||= Array.from(this._paths.keys()).reduce((max, ino) => Math.max(max, ino), 0);
         this._lastID += 2;
@@ -922,7 +941,7 @@ export class StoreFS extends FileSystem {
         if (id > size_max)
             throw err(withErrno('ENOSPC', 'No IDs available'));
         this._add(id, path);
-        return id;
+        return [id, id + 1];
     }
     /**
      * Commits a new file (well, a FILE or a DIRECTORY) to the file system with `mode`.
@@ -947,11 +966,11 @@ export class StoreFS extends FileSystem {
             const listing = decodeDirListing((await tx.get(parent.data)) ?? _throw(withErrno('ENOENT')));
             if (listing[fname])
                 throw withErrno('EEXIST');
-            const id = this.allocNew(path);
+            const [ino, dataId] = this.allocNew(path);
             const inode = new Inode({
                 ...options,
-                ino: id,
-                data: id + 1,
+                ino,
+                data: dataId,
                 size: data.byteLength,
                 nlink: 1,
             });
@@ -996,11 +1015,11 @@ export class StoreFS extends FileSystem {
             const listing = decodeDirListing(tx.getSync(parent.data) ?? _throw(withErrno('ENOENT')));
             if (listing[fname])
                 throw withErrno('EEXIST');
-            const id = this.allocNew(path);
+            const [ino, dataId] = this.allocNew(path);
             const inode = new Inode({
                 ...options,
-                ino: id,
-                data: id + 1,
+                ino,
+                data: dataId,
                 size: data.byteLength,
                 nlink: 1,
             });

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

@@ -6,9 +6,9 @@ import { AsyncTransaction, SyncTransaction } from './store.js';
  */
 export interface SyncMapStore extends Store {
     keys(): Iterable<number>;
-    get(id: number): Uint8Array | undefined;
-    getAsync?(id: number): Promise<Uint8Array | undefined>;
-    set(id: number, data: Uint8Array): void;
+    get(id: number, offset?: number, end?: number): Uint8Array | undefined;
+    getAsync?(id: number, offset?: number, end?: number): Promise<Uint8Array | undefined>;
+    set(id: number, data: Uint8Array, offset?: number): void;
     delete(id: number): void;
 }
 /**
@@ -19,9 +19,9 @@ export interface SyncMapStore extends Store {
 export declare class SyncMapTransaction extends SyncTransaction<SyncMapStore> {
     readonly store: SyncMapStore;
     keys(): Promise<Iterable<number>>;
-    get(id: number): Promise<Uint8Array | undefined>;
-    getSync(id: number): Uint8Array | undefined;
-    setSync(id: number, data: Uint8Array): void;
+    get(id: number, offset?: number, end?: number): Promise<Uint8Array | undefined>;
+    getSync(id: number, offset?: number, end?: number): Uint8Array | undefined;
+    setSync(id: number, data: Uint8Array, offset?: number): void;
     removeSync(id: number): void;
 }
 /**

package/dist/backends/store/map.js

@@ -9,14 +9,14 @@ export class SyncMapTransaction extends SyncTransaction {
     async keys() {
         return this.store.keys();
     }
-    async get(id) {
-        return await (this.store.getAsync?.(id) ?? this.store.get(id));
+    async get(id, offset, end) {
+        return await (this.store.getAsync?.(id, offset, end) ?? this.store.get(id, offset, end));
     }
-    getSync(id) {
-        return this.store.get(id);
+    getSync(id, offset, end) {
+        return this.store.get(id, offset, end);
     }
-    setSync(id, data) {
-        this.store.set(id, data);
+    setSync(id, data, offset) {
+        this.store.set(id, data, offset);
     }
     removeSync(id) {
         this.store.delete(id);

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

@@ -7,7 +7,7 @@ import type { StoreFS } from './fs.js';
  * @category Stores and Transactions
  */
 export type StoreFlag = 
-/** The store supports partial reads and writes */
+/** The store supports reading ranges and writing at offsets */
 'partial';
 /**
  * Represents a key-value store.
@@ -48,6 +48,10 @@ export interface Store {
      * Usage information for the store
      */
     usage?(): UsageInfo;
+    /**
+     * Allocate IDs for a new inode + data
+     */
+    allocId?(): [ino: number, data: number];
     /**
      * @internal @hidden
      */
@@ -77,17 +81,17 @@ export declare abstract class Transaction<T extends Store = Store> {
      */
     abstract getSync(id: number, offset: number, end?: number): Uint8Array | undefined;
     /**
-     * Adds the data to the store under an id. Overwrites any existing data.
-     * @param id The key to add the data under.
-     * @param data The data to add to the store.
+     * Stores data under an id.
+     * Without `offset`, replaces any existing data.
+     * With `offset`, writes the data at `offset` and keeps the rest, which partial stores must support.
      */
-    abstract set(id: number, data: Uint8Array, offset: number): Promise<void>;
+    abstract set(id: number, data: Uint8Array, offset?: number): Promise<void>;
     /**
-     * Adds the data to the store under and id.
-     * @param id The key to add the data under.
-     * @param data The data to add to the store.
+     * Stores data under an id.
+     * Without `offset`, replaces any existing data.
+     * With `offset`, writes the data at `offset` and keeps the rest, which partial stores must support.
      */
-    abstract setSync(id: number, data: Uint8Array, offset: number): void;
+    abstract setSync(id: number, data: Uint8Array, offset?: number): void;
     /**
      * Deletes the data at `ino`.
      * @param id The key to delete from the store.
@@ -105,7 +109,7 @@ export declare abstract class Transaction<T extends Store = Store> {
  */
 export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
     get(id: number, offset: number, end?: number): Promise<Uint8Array | undefined>;
-    set(id: number, data: Uint8Array, offset: number): Promise<void>;
+    set(id: number, data: Uint8Array, offset?: number): Promise<void>;
     remove(id: number): Promise<void>;
 }
 /**
@@ -136,7 +140,7 @@ export declare abstract class AsyncTransaction<T extends AsyncStore = AsyncStore
         size: number;
     }): Resource<number> | undefined;
     getSync(id: number, offset: number, end?: number): Uint8Array | undefined;
-    setSync(id: number, data: Uint8Array, offset: number): void;
+    setSync(id: number, data: Uint8Array, offset?: number): void;
     removeSync(id: number): void;
 }
 /**
@@ -160,7 +164,7 @@ export declare class WrappedTransaction<T extends Store = Store> {
      */
     protected originalData: Map<number, {
         data?: Uint8Array;
-        offset: number;
+        offset?: number;
     }[]>;
     /**
      * List of keys modified in this transaction, if any.
@@ -189,9 +193,9 @@ export declare class WrappedTransaction<T extends Store = Store> {
     /**
      * Marks an id as modified, and stashes its value if it has not been stashed already.
      */
-    protected markModified(id: number, offset: number, length?: number): Promise<void>;
+    protected markModified(id: number, offset?: number, length?: number): Promise<void>;
     /**
      * Marks an id as modified, and stashes its value if it has not been stashed already.
      */
-    protected markModifiedSync(id: number, offset: number, length?: number): void;
+    protected markModifiedSync(id: number, offset?: number, length?: number): void;
 }

package/dist/backends/store/store.js

@@ -126,22 +126,22 @@ export class WrappedTransaction {
         this.stash(id);
         return data;
     }
-    async set(id, view, offset = 0) {
+    async set(id, view, offset) {
         await this.markModified(id, offset, view.byteLength);
         const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
         await this.raw.set(id, buffer, offset);
     }
-    setSync(id, view, offset = 0) {
+    setSync(id, view, offset) {
         this.markModifiedSync(id, offset, view.byteLength);
         const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
         this.raw.setSync(id, buffer, offset);
     }
     async remove(id) {
-        await this.markModified(id, 0, undefined);
+        await this.markModified(id);
         await this.raw.remove(id);
     }
     removeSync(id) {
-        this.markModifiedSync(id, 0, undefined);
+        this.markModifiedSync(id);
         this.raw.removeSync(id);
     }
     commit() {
@@ -201,7 +201,7 @@ export class WrappedTransaction {
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    stash(id, data, offset = 0) {
+    stash(id, data, offset) {
         this.originalData.getOrInsertComputed(id, () => []).push({ data, offset });
     }
     /**
@@ -209,9 +209,9 @@ export class WrappedTransaction {
      */
     async markModified(id, offset, length) {
         this.modifiedKeys.add(id);
-        const end = length ? offset + length : undefined;
+        const end = offset !== undefined && length ? offset + length : undefined;
         try {
-            this.stash(id, await this.raw.get(id, offset, end), offset);
+            this.stash(id, await this.raw.get(id, offset ?? 0, end), offset);
         }
         catch (e) {
             if (!(this.raw instanceof AsyncTransaction))
@@ -225,7 +225,7 @@ export class WrappedTransaction {
             const resource = tx._cached(id);
             if (!resource)
                 throw e;
-            for (const range of resource.cached(offset, end ?? offset)) {
+            for (const range of resource.cached(offset ?? 0, end ?? offset ?? 0)) {
                 this.stash(id, await this.raw.get(id, range.start, range.end), range.start);
             }
         }
@@ -235,9 +235,9 @@ export class WrappedTransaction {
      */
     markModifiedSync(id, offset, length) {
         this.modifiedKeys.add(id);
-        const end = length ? offset + length : undefined;
+        const end = offset !== undefined && length ? offset + length : undefined;
         try {
-            this.stash(id, this.raw.getSync(id, offset, end), offset);
+            this.stash(id, this.raw.getSync(id, offset ?? 0, end), offset);
         }
         catch (e) {
             if (!(this.raw instanceof AsyncTransaction))
@@ -251,7 +251,7 @@ export class WrappedTransaction {
             const resource = tx._cached(id);
             if (!resource)
                 throw e;
-            for (const range of resource.cached(offset, end ?? offset)) {
+            for (const range of resource.cached(offset ?? 0, end ?? offset ?? 0)) {
                 this.stash(id, this.raw.getSync(id, range.start, range.end), range.start);
             }
         }

package/dist/internal/contexts.d.ts

@@ -28,6 +28,8 @@ export interface FSContext {
     pwd: string;
     /** The credentials of the context, used for access checks */
     readonly credentials: Credentials;
+    /** Permission bits cleared from the mode of newly created files and directories */
+    umask: number;
     /** A map of open file descriptors to their handles */
     readonly descriptors: Map<number, Handle>;
     /** The parent context, if any. */
@@ -66,6 +68,7 @@ export interface ContextInit {
     root?: string;
     pwd?: string;
     credentials?: CredentialsInit;
+    umask?: number;
     mounts?: Record<string, FileSystem>;
 }
 /**
@@ -75,6 +78,8 @@ export interface ContextInit {
  */
 export declare const defaultContext: FSContext;
 export declare function contextOf($: unknown): FSContext;
+/** Clears the permission bits of `mode` that are set in the context's umask. */
+export declare function applyUmask($: unknown, mode: number): number;
 /**
  * Create a blank FS Context
  * @internal

package/dist/internal/contexts.js

@@ -26,6 +26,7 @@ export const defaultContext = {
     root: '/',
     pwd: '/',
     credentials: createCredentials({ uid: 0, gid: 0 }),
+    umask: 0,
     descriptors: new Map(),
     parent: null,
     children: [],
@@ -34,6 +35,10 @@ export const defaultContext = {
 export function contextOf($) {
     return isContext($) ? $ : defaultContext;
 }
+/** Clears the permission bits of `mode` that are set in the context's umask. */
+export function applyUmask($, mode) {
+    return mode & ~(contextOf($).umask & 0o777);
+}
 // 1 is reserved for the global/default context
 let _nextId = 2;
 /**
@@ -46,13 +51,14 @@ let _nextId = 2;
  */
 export function createChildContext(parent, init = {}) {
     assertContext(parent);
-    const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials), mounts } = init;
+    const { root = parent.root, pwd = parent.pwd, credentials = structuredClone(parent.credentials), umask = parent.umask, mounts } = init;
     const ctx = {
         [kIsContext]: true,
         id: _nextId++,
         root,
         pwd,
         credentials: createCredentials(credentials),
+        umask,
         descriptors: new Map(),
         parent: parent,
         children: [],

package/dist/mixins/async.js

@@ -63,6 +63,12 @@ import { _asyncFSKeys } from './shared.js';
 function isInLoop(key, error = new Error()) {
     return new RegExp(`__patched__[^]*(__patched__|\\b${key}Sync\\b)`).test(error.stack ?? '');
 }
+/**
+ * Whether the stack has a queued replay below the innermost patched method.
+ */
+function isReplay() {
+    return /__patched__[^]*__replay__/.test(new Error().stack ?? '');
+}
 /**
  * Async() implements synchronous methods on an asynchronous file system
  *
@@ -88,10 +94,21 @@ export function Async(FS) {
             return this.sync();
         }
         _promise = Promise.resolve();
+        /** How many queued operations have not finished */
+        _pending = 0;
         /** The async methods before patching, which do not update the sync cache */
         _unpatched = {};
         _async(thunk) {
-            this._promise = this._promise.finally(() => thunk());
+            this._pending++;
+            const replay = async function __replay__() {
+                try {
+                    await thunk();
+                }
+                finally {
+                    this._pending--;
+                }
+            };
+            this._promise = this._promise.finally(replay.bind(this));
         }
         _isInitialized = false;
         /** Tracks how many updates to the sync. cache we skipped during initialization */
@@ -261,17 +278,19 @@ export function Async(FS) {
         }
         /**
          * @internal
-         * Patch all async methods to also call their synchronous counterparts unless called from themselves (either sync or async)
+         * Patch all async methods to wait for queued operations,
+         * and methods that change the file system to also call their synchronous counterparts unless called from themselves (either sync or async)
          */
         _patchAsync() {
-            const noPatch = ['read', 'readdir', 'stat', 'exists'];
-            const toPatch = _asyncFSKeys.filter(key => !noPatch.includes(key));
-            for (const key of toPatch) {
+            const reads = ['read', 'readdir', 'stat', 'exists'];
+            for (const key of _asyncFSKeys) {
                 // TS does not narrow the union based on the key
                 const originalMethod = this[key].bind(this);
                 const fn = async function __patched__(...args) {
+                    if (this._pending && !isReplay())
+                        await this._promise.catch(() => { });
                     const result = await originalMethod(...args);
-                    if (isInLoop(key))
+                    if (reads.includes(key) || isInLoop(key))
                         return result;
                     if (!this._isInitialized) {
                         this._skippedCacheUpdates++;
@@ -293,7 +312,7 @@ export function Async(FS) {
                 this._unpatched[key] = originalMethod;
                 this[key] = fn;
             }
-            debug(`Async: patched ${toPatch.length} methods`);
+            debug(`Async: patched ${_asyncFSKeys.length} methods`);
         }
     }
     return AsyncFS;

package/dist/node/promises.js

@@ -780,130 +780,33 @@ export async function readlink(path, options) {
 }
 readlink;
 export async function chown(path, uid, gid) {
-    const env_8 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_8, await open.call(this, path, 'r+'), true);
-        await handle.chown(uid, gid);
-    }
-    catch (e_8) {
-        env_8.error = e_8;
-        env_8.hasError = true;
-    }
-    finally {
-        const result_6 = __disposeResources(env_8);
-        if (result_6)
-            await result_6;
-    }
+    await _async.chown.call(this, path, uid, gid, false);
 }
 chown;
 export async function lchown(path, uid, gid) {
-    const env_9 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_9, await _async.open(this, path, {
-            flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
-            allowDirectory: true,
-        }), true);
-        await handle.chown(uid, gid);
-    }
-    catch (e_9) {
-        env_9.error = e_9;
-        env_9.hasError = true;
-    }
-    finally {
-        const result_7 = __disposeResources(env_9);
-        if (result_7)
-            await result_7;
-    }
+    await _async.chown.call(this, path, uid, gid, true);
 }
 lchown;
 export async function chmod(path, mode) {
-    const env_10 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_10, await open.call(this, path, 'r+').catch(rethrow({ syscall: 'chmod', path: normalizePath.call(this, path) })), true);
-        await handle.chmod(mode);
-    }
-    catch (e_10) {
-        env_10.error = e_10;
-        env_10.hasError = true;
-    }
-    finally {
-        const result_8 = __disposeResources(env_10);
-        if (result_8)
-            await result_8;
-    }
+    await _async.chmod.call(this, path, mode, false);
 }
 chmod;
 export async function lchmod(path, mode) {
-    const env_11 = { stack: [], error: void 0, hasError: false };
-    try {
-        mode = normalizeMode(mode);
-        const handle = __addDisposableResource(env_11, await _async.open(this, path, {
-            flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
-            allowDirectory: true,
-        }), true);
-        await handle.chmod(mode);
-    }
-    catch (e_11) {
-        env_11.error = e_11;
-        env_11.hasError = true;
-    }
-    finally {
-        const result_9 = __disposeResources(env_11);
-        if (result_9)
-            await result_9;
-    }
+    await _async.chmod.call(this, path, mode, true);
 }
 lchmod;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export async function utimes(path, atime, mtime) {
-    const env_12 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_12, await _async.open(this, path, {
-            flag: 'r+',
-            allowDirectory: true,
-        }), true);
-        await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
-    }
-    catch (e_12) {
-        env_12.error = e_12;
-        env_12.hasError = true;
-    }
-    finally {
-        const result_10 = __disposeResources(env_12);
-        if (result_10)
-            await result_10;
-    }
+    await _async.utimes.call(this, path, atime, mtime, false);
 }
 utimes;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export async function lutimes(path, atime, mtime) {
-    const env_13 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_13, await _async.open(this, path, {
-            flag: 'r+',
-            mode: 0o644,
-            preserveSymlinks: true,
-            allowDirectory: true,
-        }), true);
-        await handle.utimes(normalizeTime(atime), normalizeTime(mtime));
-    }
-    catch (e_13) {
-        env_13.error = e_13;
-        env_13.hasError = true;
-    }
-    finally {
-        const result_11 = __disposeResources(env_13);
-        if (result_11)
-            await result_11;
-    }
+    await _async.utimes.call(this, path, atime, mtime, true);
 }
 lutimes;
 export async function realpath(path, options) {

package/dist/node/sync.js

@@ -453,60 +453,33 @@ export function readlinkSync(path, options) {
 }
 readlinkSync;
 export function chownSync(path, uid, gid) {
-    const env_7 = { stack: [], error: void 0, hasError: false };
-    try {
-        const handle = __addDisposableResource(env_7, _sync.open(this, path, { flag: 'r+', mode: constants.F_OK }), false);
-        handle.chownSync(uid, gid);
-    }
-    catch (e_7) {
-        env_7.error = e_7;
-        env_7.hasError = true;
-    }
-    finally {
-        __disposeResources(env_7);
-    }
+    _sync.chown.call(this, path, uid, gid);
 }
 chownSync;
 export function lchownSync(path, uid, gid) {
-    const fd = lopenSync.call(this, path, 'r+');
-    fchownSync.call(this, fd, uid, gid);
-    closeSync.call(this, fd);
+    _sync.chown.call(this, path, uid, gid, true);
 }
 lchownSync;
 export function chmodSync(path, mode) {
-    let fd;
-    try {
-        fd = openSync.call(this, path, 'r+');
-    }
-    catch (e) {
-        throw setUVMessage(Object.assign(e, { syscall: 'chmod', path: normalizePath.call(this, path) }));
-    }
-    fchmodSync.call(this, fd, mode);
-    closeSync.call(this, fd);
+    _sync.chmod.call(this, path, mode);
 }
 chmodSync;
 export function lchmodSync(path, mode) {
-    const fd = lopenSync.call(this, path, 'r+');
-    fchmodSync.call(this, fd, mode);
-    closeSync.call(this, fd);
+    _sync.chmod.call(this, path, mode, true);
 }
 lchmodSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export function utimesSync(path, atime, mtime) {
-    const fd = openSync.call(this, path, 'r+');
-    futimesSync.call(this, fd, atime, mtime);
-    closeSync.call(this, fd);
+    _sync.utimes.call(this, path, atime, mtime);
 }
 utimesSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  */
 export function lutimesSync(path, atime, mtime) {
-    const fd = lopenSync.call(this, path, 'r+');
-    futimesSync.call(this, fd, atime, mtime);
-    closeSync.call(this, fd);
+    _sync.utimes.call(this, path, atime, mtime, true);
 }
 lutimesSync;
 export function realpathSync(path, options) {