@zenfs/dom 1.1.5 → 1.1.7

package/dist/IndexedDB.d.ts

@@ -1,24 +1,32 @@
 import type { SharedConfig, Store } from '@zenfs/core';
-import { AsyncTransaction, StoreFS } from '@zenfs/core';
-import type * as cache from 'utilium/cache.js';
+import { StoreFS, Transaction } from '@zenfs/core';
 /**
  * @internal @hidden
  */
-export declare class IndexedDBTransaction extends AsyncTransaction<IndexedDBStore> {
+export declare class IndexedDBTransaction extends Transaction<IndexedDBStore> {
     tx: IDBTransaction;
     store: IndexedDBStore;
     private _idb;
+    protected asyncDone: Promise<unknown>;
+    /**
+     * Run a asynchronous operation from a sync context. Not magic and subject to (race) conditions.
+     * @internal
+     */
+    protected async(promise: Promise<unknown>): void;
     constructor(tx: IDBTransaction, store: IndexedDBStore);
     keys(): Promise<Iterable<number>>;
     get(id: number): Promise<Uint8Array | undefined>;
+    getSync(id: number, offset: number, end?: number): Uint8Array | undefined;
     set(id: number, data: Uint8Array): Promise<void>;
+    setSync(id: number, data: Uint8Array): void;
     remove(id: number): Promise<void>;
+    removeSync(id: number): void;
     commit(): Promise<void>;
     abort(): Promise<void>;
 }
 export declare class IndexedDBStore implements Store {
     protected db: IDBDatabase;
-    cache: Map<number, cache.Resource<number>>;
+    cache: Map<number, Uint8Array<ArrayBufferLike>>;
     constructor(db: IDBDatabase);
     sync(): Promise<void>;
     get name(): string;
@@ -52,7 +60,7 @@ declare const _IndexedDB: {
             readonly required: false;
         };
     };
-    readonly isAvailable: (idbFactory?: IDBFactory) => Promise<boolean>;
+    readonly isAvailable: ({ idbFactory }: IndexedDBOptions) => Promise<boolean>;
     readonly create: (options: IndexedDBOptions & Partial<SharedConfig>) => Promise<StoreFS<IndexedDBStore>>;
 };
 type _IndexedDB = typeof _IndexedDB;

package/dist/IndexedDB.js

