@zenfs/core 1.8.8 → 1.9.1

package/dist/backends/store/store.js

@@ -1,4 +1,6 @@
-import { ErrnoError } from '../../error.js';
+import { Resource } from 'utilium/cache.js';
+import { ErrnoError } from '../../internal/error.js';
+import { err, warn } from '../../internal/log.js';
 import '../../polyfills.js';
 /**
  * A transaction for a store.
@@ -6,20 +8,6 @@ import '../../polyfills.js';
 export class Transaction {
     constructor(store) {
         this.store = store;
-        /**
-         * Whether the transaction was committed or aborted
-         */
-        this.done = false;
-    }
-    async [Symbol.asyncDispose]() {
-        if (this.done)
-            return;
-        await this.abort();
-    }
-    [Symbol.dispose]() {
-        if (this.done)
-            return;
-        this.abortSync();
     }
 }
 /**
@@ -27,45 +15,249 @@ export class Transaction {
  */
 export class SyncTransaction extends Transaction {
     /* eslint-disable @typescript-eslint/require-await */
-    async keys() {
-        return this.keysSync();
-    }
-    async get(id) {
-        return this.getSync(id);
+    async get(id, offset, end) {
+        return this.getSync(id, offset, end);
     }
-    async set(id, data, isMetadata) {
-        return this.setSync(id, data, isMetadata);
+    async set(id, data, offset) {
+        return this.setSync(id, data, offset);
     }
     async remove(id) {
         return this.removeSync(id);
     }
-    async commit() {
-        return this.commitSync();
+}
+/**
+ * Transaction that implements synchronous operations with a cache
+ * @implementors You *must* update the cache and wait for `store.asyncDone` in your asynchronous methods.
+ * @todo Make sure we handle abortions correctly, especially since the cache is shared between transactions.
+ */
+export class AsyncTransaction extends Transaction {
+    constructor() {
+        super(...arguments);
+        this.asyncDone = Promise.resolve();
     }
-    async abort() {
-        return this.abortSync();
+    /**
+     * Run a asynchronous operation from a sync context. Not magic and subject to (race) conditions.
+     * @internal
+     */
+    async(promise) {
+        this.asyncDone = this.asyncDone.then(() => promise);
+    }
+    /**
+     * Gets a cache resource
+     * If `info` is set and the resource doesn't exist, it will be created
+     * @internal
+     */
+    _cached(id, info) {
+        var _a;
+        var _b;
+        (_a = (_b = this.store).cache) !== null && _a !== void 0 ? _a : (_b.cache = new Map());
+        const resource = this.store.cache.get(id);
+        if (!resource)
+            return !info ? undefined : new Resource(id, info.size, {}, this.store.cache);
+        if (info)
+            resource.size = info.size;
+        return resource;
+    }
+    getSync(id, offset, end) {
+        var _a;
+        const resource = this._cached(id);
+        if (!resource)
+            return;
+        end !== null && end !== void 0 ? end : (end = resource.size);
+        const missing = resource.missing(offset, end);
+        for (const { start, end } of missing) {
+            this.async(this.get(id, start, end));
+        }
+        if (missing.length)
+            throw err(ErrnoError.With('EAGAIN', (_a = this.store._fs) === null || _a === void 0 ? void 0 : _a._path(id)));
+        const region = resource.regionAt(offset);
+        if (!region) {
+            warn('Missing cache region for ' + id);
+            return;
+        }
+        return region.data.subarray(offset - region.offset, end - region.offset);
+    }
+    setSync(id, data, offset) {
+        this.async(this.set(id, data, offset));
+    }
+    removeSync(id) {
+        var _a;
+        this.async(this.remove(id));
+        (_a = this.store.cache) === null || _a === void 0 ? void 0 : _a.delete(id);
     }
 }
 /**
- * Transaction that only supports asynchronous operations
+ * Wraps a transaction with the ability to roll-back changes, among other things.
+ * This is used by `StoreFS`
+ * @internal @hidden
  */
-export class AsyncTransaction extends Transaction {
-    keysSync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.keysSync');
+export class WrappedTransaction {
+    flag(flag) {
+        var _a, _b;
+        return (_b = (_a = this.raw.store.flags) === null || _a === void 0 ? void 0 : _a.includes(flag)) !== null && _b !== void 0 ? _b : false;
+    }
+    constructor(raw, fs) {
+        this.raw = raw;
+        this.fs = fs;
+        /**
+         * Whether the transaction was committed or aborted
+         */
+        this.done = false;
+        /**
+         * Stores data in the keys we modify prior to modifying them.
+         * Allows us to roll back commits.
+         */
+        this.originalData = new Map();
+        /**TransactionEntry
+         * List of keys modified in this transaction, if any.
+         */
+        this.modifiedKeys = new Set();
+    }
+    keys() {
+        return this.raw.keys();
     }
-    getSync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.getSync');
+    async get(id, offset = 0, end) {
+        const data = await this.raw.get(id, offset, end);
+        this.stash(id);
+        return data;
     }
-    setSync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.setSync');
+    getSync(id, offset = 0, end) {
+        const data = this.raw.getSync(id, offset, end);
+        this.stash(id);
+        return data;
     }
-    removeSync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.removeSync');
+    async set(id, data, offset = 0) {
+        await this.markModified(id, offset, data.byteLength);
+        await this.raw.set(id, data, offset);
+    }
+    setSync(id, data, offset = 0) {
+        this.markModifiedSync(id, offset, data.byteLength);
+        this.raw.setSync(id, data, offset);
+    }
+    async remove(id) {
+        await this.markModified(id, 0, undefined);
+        await this.raw.remove(id);
+    }
+    removeSync(id) {
+        this.markModifiedSync(id, 0, undefined);
+        this.raw.removeSync(id);
+    }
+    commit() {
+        this.done = true;
+        return Promise.resolve();
     }
     commitSync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.commitSync');
+        this.done = true;
+    }
+    async abort() {
+        if (this.done)
+            return;
+        // Rollback old values.
+        for (const [id, entries] of this.originalData) {
+            if (!this.modifiedKeys.has(id))
+                continue;
+            // Key didn't exist.
+            if (entries.some(ent => !ent.data)) {
+                await this.raw.remove(id);
+                this.fs._remove(id);
+                continue;
+            }
+            for (const entry of entries.reverse()) {
+                await this.raw.set(id, entry.data, entry.offset);
+            }
+        }
+        this.done = true;
     }
     abortSync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'AsyncTransaction.abortSync');
+        if (this.done)
+            return;
+        // Rollback old values.
+        for (const [id, entries] of this.originalData) {
+            if (!this.modifiedKeys.has(id))
+                continue;
+            // Key didn't exist.
+            if (entries.some(ent => !ent.data)) {
+                this.raw.removeSync(id);
+                this.fs._remove(id);
+                continue;
+            }
+            for (const entry of entries.reverse()) {
+                this.raw.setSync(id, entry.data, entry.offset);
+            }
+        }
+        this.done = true;
+    }
+    async [Symbol.asyncDispose]() {
+        if (this.done)
+            return;
+        await this.abort();
+    }
+    [Symbol.dispose]() {
+        if (this.done)
+            return;
+        this.abortSync();
+    }
+    /**
+     * Stashes given key value pair into `originalData` if it doesn't already exist.
+     * Allows us to stash values the program is requesting anyway to
+     * prevent needless `get` requests if the program modifies the data later
+     * on during the transaction.
+     */
+    stash(id, data, offset = 0) {
+        if (!this.originalData.has(id))
+            this.originalData.set(id, []);
+        this.originalData.get(id).push({ data, offset });
+    }
+    /**
+     * Marks an id as modified, and stashes its value if it has not been stashed already.
+     */
+    async markModified(id, offset, length) {
+        this.modifiedKeys.add(id);
+        const end = length ? offset + length : undefined;
+        try {
+            this.stash(id, await this.raw.get(id, offset, end), offset);
+        }
+        catch (e) {
+            if (!(this.raw instanceof AsyncTransaction))
+                throw e;
+            /*
+                async transaction has a quirk:
+                setting the buffer to a larger size doesn't work correctly due to cache ranges
+                so, we cache the existing sub-ranges
+            */
+            const tx = this.raw;
+            const resource = tx._cached(id);
+            if (!resource)
+                throw e;
+            for (const range of resource.cached(offset, end !== null && end !== void 0 ? end : offset)) {
+                this.stash(id, await this.raw.get(id, range.start, range.end), range.start);
+            }
+        }
+    }
+    /**
+     * Marks an id as modified, and stashes its value if it has not been stashed already.
+     */
+    markModifiedSync(id, offset, length) {
+        this.modifiedKeys.add(id);
+        const end = length ? offset + length : undefined;
+        try {
+            this.stash(id, this.raw.getSync(id, offset, end), offset);
+        }
+        catch (e) {
+            if (!(this.raw instanceof AsyncTransaction))
+                throw e;
+            /*
+                async transaction has a quirk:
+                setting the buffer to a larger size doesn't work correctly due to cache ranges
+                so, we cache the existing sub-ranges
+            */
+            const tx = this.raw;
+            const resource = tx._cached(id);
+            if (!resource)
+                throw e;
+            for (const range of resource.cached(offset, end !== null && end !== void 0 ? end : offset)) {
+                this.stash(id, this.raw.getSync(id, range.start, range.end), range.start);
+            }
+        }
     }
 }

package/dist/config.d.ts

@@ -1,5 +1,6 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
-import type { Device, DeviceDriver } from './devices.js';
+import type { Device, DeviceDriver } from './internal/devices.js';
+import type { LogConfiguration } from './internal/log.js';
 /**
  * Configuration for a specific mount point
  */
@@ -37,7 +38,6 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
     gid: number;
     /**
      * Whether to automatically add normal Linux devices
-     * @experimental
      * @default false
      */
     addDevices: boolean;
@@ -60,7 +60,6 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * If true, disables *all* permissions checking.
      *
      * This can increase performance.
-     * @experimental
      * @default false
      */
     disableAccessChecks: boolean;
@@ -81,6 +80,11 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     onlySyncOnClose: boolean;
+    /**
+     * Configurations options for the log.
+     * @experimental
+     */
+    log: LogConfiguration;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -1,8 +1,9 @@
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
-import { useCredentials } from './credentials.js';
-import { DeviceFS } from './devices.js';
-import { Errno, ErrnoError } from './error.js';
-import { FileSystem } from './filesystem.js';
+import { useCredentials } from './internal/credentials.js';
+import { DeviceFS } from './internal/devices.js';
+import { Errno, ErrnoError } from './internal/error.js';
+import { FileSystem } from './internal/filesystem.js';
+import { configure as configureLog, crit, err, info } from './internal/log.js';
 import * as cache from './vfs/cache.js';
 import { config } from './vfs/config.js';
 import * as fs from './vfs/index.js';
@@ -16,10 +17,10 @@ function isMountConfig(arg) {
  */
 export async function resolveMountConfig(configuration, _depth = 0) {
     if (typeof configuration !== 'object' || configuration == null) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid options on mount configuration');
+        throw err(new ErrnoError(Errno.EINVAL, 'Invalid options on mount configuration'));
     }
     if (!isMountConfig(configuration)) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid mount configuration');
+        throw err(new ErrnoError(Errno.EINVAL, 'Invalid mount configuration'));
     }
     if (configuration instanceof FileSystem) {
         await configuration.ready();
@@ -29,24 +30,24 @@ export async function resolveMountConfig(configuration, _depth = 0) {
         configuration = { backend: configuration };
     }
     for (const [key, value] of Object.entries(configuration)) {
-        if (key == 'backend') {
+        if (key == 'backend')
             continue;
-        }
-        if (!isMountConfig(value)) {
+        if (!isMountConfig(value))
             continue;
-        }
+        info('Resolving nested mount configuration: ' + key);
         if (_depth > 10) {
-            throw new ErrnoError(Errno.EINVAL, 'Invalid configuration, too deep and possibly infinite');
+            throw err(new ErrnoError(Errno.EINVAL, 'Invalid configuration, too deep and possibly infinite'));
         }
         configuration[key] = await resolveMountConfig(value, ++_depth);
     }
     const { backend } = configuration;
     if (typeof backend.isAvailable == 'function' && !(await backend.isAvailable())) {
-        throw new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend.name);
+        throw err(new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend.name));
     }
     await checkOptions(backend, configuration);
     const mount = (await backend.create(configuration));
-    mount._disableSync = configuration.disableAsyncCache || false;
+    if (configuration.disableAsyncCache)
+        mount.attributes.set('no_async');
     await mount.ready();
     return mount;
 }
