@zenfs/dom 1.1.6 → 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;

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));

package/dist/access.d.ts

@@ -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>;
     /**
@@ -33,7 +33,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
      */
     writeFile(path: string, data: Uint8Array): Promise<void>;
     mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
-    protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string, syscall?: string): T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle;
+    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 { 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 }));
         }
     }
@@ -60,24 +61,24 @@ export class WebAccessFS extends Async(IndexFS) {
          * @hidden
          */
         this._sync = InMemory.create({ label: 'accessfs-cache' });
-        this.attributes.set('no_buffer_resize');
+        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) {
@@ -88,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();
@@ -127,17 +128,17 @@ export class WebAccessFS extends Async(IndexFS) {
     }
     async mkdir(path, options) {
         const inode = await super.mkdir(path, options);
-        const handle = this.get('directory', dirname(path), 'mkdir');
+        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/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 {

package/dist/storage.js

@@ -1,4 +1,5 @@
-import { Errno, ErrnoError, StoreFS, 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.
@@ -36,7 +37,7 @@ export class WebStorageStore {
             this.storage.setItem(key.toString(), decodeASCII(data));
         }
         catch {
-            throw new ErrnoError(Errno.ENOSPC, 'Storage is full.');
+            throw withErrno('ENOSPC');
         }
     }
     delete(key) {
@@ -44,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}`);
         }
     }
 }

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.js

@@ -1,4 +1,5 @@
-import { _inode_fields, constants, Errno, ErrnoError, FileSystem, Inode, Sync } from '@zenfs/core';
+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) {
@@ -66,15 +67,15 @@ export class XMLFS extends Sync(FileSystem) {
     unlinkSync(path) {
         const node = this.get('unlink', path);
         if (get_stats(node).mode & constants.S_IFDIR)
-            throw ErrnoError.With('EISDIR', path, 'unlink');
+            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');
+            throw withErrno('ENOTEMPTY');
         if (!(get_stats(node).mode & constants.S_IFDIR))
-            throw ErrnoError.With('ENOTDIR', path, 'rmdir');
+            throw withErrno('ENOTDIR');
         this.remove('rmdir', node, path);
     }
     mkdirSync(path, options) {
@@ -90,12 +91,12 @@ export class XMLFS extends Sync(FileSystem) {
     readdirSync(path) {
         const node = this.get('readdir', path);
         if (!(get_stats(node).mode & constants.S_IFDIR))
-            throw ErrnoError.With('ENOTDIR', path, 'rmdir');
+            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) {
@@ -124,16 +125,16 @@ 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 Inode({

package/package.json

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