@@ -1,4 +1,5 @@
-import { AsyncTransaction, StoreFS, log } from '@zenfs/core';
+import { StoreFS, Transaction } from '@zenfs/core';
+import { log } from 'kerium';
 import { convertException } from './utils.js';
 function wrap(request) {
     return new Promise((resolve, reject) => {
@@ -12,31 +13,54 @@ function wrap(request) {
 /**
  * @internal @hidden
  */
-export class IndexedDBTransaction extends AsyncTransaction {
+export class IndexedDBTransaction extends Transaction {
+    /**
+     * Run a asynchronous operation from a sync context. Not magic and subject to (race) conditions.
+     * @internal
+     */
+    async(promise) {
+        this.asyncDone = this.asyncDone.then(() => promise);
+    }
     constructor(tx, store) {
         super(store);
         this.tx = tx;
         this.store = store;
+        this.asyncDone = Promise.resolve();
         this._idb = tx.objectStore(store.name);
     }
     async keys() {
         return (await wrap(this._idb.getAllKeys())).filter(k => typeof k == 'string').map(k => Number(k));
     }
     async get(id) {
-        const data = await wrap(this._idb.get(id.toString()));
+        const data = await wrap(this._idb.get(id));
         if (data)
-            this._cached(id, { size: data.byteLength }).add(data, 0);
+            this.store.cache.set(id, new Uint8Array(data));
         return data;
     }
+    getSync(id, offset, end) {
+        if (!this.store.cache.has(id))
+            return;
+        const data = new Uint8Array(this.store.cache.get(id));
+        end ?? (end = data.byteLength);
+        return data.subarray(offset, end);
+    }
     async set(id, data) {
-        this._cached(id, { size: data.byteLength }).add(data, 0);
-        await wrap(this._idb.put(data, id.toString()));
+        this.store.cache.set(id, new Uint8Array(data));
+        await wrap(this._idb.put(data, id));
+    }
+    setSync(id, data) {
+        this.async(this.set(id, data));
     }
     remove(id) {
         this.store.cache.delete(id);
-        return wrap(this._idb.delete(id.toString()));
+        return wrap(this._idb.delete(id));
+    }
+    removeSync(id) {
+        this.store.cache.delete(id);
+        this.async(this.remove(id));
     }
     async commit() {
+        await this.asyncDone;
         const { promise, resolve, reject } = Promise.withResolvers();
         this.tx.oncomplete = () => resolve();
         this.tx.onerror = () => reject(convertException(this.tx.error));
@@ -44,6 +68,7 @@ export class IndexedDBTransaction extends AsyncTransaction {
         return promise;
     }
     async abort() {
+        await this.asyncDone;
         const { promise, resolve, reject } = Promise.withResolvers();
         this.tx.onabort = () => resolve();
         this.tx.onerror = () => reject(convertException(this.tx.error));
@@ -89,11 +114,10 @@ const _IndexedDB = {
         storeName: { type: 'string', required: false },
         idbFactory: { type: 'object', required: false },
     },
-    async isAvailable(idbFactory = globalThis.indexedDB) {
+    async isAvailable({ idbFactory = globalThis.indexedDB }) {
         try {
-            if (!(idbFactory instanceof IDBFactory)) {
+            if (!(idbFactory instanceof IDBFactory))
                 return false;
-            }
             const req = idbFactory.open('__zenfs_test');
             await wrap(req);
             return true;
@@ -102,7 +126,7 @@ const _IndexedDB = {
             return false;
         }
         finally {
-            idbFactory.deleteDatabase('__zenfs_test');
+            idbFactory?.deleteDatabase('__zenfs_test');
         }
     },
     async create(options) {

package/dist/access.d.ts

@@ -1,4 +1,4 @@
-import type { CreationOptions, FileSystem } from '@zenfs/core';
+import type { CreationOptions, FileSystem, InodeLike } from '@zenfs/core';
 import { IndexFS } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
@@ -24,7 +24,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
     _sync: FileSystem;
     constructor(handle: FileSystemDirectoryHandle);
     remove(path: string): Promise<void>;
-    protected removeSync(path: string): void;
+    protected removeSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
     /**
@@ -32,8 +32,8 @@ export declare class WebAccessFS extends WebAccessFS_base {
      * @deprecated @internal @hidden
      */
     writeFile(path: string, data: Uint8Array): Promise<void>;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string, syscall?: string): T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle;
+    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
+    protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string): T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle;
 }
 declare const _WebAccess: {
     readonly name: "WebAccess";

package/dist/access.js

@@ -1,6 +1,7 @@
-import { Async, constants, Errno, ErrnoError, IndexFS, InMemory, Inode, log } from '@zenfs/core';
+import { Async, constants, IndexFS, InMemory, Inode } from '@zenfs/core';
+import { basename, dirname, join } from '@zenfs/core/path.js';
 import { S_IFDIR, S_IFMT } from '@zenfs/core/vfs/constants.js';
-import { basename, dirname, join } from '@zenfs/core/vfs/path.js';
+import { log, withErrno } from 'kerium';
 import { _throw } from 'utilium';
 import { convertException } from './utils.js';
 function isResizable(buffer) {
@@ -49,7 +50,7 @@ export class WebAccessFS extends Async(IndexFS) {
                 continue;
             }
             if (!isKind(handle, 'directory'))
-                throw new ErrnoError(Errno.EIO, 'Invalid handle', path);
+                throw withErrno('EIO', 'Invalid handle');
             this.index.set(path, new Inode({ mode: 0o777 | constants.S_IFDIR, size: 0 }));
         }
     }
@@ -59,26 +60,25 @@ export class WebAccessFS extends Async(IndexFS) {
         /**
          * @hidden
          */
-        this._sync = InMemory.create({ name: 'accessfs-cache' });
-        this.attributes.set('no_buffer_resize');
-        this.attributes.set('setid');
+        this._sync = InMemory.create({ label: 'accessfs-cache' });
+        this.attributes.set('no_buffer_resize', true);
         this._handles.set('/', handle);
     }
     async remove(path) {
         const handle = this.get('directory', dirname(path));
         await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path)));
     }
-    removeSync(path) {
-        throw log.crit(ErrnoError.With('ENOSYS', path));
+    removeSync() {
+        throw log.crit(withErrno('ENOSYS'));
     }
     async read(path, buffer, offset, end) {
         if (end <= offset)
             return;
-        const handle = this.get('file', path, 'write');
+        const handle = this.get('file', path);
         const file = await handle.getFile();
         const data = await file.arrayBuffer();
         if (data.byteLength < end - offset)
-            throw ErrnoError.With('ENODATA', path, 'read');
+            throw withErrno('ENODATA');
         buffer.set(new Uint8Array(data, offset, end - offset));
     }
     async write(path, buffer, offset) {
@@ -89,21 +89,21 @@ export class WebAccessFS extends Async(IndexFS) {
         }
         const inode = this.index.get(path);
         if (!inode)
-            throw ErrnoError.With('ENOENT', path, 'write');
+            throw withErrno('ENOENT');
         const isDir = (inode.mode & S_IFMT) == S_IFDIR;
         let handle;
         try {
-            handle = this.get(isDir ? 'directory' : 'file', path, 'write');
+            handle = this.get(isDir ? 'directory' : 'file', path);
         }
         catch {
-            const parent = this.get('directory', dirname(path), 'write');
+            const parent = this.get('directory', dirname(path));
             handle = await parent[isDir ? 'getDirectoryHandle' : 'getFileHandle'](basename(path), { create: true }).catch((ex) => _throw(convertException(ex, path)));
             this._handles.set(path, handle);
         }
         if (isDir)
             return;
         if (isKind(handle, 'directory')) {
-            log.crit(new ErrnoError(Errno.EIO, 'Mismatch in entry kind on write', path, 'write'));
+            log.crit(withErrno('EIO', 'Mismatch in entry kind on write'));
             return;
         }
         const writable = await handle.createWritable();
@@ -126,18 +126,19 @@ export class WebAccessFS extends Async(IndexFS) {
     async writeFile(path, data) {
         return this.write(path, data, 0);
     }
-    async mkdir(path, mode, options) {
-        await super.mkdir(path, mode, options);
-        const handle = this.get('directory', dirname(path), 'mkdir');
+    async mkdir(path, options) {
+        const inode = await super.mkdir(path, options);
+        const handle = this.get('directory', dirname(path));
         const dir = await handle.getDirectoryHandle(basename(path), { create: true }).catch((ex) => _throw(convertException(ex, path)));
         this._handles.set(path, dir);
+        return inode;
     }
-    get(kind = null, path, syscall) {
+    get(kind = null, path) {
         const handle = this._handles.get(path);
         if (!handle)
-            throw ErrnoError.With('ENODATA', path, syscall);
+            throw withErrno('ENODATA');
         if (kind && !isKind(handle, kind))
-            throw ErrnoError.With(kind == 'directory' ? 'ENOTDIR' : 'EISDIR', path, syscall);
+            throw withErrno(kind == 'directory' ? 'ENOTDIR' : 'EISDIR');
         return handle;
     }
 }

package/dist/devices/dsp.js

@@ -44,10 +44,10 @@ export async function dsp(options = {}) {
         init(ino, options) {
             return { data: dsp, major: 14, minor: 3 };
         },
-        readD() {
+        read() {
             return;
         },
-        writeD(device, buffer, offset) {
+        write(device, buffer, offset) {
             device.data.port.postMessage(buffer.buffer);
         },
     };

package/dist/devices/framebuffer.js

@@ -1,4 +1,4 @@
-import { Errno, ErrnoError } from '@zenfs/core';
+import { withErrno } from 'kerium';
 let framebufferN = 0;
 /**
  * A frame buffer
@@ -17,7 +17,7 @@ export const framebuffer = {
         }
         const context = canvas.getContext('2d');
         if (!context) {
-            throw new ErrnoError(Errno.EIO, 'Could not get context from canvas whilst initializing frame buffer.');
+            throw withErrno('EIO', 'Could not get context from canvas whilst initializing frame buffer.');
         }
         const image = new ImageData(canvas.width, canvas.height);
         return {
@@ -27,8 +27,8 @@ export const framebuffer = {
             name: 'fb',
         };
     },
-    readD() { },
-    writeD({ data: { image, context } }, buffer, offset) {
+    read() { },
+    write({ data: { image, context } }, buffer, offset) {
         image.data.set(buffer, offset);
         context.putImageData(image, 0, 0);
         return buffer.byteLength;

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import type { SyncMapStore, Store } from '@zenfs/core';
+import type { Store, SyncMapStore } from '@zenfs/core';
 import { StoreFS, SyncMapTransaction } from '@zenfs/core';
 /**
  * A synchronous key-value store backed by Storage.
@@ -39,7 +39,7 @@ declare const _WebStorage: {
     /**
      * @todo Consider replacing `instanceof` with a duck-typing check?
      */
-    readonly isAvailable: (storage?: Storage) => boolean;
+    readonly isAvailable: (config?: WebStorageOptions) => boolean;
     readonly create: ({ storage }: WebStorageOptions) => StoreFS<WebStorageStore>;
 };
 type _WebStorage = typeof _WebStorage;

package/dist/storage.js

@@ -1,4 +1,6 @@
-import { ErrnoError, Errno, StoreFS, decodeRaw, encodeRaw, SyncMapTransaction } from '@zenfs/core';
+import { withErrno } from 'kerium';
+import { StoreFS, SyncMapTransaction } from '@zenfs/core';
+import { decodeASCII, encodeASCII } from 'utilium';
 /**
  * A synchronous key-value store backed by Storage.
  */
@@ -28,14 +30,14 @@ export class WebStorageStore {
         if (typeof data != 'string') {
             return;
         }
-        return encodeRaw(data);
+        return encodeASCII(data);
     }
     set(key, data) {
         try {
-            this.storage.setItem(key.toString(), decodeRaw(data));
+            this.storage.setItem(key.toString(), decodeASCII(data));
         }
         catch {
-            throw new ErrnoError(Errno.ENOSPC, 'Storage is full.');
+            throw withErrno('ENOSPC');
         }
     }
     delete(key) {
@@ -43,7 +45,7 @@ export class WebStorageStore {
             this.storage.removeItem(key.toString());
         }
         catch (e) {
-            throw new ErrnoError(Errno.EIO, 'Unable to delete key ' + key + ': ' + e);
+            throw withErrno('EIO', `Unable to delete '${key}': ${e}`);
         }
     }
 }
@@ -58,8 +60,8 @@ const _WebStorage = {
     /**
      * @todo Consider replacing `instanceof` with a duck-typing check?
      */
-    isAvailable(storage = globalThis.localStorage) {
-        return storage instanceof globalThis.Storage;
+    isAvailable(config) {
+        return (config?.storage ?? globalThis.localStorage) instanceof globalThis.Storage;
     },
     create({ storage = globalThis.localStorage }) {
         return new StoreFS(new WebStorageStore(storage));

package/dist/utils.d.ts

@@ -1,8 +1,8 @@
-import { ErrnoError } from '@zenfs/core';
+import { Exception } from 'kerium';
 /** @internal */
-export type ConvertException = ErrnoError | DOMException | Error;
+export type ConvertException = Exception | DOMException | Error;
 /**
  * Handles converting errors, then rethrowing them
  * @internal
  */
-export declare function convertException(ex: ConvertException, path?: string, syscall?: string): ErrnoError;
+export declare function convertException(ex: ConvertException, path?: string): Exception;

package/dist/utils.js

@@ -1,4 +1,4 @@
-import { ErrnoError, Errno } from '@zenfs/core';
+import { Exception, Errno } from 'kerium';
 /**
  * Converts a DOMException into an Errno
  * @see https://developer.mozilla.org/Web/API/DOMException
@@ -57,12 +57,13 @@ function errnoForDOMException(ex) {
  * Handles converting errors, then rethrowing them
  * @internal
  */
-export function convertException(ex, path, syscall) {
-    if (ex instanceof ErrnoError)
+export function convertException(ex, path) {
+    if (ex instanceof Exception)
         return ex;
     const code = ex instanceof DOMException ? Errno[errnoForDOMException(ex)] : Errno.EIO;
-    const error = new ErrnoError(code, ex.message, path, syscall);
+    const error = new Exception(code, ex.message);
     error.stack = ex.stack;
+    Error.captureStackTrace?.(error, convertException);
     error.cause = ex.cause;
     return error;
 }

package/dist/xml.d.ts

@@ -1,5 +1,5 @@
-import type { CreationOptions, File, InodeLike, StatsLike } from '@zenfs/core';
-import { FileSystem, Stats } from '@zenfs/core';
+import type { CreationOptions, InodeLike, StatsLike } from '@zenfs/core';
+import { FileSystem, Inode } from '@zenfs/core';
 export interface XMLOptions {
     /**
      * The root `fs` element
@@ -18,15 +18,15 @@ export declare class XMLFS extends XMLFS_base {
      */
     root?: Element);
     renameSync(oldPath: string, newPath: string): void;
-    statSync(path: string): Stats;
-    openFileSync(path: string, flag: string): File;
-    createFileSync(path: string, flag: string, mode: number, { uid, gid }: CreationOptions): File;
+    statSync(path: string): Inode;
+    createFileSync(path: string, options: CreationOptions): Inode;
     unlinkSync(path: string): void;
     rmdirSync(path: string): void;
-    mkdirSync(path: string, mode: number, { uid, gid }: CreationOptions): void;
+    mkdirSync(path: string, options: CreationOptions): InodeLike;
     readdirSync(path: string): string[];
     linkSync(target: string, link: string): void;
-    syncSync(path: string, data?: Uint8Array, stats?: Readonly<Partial<InodeLike>>): void;
+    touchSync(path: string, metadata: Partial<InodeLike>): void;
+    syncSync(): void;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     writeSync(path: string, buffer: Uint8Array, offset: number): void;
     toString(): string;
@@ -39,7 +39,7 @@ declare const _XML: {
     name: string;
     options: {
         root: {
-            type: "object";
+            type: string;
             required: false;
         };
     };

package/dist/xml.js

@@ -1,5 +1,7 @@
-import { _inode_fields, constants, decodeRaw, encodeRaw, Errno, ErrnoError, FileSystem, LazyFile, Stats, Sync } from '@zenfs/core';
-import { basename, dirname } from '@zenfs/core/vfs/path.js';
+import { withErrno } from 'kerium';
+import { _inode_fields, constants, FileSystem, Inode, Sync } from '@zenfs/core';
+import { basename, dirname } from '@zenfs/core/path.js';
+import { decodeASCII, encodeASCII } from 'utilium';
 function get_stats(node) {
     const stats = {};
     for (const key of _inode_fields) {
@@ -7,7 +9,7 @@ function get_stats(node) {
         if (value !== null && value !== undefined)
             stats[key] = parseInt(value, 16);
     }
-    return new Stats(stats);
+    return new Inode(stats);
 }
 function set_stats(node, stats) {
     for (const key of Object.keys(stats)) {
@@ -35,9 +37,8 @@ export class XMLFS extends Sync(FileSystem) {
     root = new DOMParser().parseFromString('<fs></fs>', 'application/xml').documentElement) {
         super(0x20786d6c, 'xmltmpfs');
         this.root = root;
-        this.attributes.set('setid');
         try {
-            this.mkdirSync('/', 0o777, { uid: 0, gid: 0 });
+            this.mkdirSync('/', { uid: 0, gid: 0, mode: 0o777 });
         }
         catch (e) {
             const error = e;
@@ -53,72 +54,68 @@ export class XMLFS extends Sync(FileSystem) {
     statSync(path) {
         return get_stats(this.get('stat', path));
     }
-    openFileSync(path, flag) {
-        const node = this.get('openFile', path);
-        return new LazyFile(this, path, flag, get_stats(node));
-    }
-    createFileSync(path, flag, mode, { uid, gid }) {
+    createFileSync(path, options) {
         const parent = this.statSync(dirname(path));
-        const stats = new Stats({
-            mode: mode | constants.S_IFREG,
-            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
-            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        const inode = new Inode({
+            mode: options.mode | constants.S_IFREG,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : options.uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : options.gid,
         });
-        this.create('createFile', path, stats);
-        return new LazyFile(this, path, flag, stats);
+        this.create('createFile', path, inode);
+        return inode;
     }
     unlinkSync(path) {
         const node = this.get('unlink', path);
-        if (get_stats(node).isDirectory())
-            throw ErrnoError.With('EISDIR', path, 'unlink');
+        if (get_stats(node).mode & constants.S_IFDIR)
+            throw withErrno('EISDIR');
         this.remove('unlink', node, path);
     }
     rmdirSync(path) {
         const node = this.get('rmdir', path);
         if (node.textContent?.length)
-            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
-        if (!get_stats(node).isDirectory())
-            throw ErrnoError.With('ENOTDIR', path, 'rmdir');
+            throw withErrno('ENOTEMPTY');
+        if (!(get_stats(node).mode & constants.S_IFDIR))
+            throw withErrno('ENOTDIR');
         this.remove('rmdir', node, path);
     }
-    mkdirSync(path, mode, { uid, gid }) {
+    mkdirSync(path, options) {
         const parent = this.statSync(dirname(path));
-        const node = this.create('mkdir', path, {
-            mode: mode | constants.S_IFDIR,
-            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
-            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        const inode = new Inode({
+            mode: options.mode | constants.S_IFDIR,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : options.uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : options.gid,
         });
-        node.textContent = '[]';
+        this.create('mkdir', path, inode).textContent = '[]';
+        return inode;
     }
     readdirSync(path) {
         const node = this.get('readdir', path);
-        if (!get_stats(node).isDirectory())
-            throw ErrnoError.With('ENOTDIR', path, 'rmdir');
+        if (!(get_stats(node).mode & constants.S_IFDIR))
+            throw withErrno('ENOTDIR');
         try {
             return JSON.parse(node.textContent);
         }
         catch (e) {
-            throw new ErrnoError(Errno.EIO, 'Invalid directory listing: ' + e, path, 'readdir');
+            throw withErrno('EIO', 'Invalid directory listing: ' + e);
         }
     }
     linkSync(target, link) {
         const node = this.get('link', target);
         this.add('link', node, link);
     }
-    syncSync(path, data, stats = {}) {
-        const node = this.get('sync', path);
-        if (data)
-            node.textContent = decodeRaw(data);
-        set_stats(node, stats);
+    touchSync(path, metadata) {
+        const node = this.get('touch', path);
+        set_stats(node, metadata);
     }
+    syncSync() { }
     readSync(path, buffer, offset, end) {
         const node = this.get('read', path);
-        const raw = encodeRaw(node.textContent.slice(offset, end));
+        const raw = encodeASCII(node.textContent.slice(offset, end));
         buffer.set(raw);
     }
     writeSync(path, buffer, offset) {
         const node = this.get('write', path);
-        const data = decodeRaw(buffer);
+        const data = decodeASCII(buffer);
         const after = node.textContent.slice(offset + data.length);
         node.textContent = node.textContent.slice(0, offset) + data + after;
     }
@@ -128,19 +125,19 @@ export class XMLFS extends Sync(FileSystem) {
     get(syscall, path) {
         const nodes = this.root.children;
         if (!nodes)
-            throw ErrnoError.With('EIO', path, syscall);
+            throw withErrno('EIO');
         for (let i = 0; i < nodes.length; i++) {
             if (get_paths(nodes[i]).includes(path))
                 return nodes[i];
         }
-        throw ErrnoError.With('ENOENT', path, syscall);
+        throw withErrno('ENOENT');
     }
     create(syscall, path, stats) {
         if (this.existsSync(path))
-            throw ErrnoError.With('EEXIST', path, syscall);
+            throw withErrno('EEXIST');
         const node = document.createElement('file');
         this.add(syscall, node, path);
-        set_stats(node, new Stats({
+        set_stats(node, new Inode({
             ...stats,
             uid: stats.mode,
         }));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/dom",
-	"version": "1.1.5",
+	"version": "1.1.7",
 	"description": "DOM backends for ZenFS",
 	"funding": {
 		"type": "individual",
@@ -61,8 +61,9 @@
 		"typescript-eslint": "^8.8.1"
 	},
 	"peerDependencies": {
-		"@zenfs/core": "^1.9.1",
-		"utilium": "^1.2.10"
+		"@zenfs/core": "^2.1.0",
+		"kerium": "^1.3.4",
+		"utilium": "^2.0.0"
 	},
 	"keywords": [
 		"filesystem",