@zenfs/core 1.2.10 → 1.3.1

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

@@ -1,13 +1,12 @@
-import type { Ino } from '../../inode.js';
 import { SyncTransaction, type Store } from './store.js';
 /**
  * An interface for simple synchronous stores that don't have special support for transactions and such.
  */
 export interface SimpleSyncStore extends Store {
-    keys(): Iterable<Ino>;
-    get(ino: Ino): Uint8Array | undefined;
-    set(ino: Ino, data: Uint8Array): void;
-    delete(ino: Ino): void;
+    keys(): Iterable<bigint>;
+    get(id: bigint): Uint8Array | undefined;
+    set(id: bigint, data: Uint8Array): void;
+    delete(id: bigint): void;
 }
 /**
  * An interface for simple asynchronous stores that don't have special support for transactions and such.
@@ -15,15 +14,15 @@ export interface SimpleSyncStore extends Store {
  */
 export declare abstract class SimpleAsyncStore implements SimpleSyncStore {
     abstract name: string;
-    protected cache: Map<Ino, Uint8Array>;
+    protected cache: Map<bigint, Uint8Array>;
     protected queue: Set<Promise<unknown>>;
-    protected abstract entries(): Promise<Iterable<[Ino, Uint8Array]>>;
-    keys(): Iterable<Ino>;
-    get(ino: Ino): Uint8Array | undefined;
-    set(ino: Ino, data: Uint8Array): void;
-    protected abstract _set(ino: Ino, data: Uint8Array): Promise<void>;
-    delete(ino: Ino): void;
-    protected abstract _delete(ino: Ino): Promise<void>;
+    protected abstract entries(): Promise<Iterable<[bigint, Uint8Array]>>;
+    keys(): Iterable<bigint>;
+    get(id: bigint): Uint8Array | undefined;
+    set(id: bigint, data: Uint8Array): void;
+    protected abstract _set(ino: bigint, data: Uint8Array): Promise<void>;
+    delete(id: bigint): void;
+    protected abstract _delete(ino: bigint): Promise<void>;
     clearSync(): void;
     abstract clear(): Promise<void>;
     sync(): Promise<void>;
@@ -39,16 +38,16 @@ export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore>
      * Stores data in the keys we modify prior to modifying them.
      * Allows us to roll back commits.
      */
-    protected originalData: Map<Ino, Uint8Array | void>;
+    protected originalData: Map<bigint, Uint8Array | void>;
     /**
      * List of keys modified in this transaction, if any.
      */
-    protected modifiedKeys: Set<Ino>;
+    protected modifiedKeys: Set<bigint>;
     protected store: SimpleSyncStore;
-    keysSync(): Iterable<Ino>;
-    getSync(ino: Ino): Uint8Array;
-    setSync(ino: Ino, data: Uint8Array): void;
-    removeSync(ino: Ino): void;
+    keysSync(): Iterable<bigint>;
+    getSync(id: bigint): Uint8Array;
+    setSync(id: bigint, data: Uint8Array): void;
+    removeSync(id: bigint): void;
     commitSync(): void;
     abortSync(): void;
     /**
@@ -57,10 +56,10 @@ export declare class SimpleTransaction extends SyncTransaction<SimpleSyncStore>
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    protected stashOldValue(ino: Ino, value?: Uint8Array): void;
+    protected stashOldValue(id: bigint, value?: Uint8Array): void;
     /**
      * Marks `ino` as modified, and stashes its value if it has not been
      * stashed already.
      */
-    protected markModified(ino: Ino): void;
+    protected markModified(id: bigint): void;
 }

package/dist/backends/store/simple.js

