@zenfs/core 2.0.0 → 2.1.1

package/dist/backends/store/store.d.ts

@@ -51,7 +51,7 @@ export interface Store {
     /**
      * @internal @hidden
      */
-    _fs?: StoreFS;
+    fs?: StoreFS;
 }
 /**
  * A transaction for a store.
@@ -169,8 +169,8 @@ export declare class WrappedTransaction<T extends Store = Store> {
     keys(): Promise<Iterable<number>>;
     get(id: number, offset?: number, end?: number): Promise<Uint8Array | undefined>;
     getSync(id: number, offset?: number, end?: number): Uint8Array | undefined;
-    set(id: number, data: Uint8Array, offset?: number): Promise<void>;
-    setSync(id: number, data: Uint8Array, offset?: number): void;
+    set(id: number, view: Uint8Array | ArrayBufferView, offset?: number): Promise<void>;
+    setSync(id: number, view: Uint8Array | ArrayBufferView, offset?: number): void;
     remove(id: number): Promise<void>;
     removeSync(id: number): void;
     commit(): Promise<void>;

package/dist/backends/store/store.js

@@ -1,6 +1,6 @@
+import { withErrno } from 'kerium';
+import { warn } from 'kerium/log';
 import { Resource } from 'utilium/cache.js';
-import { ErrnoError } from '../../internal/error.js';
-import { err, warn } from '../../internal/log.js';
 import '../../polyfills.js';
 /**
  * A transaction for a store.
@@ -62,7 +62,6 @@ export class AsyncTransaction extends Transaction {
         return resource;
     }
     getSync(id, offset, end) {
-        var _a;
         const resource = this._cached(id);
         if (!resource)
             return;
@@ -72,7 +71,7 @@ export class AsyncTransaction extends Transaction {
             this.async(this.get(id, start, end));
         }
         if (missing.length)
-            throw err(ErrnoError.With('EAGAIN', (_a = this.store._fs) === null || _a === void 0 ? void 0 : _a._path(id)));
+            throw withErrno('EAGAIN');
         const region = resource.regionAt(offset);
         if (!region) {
             warn('Missing cache region for ' + id);
@@ -130,13 +129,15 @@ export class WrappedTransaction {
         this.stash(id);
         return data;
     }
-    async set(id, data, offset = 0) {
-        await this.markModified(id, offset, data.byteLength);
-        await this.raw.set(id, data, offset);
+    async set(id, view, offset = 0) {
+        await this.markModified(id, offset, view.byteLength);
+        const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        await this.raw.set(id, buffer, offset);
     }
-    setSync(id, data, offset = 0) {
-        this.markModifiedSync(id, offset, data.byteLength);
-        this.raw.setSync(id, data, offset);
+    setSync(id, view, offset = 0) {
+        this.markModifiedSync(id, offset, view.byteLength);
+        const buffer = view instanceof Uint8Array ? view : new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+        this.raw.setSync(id, buffer, offset);
     }
     async remove(id) {
         await this.markModified(id, 0, undefined);

package/dist/config.d.ts

@@ -1,6 +1,6 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
 import type { Device, DeviceDriver } from './internal/devices.js';
-import type { LogConfiguration } from './internal/log.js';
+import { log } from 'kerium';
 /**
  * Configuration for a specific mount point
  * @category Backends and Configuration
@@ -64,7 +64,7 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
     /**
      * Configurations options for the log.
      */
