@zenfs/dom 1.1.2 → 1.1.4

package/dist/IndexedDB.d.ts

@@ -1,27 +1,27 @@
-import type { AsyncMixin, SharedConfig, Store } from '@zenfs/core';
+import type { SharedConfig, Store } from '@zenfs/core';
 import { AsyncTransaction, StoreFS } from '@zenfs/core';
+import type * as cache from 'utilium/cache.js';
 /**
- * @hidden
+ * @internal @hidden
  */
 export declare class IndexedDBTransaction extends AsyncTransaction<IndexedDBStore> {
     tx: IDBTransaction;
     store: IndexedDBStore;
     private _idb;
     constructor(tx: IDBTransaction, store: IndexedDBStore);
-    keys(): Promise<Iterable<bigint>>;
-    get(key: bigint): Promise<Uint8Array>;
-    set(key: bigint, data: Uint8Array): Promise<void>;
-    remove(key: bigint): Promise<void>;
+    keys(): Promise<Iterable<number>>;
+    get(id: number): Promise<Uint8Array | undefined>;
+    set(id: number, data: Uint8Array): Promise<void>;
+    remove(id: number): Promise<void>;
     commit(): Promise<void>;
     abort(): Promise<void>;
 }
 export declare class IndexedDBStore implements Store {
     protected db: IDBDatabase;
+    cache: Map<number, cache.Resource<number>>;
     constructor(db: IDBDatabase);
     sync(): Promise<void>;
     get name(): string;
-    clear(): Promise<void>;
-    clearSync(): void;
     transaction(): IndexedDBTransaction;
 }
 /**
@@ -53,7 +53,7 @@ declare const _IndexedDB: {
         };
     };
     readonly isAvailable: (idbFactory?: IDBFactory) => Promise<boolean>;
-    readonly create: (options: IndexedDBOptions & Partial<SharedConfig>) => Promise<AsyncMixin & StoreFS<IndexedDBStore>>;
+    readonly create: (options: IndexedDBOptions & Partial<SharedConfig>) => Promise<StoreFS<IndexedDBStore>>;
 };
 type _IndexedDB = typeof _IndexedDB;
 export interface IndexedDB extends _IndexedDB {

package/dist/IndexedDB.js

@@ -1,4 +1,4 @@
-import { Async, AsyncTransaction, ErrnoError, InMemory, StoreFS } from '@zenfs/core';
+import { AsyncTransaction, StoreFS, log } from '@zenfs/core';
 import { convertException } from './utils.js';
 function wrap(request) {
     return new Promise((resolve, reject) => {
@@ -10,7 +10,7 @@ function wrap(request) {
     });
 }
 /**
- * @hidden
+ * @internal @hidden
  */
 export class IndexedDBTransaction extends AsyncTransaction {
     constructor(tx, store) {
@@ -20,33 +20,30 @@ export class IndexedDBTransaction extends AsyncTransaction {
         this._idb = tx.objectStore(store.name);
     }
     async keys() {
-        return (await wrap(this._idb.getAllKeys())).filter(k => typeof k == 'string').map(k => BigInt(k));
+        return (await wrap(this._idb.getAllKeys())).filter(k => typeof k == 'string').map(k => Number(k));
     }
-    get(key) {
-        return wrap(this._idb.get(key.toString()));
+    async get(id) {
+        const data = await wrap(this._idb.get(id.toString()));
+        if (data)
+            this._cached(id, { size: data.byteLength }).add(data, 0);
+        return data;
     }
-    async set(key, data) {
-        await wrap(this._idb.put(data, key.toString()));
+    async set(id, data) {
+        this._cached(id, { size: data.byteLength }).add(data, 0);
+        await wrap(this._idb.put(data, id.toString()));
     }
-    remove(key) {
-        return wrap(this._idb.delete(key.toString()));
+    remove(id) {
+        this.store.cache.delete(id);
+        return wrap(this._idb.delete(id.toString()));
     }
     async commit() {
-        if (this.done) {
-            return;
-        }
         const { promise, resolve, reject } = Promise.withResolvers();
-        this.done = true;
         this.tx.oncomplete = () => resolve();
         this.tx.onerror = () => reject(convertException(this.tx.error));
         this.tx.commit();
         return promise;
     }
     async abort() {
-        if (this.done) {
-            return;
-        }
-        this.done = true;
         const { promise, resolve, reject } = Promise.withResolvers();
         this.tx.onabort = () => resolve();
         this.tx.onerror = () => reject(convertException(this.tx.error));
@@ -60,29 +57,24 @@ async function createDB(name, indexedDB = globalThis.indexedDB) {
         const db = req.result;
         // This should never happen; we're at version 1. Why does another database exist?
         if (db.objectStoreNames.contains(name)) {
+            log.warn('Found unexpected object store: ' + name);
             db.deleteObjectStore(name);
         }
         db.createObjectStore(name);
     };
-    const result = await wrap(req);
-    return result;
+    return await wrap(req);
 }
 export class IndexedDBStore {
     constructor(db) {
         this.db = db;
+        this.cache = new Map();
     }
     sync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'IndexedDBStore.sync');
+        return Promise.resolve();
     }
     get name() {
         return this.db.name;
     }
-    clear() {
-        return wrap(this.db.transaction(this.name, 'readwrite').objectStore(this.name).clear());
-    }
-    clearSync() {
-        throw ErrnoError.With('ENOSYS', undefined, 'IndexedDBStore.clearSync');
-    }
     transaction() {
         const tx = this.db.transaction(this.name, 'readwrite');
         return new IndexedDBTransaction(tx, this);
@@ -94,14 +86,8 @@ export class IndexedDBStore {
 const _IndexedDB = {
     name: 'IndexedDB',
     options: {
-        storeName: {
-            type: 'string',
-            required: false,
-        },
-        idbFactory: {
-            type: 'object',
-            required: false,
-        },
+        storeName: { type: 'string', required: false },
+        idbFactory: { type: 'object', required: false },
     },
     async isAvailable(idbFactory = globalThis.indexedDB) {
         try {
@@ -122,9 +108,14 @@ const _IndexedDB = {
     async create(options) {
         const db = await createDB(options.storeName || 'zenfs', options.idbFactory);
         const store = new IndexedDBStore(db);
-        const fs = new (Async(StoreFS))(store);
-        if (!options?.disableAsyncCache) {
-            fs._sync = InMemory.create({ name: 'idb-cache' });
+        const fs = new StoreFS(store);
+        if (options?.disableAsyncCache) {
+            log.notice('Async preloading disabled for IndexedDB');
+            return fs;
+        }
+        const tx = store.transaction();
+        for (const id of await tx.keys()) {
+            await tx.get(id); // Adds to cache
         }
         return fs;
     },

package/dist/access.d.ts

@@ -1,29 +1,60 @@
-import type { CreationOptions, FileSystemMetadata } from '@zenfs/core';
-import { FileSystem, PreloadFile, Stats } from '@zenfs/core';
+import type { CreationOptions, File, InodeLike, Stats } from '@zenfs/core';
+import { FileSystem, Index } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
+    metadata?: string;
 }
+type HKindToType<T extends FileSystemHandleKind> = T extends 'directory' ? FileSystemDirectoryHandle : T extends 'file' ? FileSystemFileHandle : FileSystemHandle;
 declare const WebAccessFS_base: import("@zenfs/core").Mixin<typeof FileSystem, import("@zenfs/core").AsyncMixin>;
 export declare class WebAccessFS extends WebAccessFS_base {
-    private _handles;
+    /**
+     * Disables index optimizations,
+     * like using the index for `readdir`
+     */
+    private readonly disableIndexOptimizations;
+    protected index: Index;
+    protected _handles: Map<string, FileSystemHandle>;
+    /**
+     * Loads all of the handles.
+     * @internal @hidden
+     */
+    _loadHandles(path: string, handle: FileSystemDirectoryHandle): Promise<void>;
+    /**
+     * Loads metadata
+     * @internal @hidden
+     */
+    _loadMetadata(metadataPath?: string): Promise<void>;
     /**
      * @hidden
      */
     _sync: FileSystem;
-    constructor(handle: FileSystemDirectoryHandle);
-    metadata(): FileSystemMetadata;
-    sync(path: string, data: Uint8Array): Promise<void>;
+    constructor(handle: FileSystemDirectoryHandle, 
+    /**
+     * Disables index optimizations,
+     * like using the index for `readdir`
+     */
+    disableIndexOptimizations?: boolean);
     rename(oldPath: string, newPath: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
+    write(path: string, buffer: Uint8Array, offset: number): Promise<void>;
+    /**
+     * Do not use!
+     * @deprecated @internal @hidden
+     */
     writeFile(path: string, data: Uint8Array): Promise<void>;
-    createFile(path: string, flag: string): Promise<PreloadFile<this>>;
     stat(path: string): Promise<Stats>;
-    openFile(path: string, flag: string): Promise<PreloadFile<this>>;
-    unlink(path: string): Promise<void>;
+    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
+    openFile(path: string, flag: string): Promise<File>;
+    /**
+     * @todo Implement
+     */
     link(srcpath: string): Promise<void>;
+    sync(path: string, data?: Uint8Array, stats?: Readonly<Partial<InodeLike>>): Promise<void>;
     rmdir(path: string): Promise<void>;
-    mkdir(path: string, mode?: number, options?: CreationOptions): Promise<void>;
+    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
     readdir(path: string): Promise<string[]>;
-    protected getHandle(path: string): Promise<FileSystemHandle | undefined>;
+    protected get<const T extends FileSystemHandleKind | null>(kind: T | undefined, path: string, syscall?: string): T extends FileSystemHandleKind ? HKindToType<T> : FileSystemHandle;
 }
 declare const _WebAccess: {
     readonly name: "WebAccess";
@@ -32,9 +63,12 @@ declare const _WebAccess: {
             readonly type: "object";
             readonly required: true;
         };
+        readonly metadata: {
+            readonly type: "string";
+            readonly required: false;
+        };
     };
-    readonly isAvailable: () => boolean;
-    readonly create: (options: WebAccessOptions) => WebAccessFS;
+    readonly create: (options: WebAccessOptions) => Promise<WebAccessFS>;
 };
 type _WebAccess = typeof _WebAccess;
 export interface WebAccess extends _WebAccess {

package/dist/access.js

@@ -1,6 +1,7 @@
-import { Async, Errno, ErrnoError, FileSystem, InMemory, PreloadFile, Stats } from '@zenfs/core';
-import { S_IFDIR, S_IFREG } from '@zenfs/core/emulation/constants.js';
-import { basename, dirname, join } from '@zenfs/core/emulation/path.js';
+import { Async, constants, Errno, ErrnoError, FileSystem, Index, InMemory, Inode, LazyFile } from '@zenfs/core';
+import { S_IFDIR, S_IFREG } from '@zenfs/core/vfs/constants.js';
+import { basename, dirname, join } from '@zenfs/core/vfs/path.js';
+import { _throw } from 'utilium';
 import { convertException } from './utils.js';
 function isResizable(buffer) {
     if (buffer instanceof ArrayBuffer)
@@ -9,184 +10,243 @@ function isResizable(buffer) {
         return buffer.growable;
     return false;
 }
+/**
+ * Since `FileSystemHandle.kind` doesn't have correct type support
+ */
+function isKind(handle, kind) {
+    return handle.kind == kind;
+}
 export class WebAccessFS extends Async(FileSystem) {
-    constructor(handle) {
-        super();
+    /**
+     * Loads all of the handles.
+     * @internal @hidden
+     */
+    async _loadHandles(path, handle) {
+        for await (const [key, child] of handle.entries()) {
+            const p = join(path, key);
+            this._handles.set(p, child);
+            if (isKind(child, 'directory'))
+                await this._loadHandles(p, child);
+        }
+    }
+    /**
+     * Loads metadata
+     * @internal @hidden
+     */
+    async _loadMetadata(metadataPath) {
+        if (metadataPath) {
+            const handle = this.get('file', metadataPath);
+            const file = await handle.getFile();
+            const raw = await file.text();
+            const data = JSON.parse(raw);
+            this.index.fromJSON(data);
+            return;
+        }
+        for (const [path, handle] of this._handles) {
+            if (isKind(handle, 'file')) {
+                const { lastModified, size } = await handle.getFile();
+                this.index.set(path, new Inode({ mode: 0o644 | constants.S_IFREG, size, mtimeMs: lastModified }));
+                continue;
+            }
+            if (!isKind(handle, 'directory'))
+                throw new ErrnoError(Errno.EIO, 'Invalid handle', path);
+            this.index.set(path, new Inode({ mode: 0o777 | constants.S_IFDIR, size: 0 }));
+        }
+    }
+    constructor(handle, 
+    /**
+     * Disables index optimizations,
+     * like using the index for `readdir`
+     */
+    disableIndexOptimizations = false) {
+        super(0x77656261, 'webaccessfs');
+        this.disableIndexOptimizations = disableIndexOptimizations;
+        this.index = new Index();
         this._handles = new Map();
         /**
          * @hidden
          */
         this._sync = InMemory.create({ name: 'accessfs-cache' });
+        this.attributes.set('no_buffer_resize');
+        this.attributes.set('setid');
         this._handles.set('/', handle);
     }
-    metadata() {
-        return {
-            ...super.metadata(),
-            name: 'WebAccess',
-            noResizableBuffers: true,
-            // Not really, but we don't support opening directories so this prevent the VFS from trying
-            features: ['setid'],
-        };
-    }
-    async sync(path, data) {
-        await this.writeFile(path, data);
-    }
     async rename(oldPath, newPath) {
-        const handle = await this.getHandle(oldPath);
-        if (handle instanceof FileSystemDirectoryHandle) {
+        if (oldPath == newPath)
+            return;
+        if (newPath.startsWith(oldPath + '/'))
+            throw ErrnoError.With('EBUSY', oldPath, 'rename');
+        const handle = this.get(null, oldPath, 'rename');
+        if (isKind(handle, 'directory')) {
             const files = await this.readdir(oldPath);
-            await this.mkdir(newPath);
-            if (!files.length) {
-                await this.unlink(oldPath);
-                return;
-            }
-            for (const file of files) {
+            const stats = await this.stat(oldPath);
+            await this.mkdir(newPath, stats.mode, stats);
+            for (const file of files)
                 await this.rename(join(oldPath, file), join(newPath, file));
-                await this.unlink(oldPath);
-            }
+            await this.rmdir(oldPath);
             return;
         }
-        if (!(handle instanceof FileSystemFileHandle)) {
+        if (!isKind(handle, 'file')) {
             throw new ErrnoError(Errno.ENOTSUP, 'Not a file or directory handle', oldPath, 'rename');
         }
-        const oldFile = await handle.getFile().catch((ex) => {
-            throw convertException(ex, oldPath, 'rename');
-        }), destFolder = await this.getHandle(dirname(newPath));
-        if (!(destFolder instanceof FileSystemDirectoryHandle)) {
-            return;
-        }
-        const newFile = await destFolder.getFileHandle(basename(newPath), { create: true }).catch((ex) => {
-            throw convertException(ex, newPath, 'rename');
-        });
+        const oldFile = await handle.getFile().catch(ex => _throw(convertException(ex, oldPath, 'rename')));
+        const destFolder = this.get('directory', dirname(newPath), 'rename');
+        const newFile = await destFolder
+            .getFileHandle(basename(newPath), { create: true })
+            .catch((ex) => _throw(ex.name == 'TypeMismatchError' ? ErrnoError.With('EISDIR', newPath, 'rename') : convertException(ex, newPath, 'rename')));
         const writable = await newFile.createWritable();
         await writable.write(await oldFile.arrayBuffer());
         await writable.close();
         await this.unlink(oldPath);
+        this._handles.set(newPath, newFile);
     }
-    async writeFile(path, data) {
-        if (isResizable(data.buffer)) {
-            throw new ErrnoError(Errno.EINVAL, 'Resizable buffers can not be written', path, 'write');
-        }
-        const handle = await this.getHandle(dirname(path));
-        if (!(handle instanceof FileSystemDirectoryHandle)) {
+    async unlink(path) {
+        if (path == '/')
+            throw ErrnoError.With('EBUSY', '/', 'unlink');
+        const handle = this.get('directory', dirname(path), 'unlink');
+        await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path, 'unlink')));
+        this.index.delete(path);
+    }
+    async read(path, buffer, offset, end) {
+        if (end <= offset)
             return;
-        }
-        const file = await handle.getFileHandle(basename(path), { create: true });
-        const writable = await file.createWritable();
-        await writable.write(data);
+        const handle = this.get('file', path, 'write');
+        const file = await handle.getFile();
+        const data = await file.arrayBuffer();
+        if (data.byteLength < end - offset)
+            throw ErrnoError.With('ENODATA', path, 'read');
+        buffer.set(new Uint8Array(data, offset, end - offset));
+    }
+    async write(path, buffer, offset) {
+        if (isResizable(buffer.buffer)) {
+            const newBuffer = new Uint8Array(new ArrayBuffer(buffer.byteLength), buffer.byteOffset, buffer.byteLength);
+            newBuffer.set(buffer);
+            buffer = newBuffer;
+        }
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'write');
+        const handle = this.get('file', path, 'write');
+        const writable = await handle.createWritable();
+        try {
+            await writable.seek(offset);
+        }
+        catch {
+            await writable.write({ type: 'seek', position: offset });
+        }
+        await writable.write(buffer);
         await writable.close();
+        const { size, lastModified } = await handle.getFile();
+        inode.update({ size, mtimeMs: lastModified });
+        this.index.set(path, inode);
     }
-    async createFile(path, flag) {
-        await this.writeFile(path, new Uint8Array());
-        return this.openFile(path, flag);
+    /**
+     * Do not use!
+     * @deprecated @internal @hidden
+     */
+    async writeFile(path, data) {
+        return this.write(path, data, 0);
     }
+    // eslint-disable-next-line @typescript-eslint/require-await
     async stat(path) {
-        const handle = await this.getHandle(path);
-        if (!handle) {
+        const inode = this.index.get(path);
+        if (!inode)
             throw ErrnoError.With('ENOENT', path, 'stat');
-        }
-        if (handle instanceof FileSystemDirectoryHandle) {
-            return new Stats({ mode: 0o777 | S_IFDIR, size: 4096 });
-        }
-        if (handle instanceof FileSystemFileHandle) {
-            const { lastModified, size } = await handle.getFile();
-            return new Stats({ mode: 0o777 | S_IFREG, size, mtimeMs: lastModified });
-        }
-        throw new ErrnoError(Errno.EBADE, 'Handle is not a directory or file', path, 'stat');
+        return inode.toStats();
     }
-    async openFile(path, flag) {
-        const handle = await this.getHandle(path);
-        if (!(handle instanceof FileSystemFileHandle)) {
-            throw ErrnoError.With('EISDIR', path, 'openFile');
-        }
-        const file = await handle.getFile().catch((ex) => {
-            throw convertException(ex, path, 'openFile');
-        });
-        const data = new Uint8Array(await file.arrayBuffer());
-        const stats = new Stats({ mode: 0o777 | S_IFREG, size: file.size, mtimeMs: file.lastModified });
-        return new PreloadFile(this, path, flag, stats, data);
+    async createFile(path, flag, mode, options) {
+        const handle = this.get('directory', dirname(path), 'createFile');
+        if (this.index.has(path))
+            throw ErrnoError.With('EEXIST', path, 'createFile');
+        const file = await handle.getFileHandle(basename(path), { create: true });
+        // Race condition bypass
+        const inode = this.index.get(path) ?? new Inode({ ...options, mode: mode | S_IFREG });
+        this.index.set(path, inode);
+        this._handles.set(path, file);
+        return new LazyFile(this, path, flag, inode);
     }
-    async unlink(path) {
-        const handle = await this.getHandle(dirname(path));
-        if (!(handle instanceof FileSystemDirectoryHandle)) {
-            throw ErrnoError.With('ENOTDIR', dirname(path), 'unlink');
-        }
-        await handle.removeEntry(basename(path), { recursive: true }).catch((ex) => {
-            throw convertException(ex, path, 'unlink');
-        });
+    async openFile(path, flag) {
+        const inode = this.index.get(path);
+        if (!inode)
+            throw ErrnoError.With('ENOENT', path, 'stat');
+        return new LazyFile(this, path, flag, inode.toStats());
     }
-    // eslint-disable-next-line @typescript-eslint/require-await
+    /**
+     * @todo Implement
+     */
     async link(srcpath) {
         return;
     }
+    async sync(path, data, stats) {
+        const inode = this.index.get(path) ?? new Inode();
+        inode.update(stats);
+        this.index.set(path, inode);
+        if (!data)
+            return;
+        const handle = this.get('file', path, 'write');
+        const writable = await handle.createWritable();
+        try {
+            await writable.seek(0);
+        }
+        catch {
+            await writable.write({ type: 'seek', position: 0 });
+        }
+        await writable.write(data);
+        await writable.close();
+    }
     async rmdir(path) {
-        return this.unlink(path);
+        if ((await this.readdir(path)).length)
+            throw ErrnoError.With('ENOTEMPTY', path, 'rmdir');
+        if (path == '/')
+            throw ErrnoError.With('EBUSY', '/', 'rmdir');
+        const handle = this.get('directory', dirname(path), 'rmdir');
+        await handle.removeEntry(basename(path), { recursive: true }).catch(ex => _throw(convertException(ex, path, 'rmdir')));
+        this.index.delete(path);
     }
     async mkdir(path, mode, options) {
-        const existingHandle = await this.getHandle(path).catch((ex) => {
-            if (ex.code != 'ENOENT') {
-                throw ex;
-            }
-        });
-        if (existingHandle) {
+        if (this.index.has(path))
             throw ErrnoError.With('EEXIST', path, 'mkdir');
-        }
-        const handle = await this.getHandle(dirname(path));
-        if (!(handle instanceof FileSystemDirectoryHandle)) {
-            throw ErrnoError.With('ENOTDIR', path, 'mkdir');
-        }
-        await handle.getDirectoryHandle(basename(path), { create: true });
+        const handle = this.get('directory', dirname(path), 'mkdir');
+        const dir = await handle.getDirectoryHandle(basename(path), { create: true });
+        this._handles.set(path, dir);
+        this.index.set(path, new Inode({ ...options, mode: mode | S_IFDIR }));
     }
     async readdir(path) {
-        const handle = await this.getHandle(path);
-        if (!(handle instanceof FileSystemDirectoryHandle)) {
-            throw ErrnoError.With('ENOTDIR', path, 'readdir');
-        }
+        if (!this.disableIndexOptimizations) {
+            if (!this.index.has(path))
+                throw ErrnoError.With('ENOENT', path, 'readdir');
+            const entries = this.index.directoryEntries(path);
+            if (!entries)
+                throw ErrnoError.With('ENOTDIR', path, 'readdir');
+            return Object.keys(entries);
+        }
+        const handle = this.get('directory', path, 'readdir');
         const entries = [];
         for await (const k of handle.keys()) {
             entries.push(k);
         }
         return entries;
     }
-    async getHandle(path) {
-        if (this._handles.has(path)) {
-            return this._handles.get(path);
-        }
-        let walked = '/';
-        for (const part of path.split('/').slice(1)) {
-            const handle = this._handles.get(walked);
-            if (!(handle instanceof FileSystemDirectoryHandle)) {
-                throw ErrnoError.With('ENOTDIR', walked, 'getHandle');
-            }
-            walked = join(walked, part);
-            const child = await handle.getDirectoryHandle(part).catch((ex) => {
-                switch (ex.name) {
-                    case 'TypeMismatchError':
-                        return handle.getFileHandle(part).catch((ex) => {
-                            //throw convertException(ex, walked, 'getHandle');
-                        });
-                    case 'TypeError':
-                        throw new ErrnoError(Errno.ENOENT, ex.message, walked, 'getHandle');
-                    default:
-                        throw convertException(ex, walked, 'getHandle');
-                }
-            });
-            if (child)
-                this._handles.set(walked, child);
-        }
-        return this._handles.get(path);
+    get(kind = null, path, syscall) {
+        const handle = this._handles.get(path);
+        if (!handle)
+            throw ErrnoError.With('ENODATA', path, syscall);
+        if (kind && !isKind(handle, kind))
+            throw ErrnoError.With(kind == 'directory' ? 'ENOTDIR' : 'EISDIR', path, syscall);
+        return handle;
     }
 }
 const _WebAccess = {
     name: 'WebAccess',
     options: {
         handle: { type: 'object', required: true },
+        metadata: { type: 'string', required: false },
     },
-    isAvailable() {
-        return typeof FileSystemHandle == 'function';
-    },
-    create(options) {
-        return new WebAccessFS(options.handle);
+    async create(options) {
+        const fs = new WebAccessFS(options.handle);
+        await fs._loadHandles('/', options.handle);
+        await fs._loadMetadata(options.metadata);
+        return fs;
     },
 };
 export const WebAccess = _WebAccess;

package/dist/devices/dsp.js

@@ -8,8 +8,8 @@ if ('AudioWorkletProcessor' in globalThis) {
         }
         process(inputs, outputs) {
             if (this.buffer && this.buffer.byteLength >= 128) {
-                outputs[0][0].set(this.buffer.slice(0, 128));
-                this.buffer = this.buffer.slice(128);
+                outputs[0][0].set(this.buffer.subarray(0, 128));
+                this.buffer = this.buffer.subarray(128);
             }
             return true;
         }
@@ -44,12 +44,11 @@ export async function dsp(options = {}) {
         init(ino, options) {
             return { data: dsp, major: 14, minor: 3 };
         },
-        read() {
-            return 0;
+        readD() {
+            return;
         },
-        write(file, data) {
-            file.device.data.port.postMessage(data.buffer);
-            return data.byteLength;
+        writeD(device, buffer, offset) {
+            device.data.port.postMessage(buffer.buffer);
         },
     };
 }

package/dist/devices/framebuffer.d.ts

@@ -2,6 +2,10 @@ import type { DeviceDriver } from '@zenfs/core';
 export interface FramebufferOptions {
     canvas?: HTMLCanvasElement | null;
 }
+export interface FramebufferData {
+    context: CanvasRenderingContext2D;
+    image: ImageData;
+}
 /**
  * A frame buffer
  *
@@ -10,4 +14,4 @@ export interface FramebufferOptions {
  * addDevice(framebuffer, { canvas: document.querySelector('#your-canvas') })
  * ```
  */
-export declare const framebuffer: DeviceDriver<CanvasRenderingContext2D>;
+export declare const framebuffer: DeviceDriver<FramebufferData>;

package/dist/devices/framebuffer.js

@@ -15,22 +15,22 @@ export const framebuffer = {
             canvas = document.createElement('canvas');
             document.body.appendChild(canvas);
         }
-        const ctx = canvas.getContext('2d');
-        if (!ctx) {
+        const context = canvas.getContext('2d');
+        if (!context) {
             throw new ErrnoError(Errno.EIO, 'Could not get context from canvas whilst initializing frame buffer.');
         }
-        return { data: ctx, major: 29, minor: framebufferN++, name: 'fb' };
+        const image = new ImageData(canvas.width, canvas.height);
+        return {
+            data: { context, image },
+            major: 29,
+            minor: framebufferN++,
+            name: 'fb',
+        };
     },
-    read() {
-        return 0;
-    },
-    write(file, data) {
-        const { width, height } = file.device.data.canvas;
-        if (data.byteLength < 4 * width * height) {
-            return 0;
-        }
-        const imageData = new ImageData(new Uint8ClampedArray(data), width, height);
-        file.device.data.putImageData(imageData, 0, 0);
-        return data.byteLength;
+    readD() { },
+    writeD({ data: { image, context } }, buffer, offset) {
+        image.data.set(buffer, offset);
+        context.putImageData(image, 0, 0);
+        return buffer.byteLength;
     },
 };

package/dist/storage.d.ts

@@ -1,20 +1,20 @@
-import type { SimpleSyncStore, Store } from '@zenfs/core';
-import { SimpleTransaction, StoreFS } from '@zenfs/core';
+import type { SyncMapStore, Store } from '@zenfs/core';
+import { StoreFS, SyncMapTransaction } from '@zenfs/core';
 /**
  * A synchronous key-value store backed by Storage.
  */
-export declare class WebStorageStore implements Store, SimpleSyncStore {
+export declare class WebStorageStore implements Store, SyncMapStore {
     protected storage: Storage;
     get name(): string;
     constructor(storage: Storage);
     clear(): void;
     clearSync(): void;
     sync(): Promise<void>;
-    transaction(): SimpleTransaction;
-    keys(): Iterable<bigint>;
-    get(key: bigint): Uint8Array | undefined;
-    set(key: bigint, data: Uint8Array): void;
-    delete(key: bigint): void;
+    transaction(): SyncMapTransaction;
+    keys(): Iterable<number>;
+    get(key: number): Uint8Array | undefined;
+    set(key: number, data: Uint8Array): void;
+    delete(key: number): void;
 }
 /**
  * Options to pass to the StorageFileSystem

package/dist/storage.js

@@ -1,4 +1,4 @@
-import { ErrnoError, Errno, SimpleTransaction, StoreFS, decodeRaw, encodeRaw } from '@zenfs/core';
+import { ErrnoError, Errno, StoreFS, decodeRaw, encodeRaw, SyncMapTransaction } from '@zenfs/core';
 /**
  * A synchronous key-value store backed by Storage.
  */
@@ -18,10 +18,10 @@ export class WebStorageStore {
     }
     async sync() { }
     transaction() {
-        return new SimpleTransaction(this);
+        return new SyncMapTransaction(this);
     }
     keys() {
-        return Object.keys(this.storage).map(k => BigInt(k));
+        return Object.keys(this.storage).map(k => Number(k));
     }
     get(key) {
         const data = this.storage.getItem(key.toString());

package/dist/utils.js

@@ -57,9 +57,8 @@ function errnoForDOMException(ex) {
  * @internal
  */
 export function convertException(ex, path, syscall) {
-    if (ex instanceof ErrnoError) {
+    if (ex instanceof ErrnoError)
         return ex;
-    }
     const code = ex instanceof DOMException ? Errno[errnoForDOMException(ex)] : Errno.EIO;
     const error = new ErrnoError(code, ex.message, path, syscall);
     error.stack = ex.stack;

package/dist/xml.d.ts

@@ -1,4 +1,4 @@
-import type { CreationOptions, File, FileSystemMetadata, StatsLike } from '@zenfs/core';
+import type { CreationOptions, File, InodeLike, StatsLike } from '@zenfs/core';
 import { FileSystem, Stats } from '@zenfs/core';
 export interface XMLOptions {
     /**
@@ -9,15 +9,14 @@ export interface XMLOptions {
 declare const XMLFS_base: import("@zenfs/core").Mixin<typeof FileSystem, import("@zenfs/core").AsyncFSMethods>;
 export declare class XMLFS extends XMLFS_base {
     /**
-     * @inheritdoc XMLOptions.root
+     * @inheritDoc XMLOptions.root
      */
     readonly root: Element;
     constructor(
     /**
-     * @inheritdoc XMLOptions.root
+     * @inheritDoc XMLOptions.root
      */
     root?: Element);
-    metadata(): FileSystemMetadata;
     renameSync(oldPath: string, newPath: string): void;
     statSync(path: string): Stats;
     openFileSync(path: string, flag: string): File;
@@ -27,10 +26,12 @@ export declare class XMLFS extends XMLFS_base {
     mkdirSync(path: string, mode: number, { uid, gid }: CreationOptions): void;
     readdirSync(path: string): string[];
     linkSync(target: string, link: string): void;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
+    syncSync(path: string, data?: Uint8Array, stats?: Readonly<Partial<InodeLike>>): void;
+    readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
+    writeSync(path: string, buffer: Uint8Array, offset: number): void;
     toString(): string;
     protected get(syscall: string, path: string): Element;
-    protected create(syscall: string, path: string, stats: Partial<StatsLike<number>> & Pick<StatsLike, 'mode'>): Element;
+    protected create(syscall: string, path: string, stats: Partial<InodeLike> & Pick<StatsLike, 'mode'>): Element;
     protected add(syscall: string, node: Element, path: string, contents?: boolean): void;
     protected remove(syscall: string, node: Element, path: string, contents?: boolean): void;
 }

package/dist/xml.js

@@ -1,20 +1,19 @@
-import { decodeRaw, encodeRaw, Errno, ErrnoError, FileSystem, PreloadFile, Stats, Sync } from '@zenfs/core';
-import { S_IFDIR, S_IFREG, S_ISGID, S_ISUID } from '@zenfs/core/emulation/constants.js';
-import { basename, dirname } from '@zenfs/core/emulation/path.js';
-const statsLikeKeys = ['size', 'mode', 'atimeMs', 'mtimeMs', 'ctimeMs', 'birthtimeMs', 'uid', 'gid', 'ino', 'nlink'];
+import { _inode_fields, constants, decodeRaw, encodeRaw, Errno, ErrnoError, FileSystem, LazyFile, Stats, Sync } from '@zenfs/core';
+import { basename, dirname } from '@zenfs/core/vfs/path.js';
 function get_stats(node) {
     const stats = {};
-    for (const key of statsLikeKeys) {
+    for (const key of _inode_fields) {
         const value = node.getAttribute(key);
-        stats[key] = value != null ? parseInt(value, 16) : undefined;
+        if (value !== null && value !== undefined)
+            stats[key] = parseInt(value, 16);
     }
     return new Stats(stats);
 }
 function set_stats(node, stats) {
-    for (const key of statsLikeKeys) {
-        if (stats[key] != undefined) {
-            node.setAttribute(key, stats[key].toString(16));
-        }
+    for (const key of Object.keys(stats)) {
+        if (!(key in _inode_fields) || stats[key] === undefined)
+            continue;
+        node.setAttribute(key, stats[key].toString(16));
     }
 }
 function get_paths(node, contents = false) {
@@ -31,11 +30,12 @@ function get_paths(node, contents = false) {
 export class XMLFS extends Sync(FileSystem) {
     constructor(
     /**
-     * @inheritdoc XMLOptions.root
+     * @inheritDoc XMLOptions.root
      */
     root = new DOMParser().parseFromString('<fs></fs>', 'application/xml').documentElement) {
-        super();
+        super(0x20786d6c, 'xmltmpfs');
         this.root = root;
+        this.attributes.set('setid');
         try {
             this.mkdirSync('/', 0o777, { uid: 0, gid: 0 });
         }
@@ -45,9 +45,6 @@ export class XMLFS extends Sync(FileSystem) {
                 throw error;
         }
     }
-    metadata() {
-        return { ...super.metadata(), features: ['setid'] };
-    }
     renameSync(oldPath, newPath) {
         const node = this.get('rename', oldPath);
         this.remove('rename', node, oldPath);
@@ -58,17 +55,17 @@ export class XMLFS extends Sync(FileSystem) {
     }
     openFileSync(path, flag) {
         const node = this.get('openFile', path);
-        return new PreloadFile(this, path, flag, get_stats(node), encodeRaw(node.textContent));
+        return new LazyFile(this, path, flag, get_stats(node));
     }
     createFileSync(path, flag, mode, { uid, gid }) {
         const parent = this.statSync(dirname(path));
         const stats = new Stats({
-            mode: mode | S_IFREG,
-            uid: parent.mode & S_ISUID ? parent.uid : uid,
-            gid: parent.mode & S_ISGID ? parent.gid : gid,
+            mode: mode | constants.S_IFREG,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
         });
         this.create('createFile', path, stats);
-        return new PreloadFile(this, path, flag, stats);
+        return new LazyFile(this, path, flag, stats);
     }
     unlinkSync(path) {
         const node = this.get('unlink', path);
@@ -87,9 +84,9 @@ export class XMLFS extends Sync(FileSystem) {
     mkdirSync(path, mode, { uid, gid }) {
         const parent = this.statSync(dirname(path));
         const node = this.create('mkdir', path, {
-            mode: mode | S_IFDIR,
-            uid: parent.mode & S_ISUID ? parent.uid : uid,
-            gid: parent.mode & S_ISGID ? parent.gid : gid,
+            mode: mode | constants.S_IFDIR,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
         });
         node.textContent = '[]';
     }
@@ -108,11 +105,23 @@ export class XMLFS extends Sync(FileSystem) {
         const node = this.get('link', target);
         this.add('link', node, link);
     }
-    syncSync(path, data, stats) {
+    syncSync(path, data, stats = {}) {
         const node = this.get('sync', path);
-        node.textContent = decodeRaw(data);
+        if (data)
+            node.textContent = decodeRaw(data);
         set_stats(node, stats);
     }
+    readSync(path, buffer, offset, end) {
+        const node = this.get('read', path);
+        const raw = encodeRaw(node.textContent.slice(offset, end));
+        buffer.set(raw);
+    }
+    writeSync(path, buffer, offset) {
+        const node = this.get('write', path);
+        const data = decodeRaw(buffer);
+        const after = node.textContent.slice(offset + data.length);
+        node.textContent = node.textContent.slice(0, offset) + data + after;
+    }
     toString() {
         return new XMLSerializer().serializeToString(this.root);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/dom",
-	"version": "1.1.2",
+	"version": "1.1.4",
 	"description": "DOM backends for ZenFS",
 	"funding": {
 		"type": "individual",
@@ -45,14 +45,14 @@
 		"lint": "eslint src",
 		"build": "tsc -p tsconfig.json",
 		"build:docs": "typedoc --out docs --name 'ZenFS DOM' src/index.ts",
-		"test": "echo No tests yet",
+		"test": "npx zenfs-test -abcf",
 		"prepublishOnly": "npm run build"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.12.0",
+		"c8": "^10.1.3",
 		"eslint": "^9.12.0",
 		"fake-indexeddb": "^6.0.0",
-		"file-system-access": "^1.0.4",
 		"globals": "^15.10.0",
 		"prettier": "^3.2.5",
 		"tsx": "^4.19.2",
@@ -61,7 +61,8 @@
 		"typescript-eslint": "^8.8.1"
 	},
 	"peerDependencies": {
-		"@zenfs/core": "^1.7.0"
+		"@zenfs/core": "^1.9.0",
+		"utilium": "^1.2.10"
 	},
 	"keywords": [
 		"filesystem",

package/readme.md

@@ -6,10 +6,10 @@ Please read the ZenFS core documentation!
 
 ## Backends
 
--   `WebStorage` stores files in a `Storage` object, like `localStorage` and `sessionStorage`.
--   `IndexedDB` stores files into an `IndexedDB` object database.
--   `WebAccess` uses the [File System Access API](https://developer.mozilla.org/Web/API/File_System_API).
--   `XML` uses an `XMLDocument` to store files, which can be appended to the DOM.
+- `WebStorage` stores files in a `Storage` object, like `localStorage` and `sessionStorage`.
+- `IndexedDB` stores files into an `IndexedDB` object database.
+- `WebAccess` uses the [File System Access API](https://developer.mozilla.org/Web/API/File_System_API).
+- `XML` uses an `XMLDocument` to store files, which can be appended to the DOM.
 
 For more information, see the [API documentation](https://zen-fs.github.io/dom).
 

package/tsconfig.json

@@ -3,10 +3,11 @@
 		"module": "NodeNext",
 		"target": "ES2020",
 		"outDir": "dist",
-		"lib": ["ESNext", "DOM"],
+		"lib": ["ESNext", "DOM", "ESNext.AsyncIterable", "DOM.AsyncIterable"],
 		"strict": true,
 		"moduleResolution": "NodeNext",
-		"declaration": true
+		"declaration": true,
+		"verbatimModuleSyntax": true
 	},
 	"include": ["src/**/*"],
 	"exclude": ["node_modules"]