@@ -11,16 +11,16 @@ export class SimpleAsyncStore {
     keys() {
         return this.cache.keys();
     }
-    get(ino) {
-        return this.cache.get(ino);
+    get(id) {
+        return this.cache.get(id);
     }
-    set(ino, data) {
-        this.cache.set(ino, data);
-        this.queue.add(this._set(ino, data));
+    set(id, data) {
+        this.cache.set(id, data);
+        this.queue.add(this._set(id, data));
     }
-    delete(ino) {
-        this.cache.delete(ino);
-        this.queue.add(this._delete(ino));
+    delete(id) {
+        this.cache.delete(id);
+        this.queue.add(this._delete(id));
     }
     clearSync() {
         this.cache.clear();
@@ -61,18 +61,18 @@ export class SimpleTransaction extends SyncTransaction {
     keysSync() {
         return this.store.keys();
     }
-    getSync(ino) {
-        const val = this.store.get(ino);
-        this.stashOldValue(ino, val);
+    getSync(id) {
+        const val = this.store.get(id);
+        this.stashOldValue(id, val);
         return val;
     }
-    setSync(ino, data) {
-        this.markModified(ino);
-        return this.store.set(ino, data);
+    setSync(id, data) {
+        this.markModified(id);
+        return this.store.set(id, data);
     }
-    removeSync(ino) {
-        this.markModified(ino);
-        this.store.delete(ino);
+    removeSync(id) {
+        this.markModified(id);
+        this.store.delete(id);
     }
     commitSync() {
         this.done = true;
@@ -101,20 +101,20 @@ export class SimpleTransaction extends SyncTransaction {
      * prevent needless `get` requests if the program modifies the data later
      * on during the transaction.
      */
-    stashOldValue(ino, value) {
+    stashOldValue(id, value) {
         // Keep only the earliest value in the transaction.
-        if (!this.originalData.has(ino)) {
-            this.originalData.set(ino, value);
+        if (!this.originalData.has(id)) {
+            this.originalData.set(id, value);
         }
     }
     /**
      * Marks `ino` as modified, and stashes its value if it has not been
      * stashed already.
      */
-    markModified(ino) {
-        this.modifiedKeys.add(ino);
-        if (!this.originalData.has(ino)) {
-            this.originalData.set(ino, this.store.get(ino));
+    markModified(id) {
+        this.modifiedKeys.add(id);
+        if (!this.originalData.has(id)) {
+            this.originalData.set(id, this.store.get(id));
         }
     }
 }

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

@@ -1,4 +1,3 @@
-import type { Ino } from '../../inode.js';
 import '../../polyfills.js';
 /**
  * Represents a key-value store.
@@ -38,45 +37,45 @@ export declare abstract class Transaction<T extends Store = Store> {
     /**
      * Gets all of the keys
      */
-    abstract keys(): Promise<Iterable<Ino>>;
+    abstract keys(): Promise<Iterable<bigint>>;
     /**
      * Gets all of the keys
      */
-    abstract keysSync(): Iterable<Ino>;
+    abstract keysSync(): Iterable<bigint>;
     /**
-     * Retrieves the data at `ino`.
-     * @param ino The key to look under for data.
+     * Retrieves data.
+     * @param id The key to look under for data.
      */
-    abstract get(ino: Ino): Promise<Uint8Array>;
+    abstract get(id: bigint): Promise<Uint8Array>;
     /**
-     * Retrieves the data at `ino`.
+     * Retrieves data.
      * Throws an error if an error occurs or if the key does not exist.
-     * @param ino The key to look under for data.
+     * @param id The key to look under for data.
      * @return The data stored under the key, or undefined if not present.
      */
-    abstract getSync(ino: Ino): Uint8Array;
+    abstract getSync(id: bigint): Uint8Array;
     /**
-     * Adds the data to the store under `ino`. Overwrites any existing data.
-     * @param ino The key to add the data under.
+     * Adds the data to the store under an id. Overwrites any existing data.
+     * @param id The key to add the data under.
      * @param data The data to add to the store.
      */
-    abstract set(ino: Ino, data: Uint8Array): Promise<void>;
+    abstract set(id: bigint, data: Uint8Array): Promise<void>;
     /**
-     * Adds the data to the store under `ino`.
-     * @param ino The key to add the data under.
+     * Adds the data to the store under and id.
+     * @param id The key to add the data under.
      * @param data The data to add to the store.
      */
-    abstract setSync(ino: Ino, data: Uint8Array): void;
+    abstract setSync(id: bigint, data: Uint8Array): void;
     /**
      * Deletes the data at `ino`.
-     * @param ino The key to delete from the store.
+     * @param id The key to delete from the store.
      */
-    abstract remove(ino: Ino): Promise<void>;
+    abstract remove(id: bigint): Promise<void>;
     /**
      * Deletes the data at `ino`.
-     * @param ino The key to delete from the store.
+     * @param id The key to delete from the store.
      */
-    abstract removeSync(ino: Ino): void;
+    abstract removeSync(id: bigint): void;
     /**
      * Commits the transaction.
      */
@@ -100,10 +99,10 @@ export declare abstract class Transaction<T extends Store = Store> {
  * Transaction that implements asynchronous operations with synchronous ones
  */
 export declare abstract class SyncTransaction<T extends Store = Store> extends Transaction<T> {
-    keys(): Promise<Iterable<Ino>>;
-    get(ino: Ino): Promise<Uint8Array>;
-    set(ino: bigint, data: Uint8Array): Promise<void>;
-    remove(ino: Ino): Promise<void>;
+    keys(): Promise<Iterable<bigint>>;
+    get(id: bigint): Promise<Uint8Array>;
+    set(id: bigint, data: Uint8Array): Promise<void>;
+    remove(id: bigint): Promise<void>;
     commit(): Promise<void>;
     abort(): Promise<void>;
 }

package/dist/backends/store/store.js

@@ -32,14 +32,14 @@ export class SyncTransaction extends Transaction {
     async keys() {
         return this.keysSync();
     }
-    async get(ino) {
-        return this.getSync(ino);
+    async get(id) {
+        return this.getSync(id);
     }
-    async set(ino, data) {
-        return this.setSync(ino, data);
+    async set(id, data) {
+        return this.setSync(id, data);
     }
-    async remove(ino) {
-        return this.removeSync(ino);
+    async remove(id) {
+        return this.removeSync(id);
     }
     async commit() {
         return this.commitSync();

package/dist/config.d.ts

@@ -45,6 +45,14 @@ export interface Configuration<T extends ConfigMounts> extends SharedConfig {
      * @default false
      */
     cacheStats: boolean;
+    /**
+     * If true, enables caching realpath output
+     *
+     * This can increase performance.
+     * @experimental
+     * @default false
+     */
+    cachePaths: boolean;
     /**
      * If true, disables *all* permissions checking.
      *

package/dist/config.js

@@ -88,33 +88,33 @@ export async function configure(configuration) {
     const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
     const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
     Object.assign(credentials, { uid, gid, suid: uid, sgid: gid, euid: uid, egid: gid });
-    cache.setEnabled(configuration.cacheStats ?? false);
+    cache.stats.isEnabled = configuration.cacheStats ?? false;
+    cache.paths.isEnabled = configuration.cachePaths ?? false;
     config.checkAccess = !configuration.disableAccessChecks;
     config.updateOnRead = !configuration.disableUpdateOnRead;
     config.syncImmediately = !configuration.onlySyncOnClose;
+    if (configuration.mounts) {
+        const toMount = [];
+        let unmountRoot = false;
+        for (const [point, mountConfig] of Object.entries(configuration.mounts)) {
+            if (!point.startsWith('/')) {
+                throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
+            }
+            if (isBackendConfig(mountConfig)) {
+                mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
+            }
+            if (point == '/')
+                unmountRoot = true;
+            toMount.push([point, await resolveMountConfig(mountConfig)]);
+        }
+        if (unmountRoot)
+            fs.umount('/');
+        await Promise.all(toMount.map(([point, fs]) => mount(point, fs)));
+    }
     if (configuration.addDevices) {
         const devfs = new DeviceFS();
         devfs.addDefaults();
         await devfs.ready();
         await mount('/dev', devfs);
     }
-    if (!configuration.mounts) {
-        return;
-    }
-    const toMount = [];
-    let unmountRoot = false;
-    for (const [point, mountConfig] of Object.entries(configuration.mounts)) {
-        if (!point.startsWith('/')) {
-            throw new ErrnoError(Errno.EINVAL, 'Mount points must have absolute paths');
-        }
-        if (isBackendConfig(mountConfig)) {
-            mountConfig.disableAsyncCache ?? (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
-        }
-        if (point == '/')
-            unmountRoot = true;
-        toMount.push([point, await resolveMountConfig(mountConfig)]);
-    }
-    if (unmountRoot)
-        fs.umount('/');
-    await Promise.all(toMount.map(([point, fs]) => mount(point, fs)));
 }

package/dist/devices.d.ts

@@ -4,7 +4,6 @@ import { StoreFS } from './backends/store/fs.js';
 import { File } from './file.js';
 import type { StatsLike } from './stats.js';
 import { Stats } from './stats.js';
-import type { Ino } from './inode.js';
 /**
  * A device
  * @todo Maybe add major/minor number or some other device information, like a UUID?
@@ -19,7 +18,7 @@ export interface Device<TData = any> {
     /**
      * Which inode the device is assigned
      */
-    ino: Ino;
+    ino: bigint;
     /**
      * Data associated with a device.
      * This is meant to be used by device drivers.
@@ -55,7 +54,7 @@ export interface DeviceDriver<TData = any> {
      * @returns `Device.data`
      * @experimental
      */
-    init?(ino: Ino): {
+    init?(ino: bigint): {
         data?: TData;
         minor?: number;
         major?: number;

package/dist/emulation/cache.d.ts

@@ -1,33 +1,42 @@
 import type { Stats } from '../stats.js';
 /**
- * Whether the cache is enabled
- */
-export declare let isEnabled: boolean;
-/**
- * Sets whether the cache is enabled or not
- */
-export declare function setEnabled(value: boolean): void;
-/**
- * Gets stats from the cache, if they exist and the cache is enabled.
- */
-export declare function getStatsSync(path: string): Stats | undefined;
-/**
- * Adds stats if the cache is enabled
- */
-export declare function setStatsSync(path: string, value: Stats): void;
-/**
- * Clears the cache if it is enabled
- */
-export declare function clearStatsSync(): void;
-/**
- * Gets stats from the cache, if they exist and the cache is enabled.
- */
-export declare function getStats(path: string): Promise<Stats | undefined> | undefined;
-/**
- * Adds stats if the cache is enabled
- */
-export declare function setStats(path: string, value: Promise<Stats | undefined>): void;
-/**
- * Clears the cache if it is enabled
- */
-export declare function clearStats(): void;
+ * Used for caching data
+ * @internal
+ */
+export declare class Cache<T> {
+    isEnabled: boolean;
+    protected sync: Map<string, T>;
+    protected async: Map<string, Promise<T>>;
+    /**
+     * Gets data from the cache, if is exists and the cache is enabled.
+     */
+    getSync(path: string): T | undefined;
+    /**
+     * Adds data if the cache is enabled
+     */
+    setSync(path: string, value: T): void;
+    /**
+     * Clears the cache if it is enabled
+     */
+    clearSync(): void;
+    /**
+     * Gets data from the cache, if it exists and the cache is enabled.
+     */
+    get(path: string): Promise<T> | undefined;
+    /**
+     * Adds data if the cache is enabled
+     */
+    set(path: string, value: Promise<T>): void;
+    /**
+     * Clears the cache if it is enabled
+     */
+    clear(): void;
+}
+/**
+ * Used to cache
+ */
+export declare const stats: Cache<Stats>;
+/**
+ * Used to cache realpath lookups
+ */
+export declare const paths: Cache<string>;

package/dist/emulation/cache.js

@@ -1,61 +1,70 @@
 /* Experimental caching */
 /**
- * Whether the cache is enabled
+ * Used for caching data
+ * @internal
  */
-export let isEnabled = false;
-/**
- * Sets whether the cache is enabled or not
- */
-export function setEnabled(value) {
-    isEnabled = value;
-}
-const statsSync = new Map();
-/**
- * Gets stats from the cache, if they exist and the cache is enabled.
- */
-export function getStatsSync(path) {
-    if (!isEnabled)
-        return;
-    return statsSync.get(path);
-}
-/**
- * Adds stats if the cache is enabled
- */
-export function setStatsSync(path, value) {
-    if (!isEnabled)
-        return;
-    statsSync.set(path, value);
+export class Cache {
+    constructor() {
+        this.isEnabled = false;
+        this.sync = new Map();
+        this.async = new Map();
+    }
+    /**
+     * Gets data from the cache, if is exists and the cache is enabled.
+     */
+    getSync(path) {
+        if (!this.isEnabled)
+            return;
+        return this.sync.get(path);
+    }
+    /**
+     * Adds data if the cache is enabled
+     */
+    setSync(path, value) {
+        if (!this.isEnabled)
+            return;
+        this.sync.set(path, value);
+        this.async.set(path, Promise.resolve(value));
+    }
+    /**
+     * Clears the cache if it is enabled
+     */
+    clearSync() {
+        if (!this.isEnabled)
+            return;
+        this.sync.clear();
+    }
+    /**
+     * Gets data from the cache, if it exists and the cache is enabled.
+     */
+    get(path) {
+        if (!this.isEnabled)
+            return;
+        return this.async.get(path);
+    }
+    /**
+     * Adds data if the cache is enabled
+     */
+    set(path, value) {
+        if (!this.isEnabled)
+            return;
+        this.async.set(path, value);
+        void value.then(v => this.sync.set(path, v));
+    }
+    /**
+     * Clears the cache if it is enabled
+     */
+    clear() {
+        if (!this.isEnabled)
+            return;
+        this.async.clear();
+    }
 }
 /**
- * Clears the cache if it is enabled
+ * Used to cache
  */
-export function clearStatsSync() {
-    if (!isEnabled)
-        return;
-    statsSync.clear();
-}
-const stats = new Map();
-/**
- * Gets stats from the cache, if they exist and the cache is enabled.
- */
-export function getStats(path) {
-    if (!isEnabled)
-        return;
-    return stats.get(path);
-}
+export const stats = new Cache();
 /**
- * Adds stats if the cache is enabled
+ * Used to cache realpath lookups
  */
-export function setStats(path, value) {
-    if (!isEnabled)
-        return;
-    stats.set(path, value);
-}
-/**
- * Clears the cache if it is enabled
- */
-export function clearStats() {
-    if (!isEnabled)
-        return;
-    stats.clear();
-}
+export const paths = new Cache();

package/dist/emulation/index.d.ts

@@ -4,5 +4,5 @@ export * as promises from './promises.js';
 export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
-export { mountObject, mounts, mount, umount } from './shared.js';
+export { mountObject, mounts, mount, umount, _synced } from './shared.js';
 export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';

package/dist/emulation/index.js

@@ -4,5 +4,5 @@ export * as promises from './promises.js';
 export * as constants from './constants.js';
 export * from './streams.js';
 export * from './dir.js';
-export { mountObject, mounts, mount, umount } from './shared.js';
+export { mountObject, mounts, mount, umount, _synced } from './shared.js';
 export { Stats, StatsFs, BigIntStatsFs } from '../stats.js';