-    log: LogConfiguration;
+    log: log.Configuration;
 }
 /**
  * Configures ZenFS with single mount point /

package/dist/config.js

@@ -1,10 +1,9 @@
+import { log, withErrno } from 'kerium';
 import { checkOptions, isBackend, isBackendConfig } from './backends/backend.js';
 import { defaultContext } from './internal/contexts.js';
 import { createCredentials } from './internal/credentials.js';
 import { DeviceFS } from './internal/devices.js';
-import { Errno, ErrnoError } from './internal/error.js';
 import { FileSystem } from './internal/filesystem.js';
-import { configure as configureLog, crit, err, info } from './internal/log.js';
 import { _setAccessChecks } from './vfs/config.js';
 import * as fs from './vfs/index.js';
 import { mounts } from './vfs/shared.js';
@@ -18,10 +17,10 @@ function isMountConfig(arg) {
  */
 export async function resolveMountConfig(configuration, _depth = 0) {
     if (typeof configuration !== 'object' || configuration == null) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Invalid options on mount configuration'));
+        throw log.err(withErrno('EINVAL', 'Invalid options on mount configuration'));
     }
     if (!isMountConfig(configuration)) {
-        throw err(new ErrnoError(Errno.EINVAL, 'Invalid mount configuration'));
+        throw log.err(withErrno('EINVAL', 'Invalid mount configuration'));
     }
     if (configuration instanceof FileSystem) {
         await configuration.ready();
@@ -35,20 +34,20 @@ export async function resolveMountConfig(configuration, _depth = 0) {
             continue;
         if (!isMountConfig(value))
             continue;
-        info('Resolving nested mount configuration: ' + key);
+        log.info('Resolving nested mount configuration: ' + key);
         if (_depth > 10) {
-            throw err(new ErrnoError(Errno.EINVAL, 'Invalid configuration, too deep and possibly infinite'));
+            throw log.err(withErrno('EINVAL', 'Invalid configuration, too deep and possibly infinite'));
         }
         configuration[key] = await resolveMountConfig(value, ++_depth);
     }
     const { backend } = configuration;
     if (typeof backend.isAvailable == 'function' && !(await backend.isAvailable(configuration))) {
-        throw err(new ErrnoError(Errno.EPERM, 'Backend not available: ' + backend.name));
+        throw log.err(withErrno('EPERM', 'Backend not available: ' + backend.name));
     }
     checkOptions(backend, configuration);
     const mount = (await backend.create(configuration));
     if (configuration.disableAsyncCache)
-        mount.attributes.set('no_async');
+        mount.attributes.set('no_async_preload');
     await mount.ready();
     return mount;
 }
@@ -80,7 +79,7 @@ async function mount(path, mount) {
         await fs.promises.mkdir(path, { recursive: true });
     }
     else if (!stats.isDirectory()) {
-        throw ErrnoError.With('ENOTDIR', path, 'configure');
+        throw withErrno('ENOTDIR', 'Missing directory at mount point: ' + path);
     }
     fs.mount(path, mount);
 }