@@ -84,7 +85,7 @@ async function mount(path, mount) {
 export function addDevice(driver, options) {
     const devfs = mounts.get('/dev');
     if (!(devfs instanceof DeviceFS))
-        throw new ErrnoError(Errno.ENOTSUP, '/dev does not exist or is not a device file system');
+        throw crit(new ErrnoError(Errno.ENOTSUP, '/dev does not exist or is not a device file system'));
     return devfs._createDevice(driver, options);
 }
 /**
@@ -101,6 +102,8 @@ export async function configure(configuration) {
     config.checkAccess = !configuration.disableAccessChecks;
     config.updateOnRead = !configuration.disableUpdateOnRead;
     config.syncImmediately = !configuration.onlySyncOnClose;
+    if (configuration.log)
+        configureLog(configuration.log);
     if (configuration.mounts) {
         // sort to make sure any root replacement is done first
         for (const [_point, mountConfig] of Object.entries(configuration.mounts).sort(([a], [b]) => (a.length > b.length ? 1 : -1))) {

package/dist/context.d.ts

@@ -1,4 +1,4 @@
-import type { CredentialInit, Credentials } from './credentials.js';
+import type { CredentialInit, Credentials } from './internal/credentials.js';
 import * as fs from './vfs/index.js';
 /**
  * Represents some context used for FS operations

package/dist/context.js

@@ -1,4 +1,4 @@
-import { createCredentials, credentials as defaultCredentials } from './credentials.js';
+import { createCredentials, credentials as defaultCredentials } from './internal/credentials.js';
 import * as fs from './vfs/index.js';
 /**
  * Binds a this value for all of the functions in an object (not recursive)

package/dist/index.d.ts

@@ -1,11 +1,7 @@
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';
-export * from './credentials.js';
-export * from './devices.js';
-export * from './error.js';
-export * from './file.js';
-export * from './filesystem.js';
+export * from './internal/index.js';
 export * from './mixins/index.js';
 export * from './stats.js';
 export * from './utils.js';

package/dist/index.js

@@ -1,11 +1,7 @@
 export * from './backends/index.js';
 export * from './config.js';
 export * from './context.js';
-export * from './credentials.js';
-export * from './devices.js';
-export * from './error.js';
-export * from './file.js';
-export * from './filesystem.js';
+export * from './internal/index.js';
 export * from './mixins/index.js';
 export * from './stats.js';
 export * from './utils.js';

package/dist/{devices.d.ts → internal/devices.d.ts}

@@ -1,10 +1,10 @@
-import { Inode } from './backends/index.js';
-import { InMemoryStore } from './backends/memory.js';
-import { StoreFS } from './backends/store/fs.js';
+import { InMemoryStore } from '../backends/memory.js';
+import { StoreFS } from '../backends/store/fs.js';
+import { Stats } from '../stats.js';
 import type { FileReadResult } from './file.js';
 import { File } from './file.js';
 import type { CreationOptions } from './filesystem.js';
-import { Stats } from './stats.js';
+import { Inode } from './inode.js';
 /**
  * A device
  * @todo Maybe add some other device information, like a UUID?

package/dist/{devices.js → internal/devices.js}

@@ -53,15 +53,17 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
-import { Inode } from './backends/index.js';
-import { InMemoryStore } from './backends/memory.js';
-import { StoreFS } from './backends/store/fs.js';
+import { canary } from 'utilium';
+import { InMemoryStore } from '../backends/memory.js';
+import { StoreFS } from '../backends/store/fs.js';
+import { Stats } from '../stats.js';
+import { decodeUTF8 } from '../utils.js';
+import { S_IFBLK, S_IFCHR } from '../vfs/constants.js';
+import { basename, dirname } from '../vfs/path.js';
 import { Errno, ErrnoError } from './error.js';
 import { File } from './file.js';
-import { Stats } from './stats.js';
-import { canary, decodeUTF8 } from './utils.js';
-import { S_IFBLK, S_IFCHR } from './vfs/constants.js';
-import { basename, dirname } from './vfs/path.js';
+import { Inode } from './inode.js';
+import { alert, debug, err, info, log_deprecated } from './log.js';
 /**
  * The base class for device files
  * This class only does some simple things:
@@ -162,18 +164,19 @@ export class DeviceFile extends File {
  * A temporary file system that manages and interfaces with devices
  */
 export class DeviceFS extends StoreFS {
+    /* node:coverage disable */
     /**
      * Creates a new device at `path` relative to the `DeviceFS` root.
      * @deprecated
      */
-    /* node:coverage disable */
     createDevice(path, driver, options = {}) {
         var _a;
+        log_deprecated('DeviceFS#createDevice');
         if (this.existsSync(path)) {
             throw ErrnoError.With('EEXIST', path, 'mknod');
         }
         let ino = 1;
-        const silence = canary(path, 'mknod');
+        const silence = canary(ErrnoError.With('EDEADLK', path, 'mknod'));
         while (this.store.has(ino))
             ino++;
         silence();
@@ -191,7 +194,7 @@ export class DeviceFS extends StoreFS {
     /* node:coverage enable */
     devicesWithDriver(driver, forceIdentity) {
         if (forceIdentity && typeof driver == 'string') {
-            throw new ErrnoError(Errno.EINVAL, 'Can not fetch devices using only a driver name');
+            throw err(new ErrnoError(Errno.EINVAL, 'Can not fetch devices using only a driver name'), { fs: this });
         }
         const devs = [];
         for (const device of this.devices.values()) {
@@ -220,10 +223,10 @@ export class DeviceFS extends StoreFS {
             ...(_a = driver.init) === null || _a === void 0 ? void 0 : _a.call(driver, ino, options),
         };
         const path = '/' + (dev.name || driver.name) + (driver.singleton ? '' : this.devicesWithDriver(driver).length);
-        if (this.existsSync(path)) {
+        if (this.existsSync(path))
             throw ErrnoError.With('EEXIST', path, 'mknod');
-        }
         this.devices.set(path, dev);
+        info('Initialized device: ' + this._mountPoint + path);
         return dev;
     }
     /**
@@ -235,6 +238,7 @@ export class DeviceFS extends StoreFS {
         this._createDevice(fullDevice);
         this._createDevice(randomDevice);
         this._createDevice(consoleDevice);
+        debug('Added default devices.');
     }
     constructor() {
         super(new InMemoryStore('devfs'));
@@ -386,13 +390,13 @@ export class DeviceFS extends StoreFS {
     }
     async sync(path, data, stats) {
         if (this.devices.has(path)) {
-            throw new ErrnoError(Errno.EINVAL, 'Attempted to sync a device incorrectly (bug)', path, 'sync');
+            throw alert(new ErrnoError(Errno.EINVAL, 'Attempted to sync a device incorrectly (bug)', path, 'sync'), { fs: this });
         }
         return super.sync(path, data, stats);
     }
     syncSync(path, data, stats) {
         if (this.devices.has(path)) {
-            throw new ErrnoError(Errno.EINVAL, 'Attempted to sync a device incorrectly (bug)', path, 'sync');
+            throw alert(new ErrnoError(Errno.EINVAL, 'Attempted to sync a device incorrectly (bug)', path, 'sync'), { fs: this });
         }
         return super.syncSync(path, data, stats);
     }

package/dist/{file.d.ts → internal/file.d.ts}

@@ -1,6 +1,6 @@
+import { Stats, type StatsLike } from '../stats.js';
 import type { FileSystem } from './filesystem.js';
-import './polyfills.js';
-import { Stats, type StatsLike } from './stats.js';
+import '../polyfills.js';
 export declare function parseFlag(flag: string | number): string;
 export declare function flagToString(flag: number): string;
 export declare function flagToNumber(flag: string): number;
@@ -220,6 +220,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File<FS> {
  * @deprecated
  */
 export declare class NoSyncFile<T extends FileSystem> extends PreloadFile<T> {
+    constructor(...args: ConstructorParameters<typeof PreloadFile<T>>);
     sync(): Promise<void>;
     syncSync(): void;
     close(): Promise<void>;

package/dist/{file.js → internal/file.js}

@@ -1,9 +1,10 @@
+import { extendBuffer } from 'utilium/buffer.js';
+import { _chown, Stats } from '../stats.js';
+import { config } from '../vfs/config.js';
+import * as c from '../vfs/constants.js';
 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';
+import { log_deprecated } from './log.js';
+import '../polyfills.js';
 const maxByteLength = 0x100000; // 1 MiB
 const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export function parseFlag(flag) {
@@ -148,7 +149,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 }))) {
+    _buffer = new Uint8Array(new ArrayBuffer(0, fs.attributes.has('no_buffer_resize') ? {} : { maxByteLength }))) {
         super(fs, path);
         this.flag = flag;
         this.stats = stats;
@@ -208,7 +209,7 @@ export class PreloadFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'sync');
         if (!this.dirty)
             return;
-        if (!this.fs.metadata().readonly)
+        if (!this.fs.attributes.has('no_write'))
             await this.fs.sync(this.path, this._buffer, this.stats);
         this.dirty = false;
     }
@@ -217,7 +218,7 @@ export class PreloadFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'sync');
         if (!this.dirty)
             return;
-        if (!this.fs.metadata().readonly)
+        if (!this.fs.attributes.has('no_write'))
             this.fs.syncSync(this.path, this._buffer, this.stats);
         this.dirty = false;
     }
