@zenfs/core 1.2.9 → 1.3.0

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,7 +88,8 @@ 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;

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

package/dist/emulation/promises.js

@@ -435,7 +435,7 @@ export async function unlink(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(await (cache.getStats(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(await (cache.stats.get(path) || fs.stat(resolved))).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         await fs.unlink(resolved);
@@ -583,7 +583,7 @@ export async function rmdir(path) {
     path = await realpath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        const stats = await (cache.getStats(path) || fs.stat(resolved));
+        const stats = await (cache.stats.get(path) || fs.stat(resolved));
         if (!stats) {
             throw ErrnoError.With('ENOENT', path, 'rmdir');
         }
@@ -642,8 +642,8 @@ export async function readdir(path, options) {
         throw fixError(e, { [resolved]: path });
     };
     const { fs, path: resolved } = resolveMount(path);
-    const _stats = cache.getStats(path) || fs.stat(resolved).catch(handleError);
-    cache.setStats(path, _stats);
+    const _stats = cache.stats.get(path) || fs.stat(resolved).catch(handleError);
+    cache.stats.set(path, _stats);
     const stats = await _stats;
     if (!stats) {
         throw ErrnoError.With('ENOENT', path, 'readdir');
@@ -659,8 +659,8 @@ export async function readdir(path, options) {
     const addEntry = async (entry) => {
         let entryStats;
         if (options?.recursive || options?.withFileTypes) {
-            const _entryStats = cache.getStats(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
-            cache.setStats(join(path, entry), _entryStats);
+            const _entryStats = cache.stats.get(join(path, entry)) || fs.stat(join(resolved, entry)).catch(handleError);
+            cache.stats.set(join(path, entry), _entryStats);
             entryStats = await _entryStats;
         }
         if (options?.withFileTypes) {
@@ -690,7 +690,7 @@ export async function readdir(path, options) {
     };
     await Promise.all(entries.map(addEntry));
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.stats.clear();
     }
     return values;
 }
@@ -881,14 +881,16 @@ lutimes;
 export async function realpath(path, options) {
     path = normalizePath(path);
     const { base, dir } = parse(path);
-    const lpath = join(dir == '/' ? '/' : await realpath(dir), base);
+    const lpath = join(dir == '/' ? '/' : await (cache.paths.get(dir) || realpath(dir)), base);
     const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
     try {
-        const stats = await fs.stat(resolvedPath);
-        if (!stats.isSymbolicLink()) {
+        const _stats = cache.stats.get(lpath) || fs.stat(resolvedPath);
+        cache.stats.set(lpath, _stats);
+        if (!(await _stats).isSymbolicLink()) {
             return lpath;
         }
-        return await realpath(mountPoint + (await readlink(lpath)));
+        const target = mountPoint + (await readlink(lpath));
+        return await (cache.paths.get(target) || realpath(target));
     }
     catch (e) {
         if (e.code == 'ENOENT') {
@@ -943,17 +945,16 @@ access;
  */
 export async function rm(path, options) {
     path = normalizePath(path);
-    const _stats = cache.getStats(path) ||
+    const stats = await (cache.stats.get(path) ||
         stat(path).catch((error) => {
             if (error.code == 'ENOENT' && options?.force)
                 return undefined;
             throw error;
-        });
-    cache.setStats(path, _stats);
-    const stats = await _stats;
+        }));
     if (!stats) {
         return;
     }
+    cache.stats.setSync(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -972,11 +973,11 @@ export async function rm(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.clearStats();
+            cache.stats.clear();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
     if (!options?._isIndirect) {
-        cache.clearStats();
+        cache.stats.clear();
     }
 }
 rm;

package/dist/emulation/shared.d.ts

@@ -28,6 +28,12 @@ export declare function resolveMount(path: string): {
     path: string;
     mountPoint: string;
 };
+/**
+ * Wait for all file systems to be ready and synced.
+ * May be removed at some point.
+ * @experimental @internal
+ */
+export declare function _synced(): Promise<void>;
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
  * @hidden