@zenfs/core 2.0.0 → 2.1.0

package/dist/utils.js

@@ -1,5 +1,5 @@
+import { withErrno } from 'kerium';
 import { decodeUTF8, encodeUTF8 } from 'utilium';
-import { Errno, ErrnoError } from './internal/error.js';
 import { resolve } from './path.js';
 /**
  * Decodes a directory listing
@@ -31,7 +31,7 @@ export function normalizeMode(mode, def) {
     }
     if (typeof def == 'number')
         return def;
-    throw new ErrnoError(Errno.EINVAL, 'Invalid mode: ' + (mode === null || mode === void 0 ? void 0 : mode.toString()));
+    throw withErrno('EINVAL', 'Invalid mode: ' + (mode === null || mode === void 0 ? void 0 : mode.toString()));
 }
 /**
  * Normalizes a time
@@ -44,9 +44,15 @@ export function normalizeTime(time) {
         return Number(time);
     }
     catch {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid time.');
+        throw withErrno('EINVAL', 'Invalid time.');
     }
 }
+/**
+ * TypeScript is dumb, so we need to assert the type of a value sometimes.
+ * For example, after calling `normalizePath`, TS still thinks the type is `PathLike` and not `string`.
+ * @internal @hidden
+ */
+export function __assertType(value) { }
 /**
  * Normalizes a path
  * @internal
@@ -54,18 +60,16 @@ export function normalizeTime(time) {
 export function normalizePath(p, noResolve = false) {
     if (p instanceof URL) {
         if (p.protocol != 'file:')
-            throw new ErrnoError(Errno.EINVAL, 'URLs must use the file: protocol');
+            throw withErrno('EINVAL', 'URLs must use the file: protocol');
         p = p.pathname;
     }
     p = p.toString();
     if (p.startsWith('file://'))
         p = p.slice('file://'.length);
-    if (p.includes('\x00')) {
-        throw new ErrnoError(Errno.EINVAL, 'Path can not contain null character');
-    }
-    if (p.length == 0) {
-        throw new ErrnoError(Errno.EINVAL, 'Path can not be empty');
-    }
+    if (p.includes('\x00'))
+        throw withErrno('EINVAL', 'Path can not contain null character');
+    if (p.length == 0)
+        throw withErrno('EINVAL', 'Path can not be empty');
     p = p.replaceAll(/[/\\]+/g, '/');
     // Note: PWD is not resolved here, it is resolved later.
     return noResolve ? p : resolve(p);
@@ -92,10 +96,3 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
         mode: normalizeMode('mode' in options ? options === null || options === void 0 ? void 0 : options.mode : null, mode),
     };
 }
-export function stringifyUUID(uuid) {
-    const hex = uuid.toString(16).padStart(32, '0');
-    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-export function parseUUID(uuid) {
-    return BigInt(`0x${uuid.replace(/-/g, '')}`);
-}

package/dist/vfs/acl.d.ts

@@ -1,3 +1,4 @@
+import { BufferView } from 'utilium/buffer.js';
 import { type V_Context } from '../internal/contexts.js';
 import { type InodeLike } from '../internal/inode.js';
 export declare const enum Type {
@@ -16,16 +17,15 @@ export declare const enum Tag {
      */
     _None = 0
 }