@@ -90,7 +89,7 @@ async function mount(path, mount) {
 export function addDevice(driver, options) {
     const devfs = mounts.get('/dev');
     if (!(devfs instanceof DeviceFS))
-        throw crit(new ErrnoError(Errno.ENOTSUP, '/dev does not exist or is not a device file system'));
+        throw log.crit(withErrno('ENOTSUP', '/dev does not exist or is not a device file system'));
     return devfs._createDevice(driver, options);
 }
 /**
@@ -105,7 +104,7 @@ export async function configure(configuration) {
     Object.assign(defaultContext.credentials, createCredentials({ uid, gid }));
     _setAccessChecks(!configuration.disableAccessChecks);
     if (configuration.log)
-        configureLog(configuration.log);
+        log.configure(configuration.log);
     if (configuration.mounts) {
         // sort to make sure any root replacement is done first
         for (const [_point, mountConfig] of Object.entries(configuration.mounts).sort(([a], [b]) => (a.length > b.length ? 1 : -1))) {

package/dist/internal/devices.d.ts

@@ -119,8 +119,8 @@ export declare class DeviceFS extends StoreFS<InMemoryStore> {
     readdirSync(path: string): string[];
     link(target: string, link: string): Promise<void>;
     linkSync(target: string, link: string): void;
-    sync(path: string): Promise<void>;
-    syncSync(path: string): void;
+    sync(): Promise<void>;
+    syncSync(): void;
     read(path: string, buffer: Uint8Array, offset: number, end: number): Promise<void>;
     readSync(path: string, buffer: Uint8Array, offset: number, end: number): void;
     write(path: string, data: Uint8Array, offset: number): Promise<void>;

package/dist/internal/devices.js

@@ -1,14 +1,14 @@
 /*
 This is a great resource: https://www.kernel.org/doc/html/latest/admin-guide/devices.html
 */
+import { withErrno } from 'kerium';
+import { debug, err, info } from 'kerium/log';
 import { decodeUTF8, omit } from 'utilium';
 import { InMemoryStore } from '../backends/memory.js';
 import { StoreFS } from '../backends/store/fs.js';
 import { basename, dirname } from '../path.js';
 import { S_IFCHR } from '../vfs/constants.js';
-import { Errno, ErrnoError } from './error.js';
 import { Inode } from './inode.js';
-import { debug, err, info } from './log.js';
 /**
  * A temporary file system that manages and interfaces with devices
  * @category Internals
@@ -16,7 +16,7 @@ import { debug, err, info } from './log.js';
 export class DeviceFS extends StoreFS {
     devicesWithDriver(driver, forceIdentity) {
         if (forceIdentity && typeof driver == 'string') {
-            throw err(new ErrnoError(Errno.EINVAL, 'Can not fetch devices using only a driver name'), { fs: this });
+            throw err(withErrno('EINVAL', 'Can not fetch devices using only a driver name'));
         }
         const devs = [];
         for (const device of this.devices.values()) {
@@ -51,7 +51,7 @@ export class DeviceFS extends StoreFS {
         };
         const path = '/' + (dev.name || driver.name) + (driver.singleton ? '' : this.devicesWithDriver(driver).length);
         if (this.existsSync(path))
-            throw ErrnoError.With('EEXIST', path, 'mknod');
+            throw withErrno('EEXIST');
         this.devices.set(path, dev);
         info('Initialized device: ' + this._mountPoint + path);
         return dev;
@@ -74,21 +74,17 @@ export class DeviceFS extends StoreFS {
         this.devices = new Map();
     }
     async rename(oldPath, newPath) {
-        if (this.devices.has(oldPath)) {
-            throw ErrnoError.With('EPERM', oldPath, 'rename');
-        }
-        if (this.devices.has(newPath)) {
-            throw ErrnoError.With('EEXIST', newPath, 'rename');
-        }
+        if (this.devices.has(oldPath))
+            throw withErrno('EPERM');
+        if (this.devices.has(newPath))
+            throw withErrno('EEXIST');
         return super.rename(oldPath, newPath);
     }
     renameSync(oldPath, newPath) {
-        if (this.devices.has(oldPath)) {
-            throw ErrnoError.With('EPERM', oldPath, 'rename');
-        }
-        if (this.devices.has(newPath)) {
-            throw ErrnoError.With('EEXIST', newPath, 'rename');
-        }
+        if (this.devices.has(oldPath))
+            throw withErrno('EPERM');
+        if (this.devices.has(newPath))
+            throw withErrno('EEXIST');
         return super.renameSync(oldPath, newPath);
     }
     async stat(path) {
@@ -119,24 +115,22 @@ export class DeviceFS extends StoreFS {
     }
     async createFile(path, options) {
         if (this.devices.has(path))
-            throw ErrnoError.With('EEXIST', path, 'createFile');
+            throw withErrno('EEXIST');
         return super.createFile(path, options);
     }
     createFileSync(path, options) {
         if (this.devices.has(path))
-            throw ErrnoError.With('EEXIST', path, 'createFile');
+            throw withErrno('EEXIST');
         return super.createFileSync(path, options);
     }
     async unlink(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EPERM', path, 'unlink');
-        }
+        if (this.devices.has(path))
+            throw withErrno('EPERM');
         return super.unlink(path);
     }
     unlinkSync(path) {
-        if (this.devices.has(path)) {
-            throw ErrnoError.With('EPERM', path, 'unlink');
-        }
+        if (this.devices.has(path))
+            throw withErrno('EPERM');
         return super.unlinkSync(path);
     }
     async rmdir(path) {
@@ -147,12 +141,12 @@ export class DeviceFS extends StoreFS {
     }
     async mkdir(path, options) {
         if (this.devices.has(path))
-            throw ErrnoError.With('EEXIST', path, 'mkdir');
+            throw withErrno('EEXIST');
         return super.mkdir(path, options);
     }
     mkdirSync(path, options) {
         if (this.devices.has(path))
-            throw ErrnoError.With('EEXIST', path, 'mkdir');
+            throw withErrno('EEXIST');
         return super.mkdirSync(path, options);
     }
     async readdir(path) {
@@ -174,36 +168,32 @@ export class DeviceFS extends StoreFS {
         return entries;
     }
     async link(target, link) {
-        if (this.devices.has(target)) {
-            throw ErrnoError.With('EPERM', target, 'rmdir');
-        }
-        if (this.devices.has(link)) {
-            throw ErrnoError.With('EEXIST', link, 'link');
-        }
+        if (this.devices.has(target))
+            throw withErrno('EPERM');
+        if (this.devices.has(link))
+            throw withErrno('EEXIST');
         return super.link(target, link);
     }
     linkSync(target, link) {
-        if (this.devices.has(target)) {
-            throw ErrnoError.With('EPERM', target, 'rmdir');
-        }
-        if (this.devices.has(link)) {
-            throw ErrnoError.With('EEXIST', link, 'link');
-        }
+        if (this.devices.has(target))
+            throw withErrno('EPERM');
+        if (this.devices.has(link))
+            throw withErrno('EEXIST');
         return super.linkSync(target, link);
     }
-    async sync(path) {
+    async sync() {
         var _a, _b;
-        const device = this.devices.get(path);
-        if (device)
-            return (_b = (_a = device.driver).sync) === null || _b === void 0 ? void 0 : _b.call(_a, device);
-        return super.sync(path);
+        for (const device of this.devices.values()) {
+            (_b = (_a = device.driver).sync) === null || _b === void 0 ? void 0 : _b.call(_a, device);
+        }
+        return super.sync();
     }
-    syncSync(path) {
+    syncSync() {
         var _a, _b;
-        const device = this.devices.get(path);
-        if (device)
-            return (_b = (_a = device.driver).sync) === null || _b === void 0 ? void 0 : _b.call(_a, device);
-        return super.syncSync(path);
+        for (const device of this.devices.values()) {
+            (_b = (_a = device.driver).sync) === null || _b === void 0 ? void 0 : _b.call(_a, device);
+        }
+        return super.syncSync();
     }
     async read(path, buffer, offset, end) {
         const device = this.devices.get(path);
@@ -298,7 +288,7 @@ export const fullDevice = {
         buffer.fill(0, offset, end);
     },
     write() {
-        throw ErrnoError.With('ENOSPC', undefined, 'write');
+        throw withErrno('ENOSPC');
     },
 };
 /**

package/dist/internal/error.d.ts

@@ -1,213 +1,18 @@
+import { Exception, type ExceptionJSON } from 'kerium';
 /**
- * Standard libc error codes. More will be added to this enum and error strings as they are
- * needed.
+ * @deprecated Use {@link ExceptionJSON} instead
  * @category Internals
- * @see https://en.wikipedia.org/wiki/Errno.h
  */
-export declare enum Errno {
-    /** Operation not permitted */
-    EPERM = 1,
-    /** No such file or directory */
-    ENOENT = 2,
-    /** Interrupted system call */
-    EINTR = 4,
-    /** Input/output error */
-    EIO = 5,
-    /** No such device or address */
-    ENXIO = 6,
-    /** Bad file descriptor */
-    EBADF = 9,
-    /** Resource temporarily unavailable */
-    EAGAIN = 11,
-    /** Cannot allocate memory */
-    ENOMEM = 12,
-    /** Permission denied */
-    EACCES = 13,
-    /** Bad address */
-    EFAULT = 14,
-    /** Block device required */
-    ENOTBLK = 15,
-    /** Resource busy or locked */
-    EBUSY = 16,
-    /** File exists */
-    EEXIST = 17,
-    /** Invalid cross-device link */
-    EXDEV = 18,
-    /** No such device */
-    ENODEV = 19,
-    /** File is not a directory */
-    ENOTDIR = 20,
-    /** File is a directory */
-    EISDIR = 21,
-    /** Invalid argument */
-    EINVAL = 22,
-    /** Too many open files in system */
-    ENFILE = 23,
-    /** Too many open files */
-    EMFILE = 24,
-    /** Text file busy */
-    ETXTBSY = 26,
-    /** File is too big */
-    EFBIG = 27,
-    /** No space left on disk */
-    ENOSPC = 28,
-    /** Illegal seek */
-    ESPIPE = 29,
-    /** Cannot modify a read-only file system */
-    EROFS = 30,
-    /** Too many links */
-    EMLINK = 31,
-    /** Broken pipe */
-    EPIPE = 32,
-    /** Numerical argument out of domain */
-    EDOM = 33,
-    /** Numerical result out of range */
-    ERANGE = 34,
-    /** Resource deadlock would occur */
-    EDEADLK = 35,
-    /** File name too long */
-    ENAMETOOLONG = 36,
-    /** No locks available */
-    ENOLCK = 37,
-    /** Function not implemented */
-    ENOSYS = 38,
-    /** Directory is not empty */
-    ENOTEMPTY = 39,
-    /** Too many levels of symbolic links */
-    ELOOP = 40,
-    /** No message of desired type */
-    ENOMSG = 42,
-    /** Invalid exchange */
-    EBADE = 52,
-    /** Invalid request descriptor */
-    EBADR = 53,
-    /** Exchange full */
-    EXFULL = 54,
-    /** No anode */
-    ENOANO = 55,
-    /** Invalid request code */
-    EBADRQC = 56,
-    /** Device not a stream */
-    ENOSTR = 60,
-    /** No data available */
-    ENODATA = 61,
-    /** Timer expired */
-    ETIME = 62,
-    /** Out of streams resources */
-    ENOSR = 63,
-    /** Machine is not on the network */
-    ENONET = 64,
-    /** Object is remote */
-    EREMOTE = 66,
-    /** Link has been severed */
-    ENOLINK = 67,
-    /** Communication error on send */
-    ECOMM = 70,
-    /** Protocol error */
-    EPROTO = 71,
-    /** Bad message */
-    EBADMSG = 74,
-    /** Value too large for defined data type */
-    EOVERFLOW = 75,
-    /** File descriptor in bad state */
-    EBADFD = 77,
-    /** Streams pipe error */
-    ESTRPIPE = 86,
-    /** Socket operation on non-socket */
-    ENOTSOCK = 88,
-    /** Destination address required */
-    EDESTADDRREQ = 89,
-    /** Message too long */
-    EMSGSIZE = 90,
-    /** Protocol wrong type for socket */
-    EPROTOTYPE = 91,
-    /** Protocol not available */
-    ENOPROTOOPT = 92,
-    /** Protocol not supported */
-    EPROTONOSUPPORT = 93,
-    /** Socket type not supported */
-    ESOCKTNOSUPPORT = 94,
-    /** Operation is not supported */
-    ENOTSUP = 95,
-    /** Network is down */
-    ENETDOWN = 100,
-    /** Network is unreachable */
-    ENETUNREACH = 101,
-    /** Network dropped connection on reset */
-    ENETRESET = 102,
-    /** Connection timed out */
-    ETIMEDOUT = 110,
-    /** Connection refused */
-    ECONNREFUSED = 111,
-    /** Host is down */
-    EHOSTDOWN = 112,
-    /** No route to host */
-    EHOSTUNREACH = 113,
-    /** Operation already in progress */
-    EALREADY = 114,
-    /** Operation now in progress */
-    EINPROGRESS = 115,
-    /** Stale file handle */
-    ESTALE = 116,
-    /** Remote I/O error */
-    EREMOTEIO = 121,
-    /** Disk quota exceeded */
-    EDQUOT = 122
-}
+export type ErrnoErrorJSON = ExceptionJSON;
 /**
- * Strings associated with each error code.
+ * @deprecated Use {@link Exception} instead
  * @category Internals
- * @internal
  */
-export declare const errorMessages: {
-    [K in Errno]: string;
-};
+export declare const ErrnoError: typeof Exception;
 /**
+ * @deprecated Use {@link Exception} instead
  * @category Internals
  */
-export interface ErrnoErrorJSON {
-    errno: Errno;
-    message: string;
-    path?: string;
-    code: keyof typeof Errno;
-    stack: string;
-    syscall: string;
-}
-/**
- * An error with additional information about what happened
- * @category Internals
- */
-export declare class ErrnoError extends Error implements NodeJS.ErrnoException {
-    /**
-     * The kind of error
-     */
-    errno: Errno;
-    /**
-     * A descriptive error message
-     */
-    message: string;
-    path?: string | undefined;
-    syscall: string;
-    static fromJSON(json: ErrnoErrorJSON): ErrnoError;
-    static With(code: keyof typeof Errno, path?: string, syscall?: string): ErrnoError;
-    code: keyof typeof Errno;
-    stack: string;
-    constructor(
-    /**
-     * The kind of error
-     */
-    errno: Errno, 
-    /**
-     * A descriptive error message
-     */
-    message?: string, path?: string | undefined, syscall?: string);
-    /**
-     * @returns A friendly error message.
-     */
-    toString(): string;
-    toJSON(): ErrnoErrorJSON;
-    /**
-     * The size of the API error in buffer-form in bytes.
-     */
-    bufferSize(): number;
-}
+export type ErrnoError = Exception;
+export declare function withPath<E extends Exception>(e: E, path: string): E;
+export declare function wrap<const FS, const Prop extends keyof FS & string>(fs: FS, prop: Prop, path: string, dest?: string): FS[Prop];