@@ -291,7 +292,7 @@ export class PreloadFile extends File {
         this.dirty = true;
         const end = position + length;
         const slice = buffer.subarray(offset, offset + length);
-        this._buffer = growBuffer(this._buffer, end);
+        this._buffer = extendBuffer(this._buffer, end);
         if (end > this.stats.size)
             this.stats.size = end;
         this._buffer.set(slice, position);
@@ -433,12 +434,16 @@ export class PreloadFile extends File {
             this.syncSync();
     }
 }
+/* node:coverage disable */
 /**
  * For the file systems which do not sync to anything.
  * @deprecated
  */
-/* node:coverage disable */
 export class NoSyncFile extends PreloadFile {
+    constructor(...args) {
+        log_deprecated('NoSyncFile');
+        super(...args);
+    }
     sync() {
         return Promise.resolve();
     }
@@ -495,7 +500,7 @@ export class LazyFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'sync');
         if (!this.dirty)
             return;
-        if (!this.fs.metadata().readonly)
+        if (!this.fs.attributes.has('no_write'))
             await this.fs.sync(this.path, undefined, this.stats);
         this.dirty = false;
     }
@@ -504,7 +509,7 @@ export class LazyFile extends File {
             throw ErrnoError.With('EBADF', this.path, 'sync');
         if (!this.dirty)
             return;
-        if (!this.fs.metadata().readonly)
+        if (!this.fs.attributes.has('no_write'))
             this.fs.syncSync(this.path, undefined, this.stats);
         this.dirty = false;
     }