-export declare class Entry {
-    tag: Tag;
-    perm: number;
-    id: number;
-    constructor(data?: Partial<Entry> | Uint8Array);
+export declare class Entry extends BufferView {
+    accessor tag: Tag;
+    accessor perm: number;
+    accessor id: number;
 }
-export declare class ACL {
-    version: number;
+export declare class ACL extends BufferView {
+    accessor version: number;
     entries: Entry[];
-    constructor(data?: Uint8Array | Entry[]);
+    constructor(...args: ConstructorParameters<typeof BufferView>);
 }
 export declare function fromMode(mode: number): ACL;
 export declare function toMode(acl: ACL): number;

package/dist/vfs/acl.js

@@ -36,18 +36,30 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
 /*
     Access Control Lists.
     At the moment, they are only intended for internal use.
     They also are not checked for permissions yet.
     Please use a namespace import for the best experience.
 */
-import { assignWithDefaults, deserialize, serialize, sizeof, struct, types as t } from 'utilium';
+import { withErrno } from 'kerium';
+import { err } from 'kerium/log';
+import { packed, sizeof, struct, types as t } from 'memium';
+import { BufferView } from 'utilium/buffer.js';
 import { defaultContext } from '../internal/contexts.js';
-import { Errno, ErrnoError } from '../internal/error.js';
 import { Attributes } from '../internal/inode.js';
-import { err } from '../internal/log.js';
-import { S_IRWXG, S_IRWXO, S_IRWXU, W_OK, X_OK, R_OK } from './constants.js';
+import { R_OK, S_IRWXG, S_IRWXO, S_IRWXU, W_OK, X_OK } from './constants.js';
 import * as xattr from './xattr.js';
 const version = 2;
 export var Type;
@@ -69,11 +81,13 @@ export var Tag;
     Tag[Tag["_None"] = 0] = "_None";
 })(Tag || (Tag = {}));
 let Entry = (() => {
+    var _Entry_tag_accessor_storage, _Entry_perm_accessor_storage, _Entry_id_accessor_storage;
     var _a, _b, _c;
-    let _classDecorators = [struct()];
+    let _classDecorators = [struct(packed)];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
+    let _classSuper = BufferView;
     let _tag_decorators;
     let _tag_initializers = [];
     let _tag_extraInitializers = [];
@@ -83,27 +97,34 @@ let Entry = (() => {
     let _id_decorators;
     let _id_initializers = [];
     let _id_extraInitializers = [];
-    var Entry = _classThis = class {
-        constructor(data) {
-            this.tag = __runInitializers(this, _tag_initializers, 0);
-            this.perm = (__runInitializers(this, _tag_extraInitializers), __runInitializers(this, _perm_initializers, 0));
-            this.id = (__runInitializers(this, _perm_extraInitializers), __runInitializers(this, _id_initializers, 0));
+    var Entry = _classThis = class extends _classSuper {
+        get tag() { return __classPrivateFieldGet(this, _Entry_tag_accessor_storage, "f"); }
+        set tag(value) { __classPrivateFieldSet(this, _Entry_tag_accessor_storage, value, "f"); }
+        get perm() { return __classPrivateFieldGet(this, _Entry_perm_accessor_storage, "f"); }
+        set perm(value) { __classPrivateFieldSet(this, _Entry_perm_accessor_storage, value, "f"); }
+        get id() { return __classPrivateFieldGet(this, _Entry_id_accessor_storage, "f"); }
+        set id(value) { __classPrivateFieldSet(this, _Entry_id_accessor_storage, value, "f"); }
+        constructor() {
+            super(...arguments);
+            _Entry_tag_accessor_storage.set(this, __runInitializers(this, _tag_initializers, void 0));
+            _Entry_perm_accessor_storage.set(this, (__runInitializers(this, _tag_extraInitializers), __runInitializers(this, _perm_initializers, void 0)));
+            _Entry_id_accessor_storage.set(this, (__runInitializers(this, _perm_extraInitializers), __runInitializers(this, _id_initializers, void 0)));
             __runInitializers(this, _id_extraInitializers);
-            if (data instanceof Uint8Array)
-                deserialize(this, data);
-            else if (typeof data == 'object')
-                assignWithDefaults(this, data);
         }
     };
+    _Entry_tag_accessor_storage = new WeakMap();
+    _Entry_perm_accessor_storage = new WeakMap();
+    _Entry_id_accessor_storage = new WeakMap();
     __setFunctionName(_classThis, "Entry");
     (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
         _tag_decorators = [(_a = t).uint16.bind(_a)];
         _perm_decorators = [(_b = t).uint16.bind(_b)];
         _id_decorators = [(_c = t).uint32.bind(_c)];
-        __esDecorate(null, null, _tag_decorators, { kind: "field", name: "tag", static: false, private: false, access: { has: obj => "tag" in obj, get: obj => obj.tag, set: (obj, value) => { obj.tag = value; } }, metadata: _metadata }, _tag_initializers, _tag_extraInitializers);
-        __esDecorate(null, null, _perm_decorators, { kind: "field", name: "perm", static: false, private: false, access: { has: obj => "perm" in obj, get: obj => obj.perm, set: (obj, value) => { obj.perm = value; } }, metadata: _metadata }, _perm_initializers, _perm_extraInitializers);
-        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(_classThis, null, _tag_decorators, { kind: "accessor", name: "tag", static: false, private: false, access: { has: obj => "tag" in obj, get: obj => obj.tag, set: (obj, value) => { obj.tag = value; } }, metadata: _metadata }, _tag_initializers, _tag_extraInitializers);
+        __esDecorate(_classThis, null, _perm_decorators, { kind: "accessor", name: "perm", static: false, private: false, access: { has: obj => "perm" in obj, get: obj => obj.perm, set: (obj, value) => { obj.perm = value; } }, metadata: _metadata }, _perm_initializers, _perm_extraInitializers);
+        __esDecorate(_classThis, null, _id_decorators, { kind: "accessor", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
         __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
         Entry = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -113,40 +134,40 @@ let Entry = (() => {
 })();
 export { Entry };
 let ACL = (() => {
+    var _ACL_version_accessor_storage;
     var _a;
-    let _classDecorators = [struct()];
+    let _classDecorators = [struct(packed)];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
+    let _classSuper = BufferView;
     let _version_decorators;
     let _version_initializers = [];
     let _version_extraInitializers = [];
-    var ACL = _classThis = class {
-        constructor(data) {
-            this.version = __runInitializers(this, _version_initializers, version);
+    var ACL = _classThis = class extends _classSuper {
+        get version() { return __classPrivateFieldGet(this, _ACL_version_accessor_storage, "f"); }
+        set version(value) { __classPrivateFieldSet(this, _ACL_version_accessor_storage, value, "f"); }
+        constructor(...args) {
+            super(...args);
+            _ACL_version_accessor_storage.set(this, __runInitializers(this, _version_initializers, void 0));
             this.entries = (__runInitializers(this, _version_extraInitializers), []);
-            if (!data)
-                return;
-            if (!(data instanceof Uint8Array)) {
-                this.entries.push(...data);
-                return;
-            }
-            deserialize(this, data);
+            this.version || (this.version = version);
             if (this.version != version)
-                throw err(new ErrnoError(Errno.EINVAL, 'Invalid ACL version'));
-            for (let offset = sizeof(ACL); offset < data.length; offset += sizeof(Entry)) {
-                if (offset + sizeof(Entry) > data.length)
-                    throw err(new ErrnoError(Errno.EIO, 'Invalid ACL data'));
-                const slice = data.subarray(offset, offset + sizeof(Entry));
-                this.entries.push(new Entry(slice));
+                throw err(withErrno('EINVAL', 'Invalid ACL version'));
+            for (let offset = sizeof(ACL); offset < this.byteLength; offset += sizeof(Entry)) {
+                if (offset + sizeof(Entry) > this.byteLength)
+                    throw err(withErrno('EIO', 'Invalid ACL data'));
+                this.entries.push(new Entry(this.buffer, offset));
             }
         }
     };
+    _ACL_version_accessor_storage = new WeakMap();
     __setFunctionName(_classThis, "ACL");
     (() => {
-        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
         _version_decorators = [(_a = t).uint32.bind(_a)];
-        __esDecorate(null, null, _version_decorators, { kind: "field", name: "version", static: false, private: false, access: { has: obj => "version" in obj, get: obj => obj.version, set: (obj, value) => { obj.version = value; } }, metadata: _metadata }, _version_initializers, _version_extraInitializers);
+        __esDecorate(_classThis, null, _version_decorators, { kind: "accessor", name: "version", static: false, private: false, access: { has: obj => "version" in obj, get: obj => obj.version, set: (obj, value) => { obj.version = value; } }, metadata: _metadata }, _version_initializers, _version_extraInitializers);
         __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
         ACL = _classThis = _classDescriptor.value;
         if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
@@ -156,11 +177,9 @@ let ACL = (() => {
 })();
 export { ACL };
 export function fromMode(mode) {
-    return new ACL([
-        new Entry({ tag: Tag.UserObj, perm: (mode & S_IRWXU) >> 6 }),
-        new Entry({ tag: Tag.GroupObj, perm: (mode & S_IRWXG) >> 3 }),
-        new Entry({ tag: Tag.Other, perm: mode & S_IRWXO }),
-    ]);
+    const acl = new ACL();
+    acl.entries.push(Object.assign(new Entry(), { tag: Tag.UserObj, perm: (mode & S_IRWXU) >> 6 }), Object.assign(new Entry(), { tag: Tag.GroupObj, perm: (mode & S_IRWXG) >> 3 }), Object.assign(new Entry(), { tag: Tag.Other, perm: mode & S_IRWXO }));
+    return acl;
 }
 export function toMode(acl) {
     let mode = 0;
@@ -191,10 +210,10 @@ export function getSync($, path) {
     return new ACL(xattr.getSync.call($, path, 'system.posix_acl_access'));
 }
 export async function set($, path, acl) {
-    await xattr.set.call($, path, 'system.posix_acl_access', serialize(acl));
+    await xattr.set.call($, path, 'system.posix_acl_access', new Uint8Array(acl.buffer, acl.byteOffset, acl.byteLength));
 }
 export function setSync($, path, acl) {
-    xattr.setSync.call($, path, 'system.posix_acl_access', serialize(acl));
+    xattr.setSync.call($, path, 'system.posix_acl_access', new Uint8Array(acl.buffer, acl.byteOffset, acl.byteLength));
 }
 export let shouldCheck = true;
 export function setChecks(enabled) {
@@ -210,10 +229,10 @@ export function check($, inode, access) {
         return true;
     (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
     const { euid, egid } = (_b = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _b !== void 0 ? _b : defaultContext.credentials;
-    const attr = inode.attributes.get('system.posix_acl_access');
-    if (!attr)
+    const data = inode.attributes.get('system.posix_acl_access');
+    if (!data)
         return true;
-    const acl = new ACL(attr.value);
+    const acl = new ACL(data);
     let mask = R_OK | W_OK | X_OK;
     let result = false;
     for (const entry of acl.entries) {

package/dist/vfs/async.d.ts

@@ -5,7 +5,7 @@ import type { Dir, Dirent } from './dir.js';
 import type { Stats } from './stats.js';
 import type { FileContents } from './types.js';
 import { Buffer } from 'buffer';
-import { ErrnoError } from '../internal/error.js';
+import { type Exception } from 'kerium';
 import { BigIntStats } from './stats.js';
 import { ReadStream, WriteStream, type ReadStreamOptions, type WriteStreamOptions } from './streams.js';
 import { FSWatcher } from './watchers.js';
@@ -267,7 +267,7 @@ export declare function statfs(this: V_Context, path: fs.PathLike, options: fs.S
     bigint: true;
 }, callback: Callback<[fs.BigIntStatsFs]>): void;
 export declare function openAsBlob(this: V_Context, path: fs.PathLike, options?: fs.OpenAsBlobOptions): Promise<Blob>;
-type GlobCallback<Args extends unknown[]> = (e: ErrnoError | null, ...args: Args) => unknown;
+type GlobCallback<Args extends unknown[]> = (e: Exception | null, ...args: Args) => unknown;
 /**
  * Retrieves the files matching the specified pattern.
  */

package/dist/vfs/async.js

@@ -1,5 +1,5 @@
 import { Buffer } from 'buffer';
-import { Errno, ErrnoError } from '../internal/error.js';
+import { UV, withErrno } from 'kerium';
 import { normalizeMode, normalizePath } from '../utils.js';
 import { R_OK } from './constants.js';
 import * as promises from './promises.js';
@@ -124,9 +124,8 @@ export function ftruncate(fd, lenOrCB, cb = nop) {
     const length = typeof lenOrCB === 'number' ? lenOrCB : 0;
     cb = typeof lenOrCB === 'function' ? lenOrCB : cb;
     const file = new promises.FileHandle(this, fd);
-    if (length < 0) {
-        throw new ErrnoError(Errno.EINVAL);
-    }
+    if (length < 0)
+        throw withErrno('EINVAL');
     file.truncate(length)
         .then(() => cb())
         .catch(cb);
@@ -166,7 +165,7 @@ export function write(fd, data, cbPosOff, cbLenEnc, cbPosEnc, cb = nop) {
             default:
                 // ...try to find the callback and get out of here!
                 cb = (typeof cbLenEnc === 'function' ? cbLenEnc : typeof cbPosEnc === 'function' ? cbPosEnc : cb);
-                cb(new ErrnoError(Errno.EINVAL, 'Invalid arguments'));
+                cb(withErrno('EINVAL'));
                 return;
         }
         buffer = Buffer.from(data);
@@ -355,9 +354,8 @@ export function watchFile(path, options, listener) {
     if (typeof options == 'function') {
         listener = options;
     }
-    if (!listener) {
-        throw new ErrnoError(Errno.EINVAL, 'No listener specified', path.toString(), 'watchFile');
-    }
+    if (!listener)
+        throw UV('EINVAL', 'watch', path.toString());
     if (statWatchers.has(normalizedPath)) {
         const entry = statWatchers.get(normalizedPath);
         if (entry) {

package/dist/vfs/dir.d.ts

@@ -1,6 +1,6 @@
 import type { Dir as _Dir, Dirent as _Dirent } from 'node:fs';
 import type { V_Context } from '../context.js';
-import { type InodeLike } from '../internal/inode.js';
+import type { InodeLike } from '../internal/inode.js';
 import type { Callback } from '../utils.js';
 export declare class Dirent implements _Dirent {
     path: string;

package/dist/vfs/dir.js

@@ -1,5 +1,5 @@
+import { withErrno } from 'kerium';
 import { isBlockDevice, isCharacterDevice, isDirectory, isFIFO, isFile, isSocket, isSymbolicLink } from '../internal/inode.js';
-import { Errno, ErrnoError } from '../internal/error.js';
 import { basename } from '../path.js';
 import { readdir } from './promises.js';
 import { readdirSync } from './sync.js';
@@ -41,9 +41,8 @@ export class Dirent {
  */
 export class Dir {
     checkClosed() {
-        if (this.closed) {
-            throw new ErrnoError(Errno.EBADF, 'Can not use closed Dir');
-        }
+        if (this.closed)
+            throw withErrno('EBADF', 'Can not use closed Dir');
     }
     constructor(path, context) {
         this.path = path;

package/dist/vfs/file.js

@@ -1,5 +1,5 @@
+import { UV, withErrno } from 'kerium';
 import { defaultContext } from '../internal/contexts.js';
-import { Errno, ErrnoError } from '../internal/error.js';
 import { InodeFlags, isBlockDevice, isCharacterDevice } from '../internal/inode.js';
 import '../polyfills.js';
 import * as c from './constants.js';
@@ -51,11 +51,11 @@ export class SyncHandle {
         this.close();
     }
     get _isSync() {
-        return !!(this.flag & c.O_SYNC || this.inode.flags & InodeFlags.Sync);
+        return !!(this.flag & c.O_SYNC || this.inode.flags & InodeFlags.Sync || this.fs.attributes.has('sync'));
     }
     sync() {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'sync');
+            throw UV('EBADF', 'sync', this.path);
         if (!this.dirty)
             return;
         if (!this.fs.attributes.has('no_write'))
@@ -70,7 +70,7 @@ export class SyncHandle {
     }
     close() {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'close');
+            throw UV('EBADF', 'close', this.path);
         this.sync();
         this.dispose();
     }
@@ -79,23 +79,28 @@ export class SyncHandle {
      */
     dispose(force) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'dispose');
+            throw UV('EBADF', 'close', this.path);
         if (this.dirty && !force)
-            throw ErrnoError.With('EBUSY', this.path, 'dispose');
+            throw UV('EBUSY', 'close', this.path);
         this.closed = true;
     }
     stat() {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'stat');
+            throw UV('EBADF', 'stat', this.path);
         return this.inode;
     }
     truncate(length) {
+        if (length < 0)
+            throw UV('EINVAL', 'truncate', this.path);
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'truncate');
+            throw UV('EBADF', 'truncate', this.path);
+        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
+            throw UV('EBADF', 'truncate', this.path);
+        if (this.fs.attributes.has('readonly'))
+            throw UV('EROFS', 'truncate', this.path);
+        if (this.inode.flags & InodeFlags.Immutable)
+            throw UV('EPERM', 'truncate', this.path);
         this.dirty = true;
-        if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR)) {
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode', this.path, 'truncate');
-        }
         this.inode.mtimeMs = Date.now();
         this.inode.size = length;
         this.inode.ctimeMs = Date.now();
@@ -113,11 +118,13 @@ export class SyncHandle {
      */
     write(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'write');
+            throw UV('EBADF', 'write', this.path);
         if (!(this.flag & c.O_WRONLY || this.flag & c.O_RDWR))
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a writeable mode');
+            throw UV('EBADF', 'write', this.path);
+        if (this.fs.attributes.has('readonly'))
+            throw UV('EROFS', 'write', this.path);
         if (this.inode.flags & InodeFlags.Immutable)
-            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'write');
+            throw UV('EPERM', 'write', this.path);
         this.dirty = true;
         const end = position + length;
         const slice = buffer.subarray(offset, offset + length);
@@ -142,10 +149,10 @@ export class SyncHandle {
      */
     read(buffer, offset = 0, length = buffer.byteLength - offset, position = this.position) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'read');
+            throw UV('EBADF', 'read', this.path);
         if (this.flag & c.O_WRONLY)
-            throw new ErrnoError(Errno.EPERM, 'File not opened with a readable mode');
-        if (!(this.inode.flags & InodeFlags.NoAtime)) {
+            throw UV('EBADF', 'read', this.path);
+        if (!(this.inode.flags & InodeFlags.NoAtime) && !this.fs.attributes.has('no_atime')) {
             this.dirty = true;
             this.inode.atimeMs = Date.now();
         }
@@ -162,7 +169,7 @@ export class SyncHandle {
     }
     chmod(mode) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'chmod');
+            throw UV('EBADF', 'chmod', this.path);
         this.dirty = true;
         this.inode.mode = (this.inode.mode & (mode > c.S_IFMT ? ~c.S_IFMT : c.S_IFMT)) | mode;
         if (this._isSync || mode > c.S_IFMT)
@@ -170,7 +177,7 @@ export class SyncHandle {
     }
     chown(uid, gid) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'chown');
+            throw UV('EBADF', 'chmod', this.path);
         this.dirty = true;
         _chown(this.inode, uid, gid);
         if (this._isSync)
@@ -181,7 +188,7 @@ export class SyncHandle {
      */
     utimes(atime, mtime) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'utimes');
+            throw UV('EBADF', 'utimes', this.path);
         this.dirty = true;
         this.inode.atimeMs = atime;
         this.inode.mtimeMs = mtime;
@@ -193,7 +200,7 @@ export class SyncHandle {
      */
     streamRead(options) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'streamRead');
+            throw UV('EBADF', 'streamRead', this.path);
         return this.fs.streamRead(this.internalPath, options);
     }
     /**
@@ -201,9 +208,11 @@ export class SyncHandle {
      */
     streamWrite(options) {
         if (this.closed)
-            throw ErrnoError.With('EBADF', this.path, 'streamWrite');
+            throw UV('EBADF', 'write', this.path);
         if (this.inode.flags & InodeFlags.Immutable)
-            throw new ErrnoError(Errno.EPERM, 'File is immutable', this.path, 'streamWrite');
+            throw UV('EPERM', 'write', this.path);
+        if (this.fs.attributes.has('readonly'))
+            throw UV('EROFS', 'write', this.path);
         return this.fs.streamWrite(this.internalPath, options);
     }
 }
@@ -226,7 +235,7 @@ export function fromFD($, fd) {
     const map = (_a = $ === null || $ === void 0 ? void 0 : $.descriptors) !== null && _a !== void 0 ? _a : defaultContext.descriptors;
     const value = map.get(fd);
     if (!value)
-        throw new ErrnoError(Errno.EBADF);
+        throw withErrno('EBADF');
     return value;
 }
 export function deleteFD($, fd) {

package/dist/vfs/flags.js

@@ -1,4 +1,4 @@
-import { Errno, ErrnoError } from '../internal/error.js';
+import { withErrno } from 'kerium';
 import * as c from './constants.js';
 export const pattern = /[rwasx]{1,2}\+?/;
 /**
@@ -8,7 +8,7 @@ export function parse(flag) {
     if (typeof flag == 'number')
         return flag;
     if (!pattern.test(flag)) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid flag string: ' + flag);
+        throw withErrno('EINVAL', 'Invalid flag string: ' + flag);
     }
     return toNumber(flag);
 }
@@ -30,7 +30,7 @@ export function toString(flag) {
  */
 export function toNumber(flag) {
     if (!flag.includes('r') && !flag.includes('w') && !flag.includes('a')) {
-        throw new ErrnoError(Errno.EINVAL, 'Invalid flag string: ' + flag);
+        throw withErrno('EINVAL', 'Invalid flag string: ' + flag);
     }
     let n = flag.includes('r') ? c.O_RDONLY : c.O_CREAT;
     if (flag.includes('w'))

package/dist/vfs/ioctl.d.ts

@@ -1,17 +1,18 @@
+import { BufferView } from 'utilium/buffer.js';
 import type { V_Context } from '../context.js';
 import { Inode } from '../internal/inode.js';
-declare class fsxattr {
+declare class fsxattr extends BufferView {
     /** xflags field value */
-    xflags: number;
+    accessor xflags: number;
     /** extsize field value */
-    extsize: number;
+    accessor extsize: number;
     /** nextents field value */
-    nextents: number;
+    accessor nextents: number;
     /** project identifier */
-    projid: number;
+    accessor projid: number;
     /** CoW extsize field value */
-    cowextsize: number;
-    protected pad: never[];
+    accessor cowextsize: number;
+    protected accessor pad: number[];
     constructor(inode?: Inode);
 }
 /**