@zenfs/core 1.11.4 → 2.0.0

package/dist/backends/backend.d.ts

@@ -1,6 +1,9 @@
 import type { RequiredKeys } from 'utilium';
 import type { FileSystem } from '../internal/filesystem.js';
-type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | (abstract new (...args: any[]) => any);
+type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | string | ((arg: any) => boolean) | {
+    [Symbol.hasInstance](instance: any): boolean;
+    toString(): string;
+};
 /**
  * Resolves the type of Backend.options from the options interface
  * @category Backends and Configuration
@@ -8,24 +11,17 @@ type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undef
 export type OptionsConfig<T> = {
     [K in keyof T]: {
         /**
-         * The basic JavaScript type(s) for this option.
+         * The type of the option. Can be a:
+         * - string given by `typeof`
+         * - string that is the name of the class (e.g. `'Map'`)
+         * - object with a `Symbol.hasInstance` property
+         * - function that returns a boolean
          */
         type: OptionType | readonly OptionType[];
-        /**
-         * Description of the option. Used in error messages and documentation.
-         * @deprecated
-         */
-        description?: string;
         /**
          * Whether or not the option is required (optional can be set to null or undefined). Defaults to false.
          */
         required: K extends RequiredKeys<T> ? true : false;
-        /**
-         * A custom validation function to check if the option is valid.
-         * When async, resolves if valid and rejects if not.
-         * When sync, it will throw an error if not valid.
-         */
-        validator?(opt: T[K]): void | Promise<void>;
     };
 };
 /**
@@ -64,7 +60,7 @@ export interface Backend<FS extends FileSystem = FileSystem, TOptions extends ob
      * 'false' if the API is unavailable
      *
      */
-    isAvailable?(): boolean | Promise<boolean>;
+    isAvailable?(config: TOptions): boolean | Promise<boolean>;
 }
 /**
  * Gets the options type of a backend
@@ -83,12 +79,20 @@ export type FilesystemOf<T extends Backend> = T extends Backend<infer FS> ? FS :
  * @internal
  */
 export declare function isBackend(arg: unknown): arg is Backend;
+/**
+ * Use a function as the type of an option, but don't treat it as a class.
+ *
+ * Optionally sets the name of a function, useful for error messages.
+ * @category Backends and Configuration
+ * @internal
+ */
+export declare function _fnOpt<const T>(name: string | null | undefined, fn: (arg: T) => boolean): (arg: T) => boolean;
 /**
  * Checks that `options` object is valid for the file system options.
  * @category Backends and Configuration
  * @internal
  */
-export declare function checkOptions<T extends Backend>(backend: T, options: Record<string, unknown>): Promise<void>;
+export declare function checkOptions<T extends Backend>(backend: T, options: Record<string, unknown>): void;
 /**
  * Specifies a file system backend type and its options.
  *

package/dist/backends/backend.js

@@ -7,12 +7,25 @@ import { debug, err } from '../internal/log.js';
 export function isBackend(arg) {
     return arg != null && typeof arg == 'object' && 'create' in arg && typeof arg.create == 'function';
 }
+/**
+ * Use a function as the type of an option, but don't treat it as a class.
+ *
+ * Optionally sets the name of a function, useful for error messages.
+ * @category Backends and Configuration
+ * @internal
+ */
+export function _fnOpt(name, fn) {
+    Object.defineProperty(fn, 'prototype', { value: undefined });
+    if (name)
+        Object.defineProperty(fn, 'name', { value: name });
+    return fn;
+}
 /**
  * Checks that `options` object is valid for the file system options.
  * @category Backends and Configuration
  * @internal
  */
-export async function checkOptions(backend, options) {
+export function checkOptions(backend, options) {
     if (typeof options != 'object' || options === null) {
         throw err(new ErrnoError(Errno.EINVAL, 'Invalid options'));
     }
@@ -21,24 +34,27 @@ export async function checkOptions(backend, options) {
         const value = options === null || options === void 0 ? void 0 : options[optName];
         if (value === undefined || value === null) {
             if (!opt.required) {
-                debug('Missing non-required option: ' + optName);
+                debug('Using default for option: ' + optName);
                 continue;
             }
             throw err(new ErrnoError(Errno.EINVAL, 'Missing required option: ' + optName));
         }
-        const isType = (type, _ = value) => (typeof type == 'function' ? value instanceof type : typeof value === type);
-        if (Array.isArray(opt.type) ? !opt.type.some(v => isType(v)) : !isType(opt.type)) {
-            // The type of the value as a string
-            const type = typeof value == 'object' && 'constructor' in value ? value.constructor.name : typeof value;
-            // The expected type (as a string)
-            const name = (type) => (typeof type == 'function' ? type.name : type);
-            const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
-            throw err(new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`));
-        }
-        debug('Using custom validator for option: ' + optName);
-        if (opt.validator)
-            await opt.validator(value);
-        // Otherwise: All good!
+        const isType = (type, _ = value) => {
+            var _a;
+            return typeof type == 'function'
+                ? Symbol.hasInstance in type && type.prototype
+                    ? value instanceof type
+                    : type(value)
+                : typeof value === type || ((_a = value === null || value === void 0 ? void 0 : value.constructor) === null || _a === void 0 ? void 0 : _a.name) === type;
+        };
+        if (Array.isArray(opt.type) ? opt.type.some(v => isType(v)) : isType(opt.type))
+            continue;
+        // The type of the value as a string
+        const type = typeof value == 'object' && 'constructor' in value ? value.constructor.name : typeof value;
+        // The expected type (as a string)
+        const name = (type) => (typeof type == 'function' ? (type.name != 'type' ? type.name : type.toString()) : type);
+        const expected = Array.isArray(opt.type) ? `one of ${opt.type.map(name).join(', ')}` : name(opt.type);
+        throw err(new ErrnoError(Errno.EINVAL, `Incorrect type for "${optName}": ${type} (expected ${expected})`));
     }
 }
 /**

package/dist/backends/cow.d.ts

@@ -1,10 +1,8 @@
-import type { File } from '../internal/file.js';
 import type { CreationOptions, StreamOptions, UsageInfo } from '../internal/filesystem.js';
 import type { InodeLike } from '../internal/inode.js';
-import type { Stats } from '../stats.js';
-import { FileSystem } from '../internal/filesystem.js';
 import { EventEmitter } from 'eventemitter3';
 import { type MountConfiguration } from '../config.js';
+import { FileSystem } from '../internal/filesystem.js';
 /**
  * Configuration options for CoW.
  * @category Backends and Configuration
@@ -17,16 +15,14 @@ export interface CopyOnWriteOptions {
     /** @see {@link Journal} */
     journal?: Journal;
 }
-/**
- *  @hidden @deprecated use `CopyOnWriteOptions`
- */
-export type OverlayOptions = CopyOnWriteOptions;
 declare const journalOperations: readonly ["delete"];
 /**
+ * @category Internals
  * @internal
  */
 export type JournalOperation = (typeof journalOperations)[number];
 /**
+ * @category Internals
  * @internal
  */
 export interface JournalEntry {
@@ -35,6 +31,7 @@ export interface JournalEntry {
 }
 /**
  * Tracks various operations for the CoW backend
+ * @category Internals
  * @internal
  */
 export declare class Journal extends EventEmitter<{
@@ -54,6 +51,7 @@ export declare class Journal extends EventEmitter<{
 /**
  * Using a readable file system as a base, writes are done to a writable file system.
  * @internal
+ * @category Internals
  */
 export declare class CopyOnWriteFS extends FileSystem {
     /** The file system that initially populates this file system. */
@@ -75,28 +73,28 @@ export declare class CopyOnWriteFS extends FileSystem {
      * @todo Consider trying to track information on the writable as well
      */
     usage(): UsageInfo;
-    sync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<InodeLike>): void;
+    sync(path: string): Promise<void>;
+    syncSync(path: string): 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, buffer: Uint8Array, offset: number): Promise<void>;
     writeSync(path: string, buffer: Uint8Array, offset: number): void;
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
-    stat(path: string): Promise<Stats>;
-    statSync(path: string): Stats;
-    openFile(path: string, flag: string): Promise<File>;
-    openFileSync(path: string, flag: string): File;
-    createFile(path: string, flag: string, mode: number, options: CreationOptions): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, options: CreationOptions): File;
+    stat(path: string): Promise<InodeLike>;
+    statSync(path: string): InodeLike;
+    touch(path: string, metadata: InodeLike): Promise<void>;
+    touchSync(path: string, metadata: InodeLike): void;
+    createFile(path: string, options: CreationOptions): Promise<InodeLike>;
+    createFileSync(path: string, options: CreationOptions): InodeLike;
     link(srcpath: string, dstpath: string): Promise<void>;
     linkSync(srcpath: string, dstpath: string): void;
     unlink(path: string): Promise<void>;
     unlinkSync(path: string): void;
     rmdir(path: string): Promise<void>;
     rmdirSync(path: string): void;
-    mkdir(path: string, mode: number, options: CreationOptions): Promise<void>;
-    mkdirSync(path: string, mode: number, options: CreationOptions): void;
+    mkdir(path: string, options: CreationOptions): Promise<InodeLike>;
+    mkdirSync(path: string, options: CreationOptions): InodeLike;
     readdir(path: string): Promise<string[]>;
     readdirSync(path: string): string[];
     streamRead(path: string, options: StreamOptions): ReadableStream;
@@ -125,11 +123,6 @@ export declare class CopyOnWriteFS extends FileSystem {
     private copyToWritableSync;
     private copyToWritable;
 }
-/**
- * @hidden @deprecated use `CopyOnWriteFS`
- */
-export declare class OverlayFS extends CopyOnWriteFS {
-}
 declare const _CopyOnWrite: {
     readonly name: "CopyOnWrite";
     readonly options: {
@@ -149,21 +142,18 @@ declare const _CopyOnWrite: {
     readonly create: (options: CopyOnWriteOptions) => Promise<CopyOnWriteFS>;
 };
 type _CopyOnWrite = typeof _CopyOnWrite;
-export interface CopyOnWrite extends _CopyOnWrite {
-}
 /**
  * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
  * Deletes are persisted via metadata stored on the writable file system.
  * @category Backends and Configuration
- * @internal
  */
-export declare const CopyOnWrite: CopyOnWrite;
-export interface Overlay extends _CopyOnWrite {
+export interface CopyOnWrite extends _CopyOnWrite {
 }
 /**
- * @deprecated Use `CopyOnWrite`
+ * Overlay makes a read-only filesystem writable by storing writes on a second, writable file system.
+ * Deletes are persisted via metadata stored on the writable file system.
  * @category Backends and Configuration
- * @internal @hidden
+ * @internal
  */
-export declare const Overlay: Overlay;
+export declare const CopyOnWrite: CopyOnWrite;
 export {};

package/dist/backends/cow.js

@@ -1,63 +1,11 @@
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
+import { EventEmitter } from 'eventemitter3';
 import { canary } from 'utilium';
+import { resolveMountConfig } from '../config.js';
 import { Errno, ErrnoError } from '../internal/error.js';
-import { LazyFile } from '../internal/file.js';
 import { FileSystem } from '../internal/filesystem.js';
+import { isDirectory } from '../internal/inode.js';
 import { debug, err, warn } from '../internal/log.js';
-import { dirname, join } from '../vfs/path.js';
-import { EventEmitter } from 'eventemitter3';
-import { resolveMountConfig } from '../config.js';
+import { dirname, join } from '../path.js';
 const journalOperations = ['delete'];
 /** Because TS doesn't work right w/o it */
 function isJournalOp(op) {
@@ -67,6 +15,7 @@ const maxOpLength = Math.max(...journalOperations.map(op => op.length));
 const journalMagicString = '#journal@v0\n';
 /**
  * Tracks various operations for the CoW backend
+ * @category Internals
  * @internal
  */
 export class Journal extends EventEmitter {
@@ -123,6 +72,7 @@ export class Journal extends EventEmitter {
 /**
  * Using a readable file system as a base, writes are done to a writable file system.
  * @internal
+ * @category Internals
  */
 export class CopyOnWriteFS extends FileSystem {
     async ready() {
@@ -154,13 +104,13 @@ export class CopyOnWriteFS extends FileSystem {
     usage() {
         return this.readable.usage();
     }
-    async sync(path, data, stats) {
+    async sync(path) {
         await this.copyForWrite(path);
-        await this.writable.sync(path, data, stats);
+        await this.writable.sync(path);
     }
-    syncSync(path, data, stats) {
+    syncSync(path) {
         this.copyForWriteSync(path);
-        this.writable.syncSync(path, data, stats);
+        this.writable.syncSync(path);
     }
     async read(path, buffer, offset, end) {
         return (await this.writable.exists(path))
@@ -226,27 +176,21 @@ export class CopyOnWriteFS extends FileSystem {
             return oldStat;
         }
     }
-    async openFile(path, flag) {
-        if (await this.writable.exists(path)) {
-            return this.writable.openFile(path, flag);
-        }
-        const stats = await this.readable.stat(path);
-        return new LazyFile(this, path, flag, stats);
+    async touch(path, metadata) {
+        await this.copyForWrite(path);
+        await this.writable.touch(path, metadata);
     }
-    openFileSync(path, flag) {
-        if (this.writable.existsSync(path)) {
-            return this.writable.openFileSync(path, flag);
-        }
-        const stats = this.readable.statSync(path);
-        return new LazyFile(this, path, flag, stats);
+    touchSync(path, metadata) {
+        this.copyForWriteSync(path);
+        this.writable.touchSync(path, metadata);
     }
-    async createFile(path, flag, mode, options) {
-        await this.writable.createFile(path, flag, mode, options);
-        return this.openFile(path, flag);
+    async createFile(path, options) {
+        await this.createParentDirectories(path);
+        return await this.writable.createFile(path, options);
     }
-    createFileSync(path, flag, mode, options) {
-        this.writable.createFileSync(path, flag, mode, options);
-        return this.openFileSync(path, flag);
+    createFileSync(path, options) {
+        this.createParentDirectoriesSync(path);
+        return this.writable.createFileSync(path, options);
     }
     async link(srcpath, dstpath) {
         await this.copyForWrite(srcpath);
@@ -311,17 +255,17 @@ export class CopyOnWriteFS extends FileSystem {
         }
         this.journal.add('delete', path);
     }
-    async mkdir(path, mode, options) {
+    async mkdir(path, options) {
         if (await this.exists(path))
             throw ErrnoError.With('EEXIST', path, 'mkdir');
         await this.createParentDirectories(path);
-        await this.writable.mkdir(path, mode, options);
+        return await this.writable.mkdir(path, options);
     }
-    mkdirSync(path, mode, options) {
+    mkdirSync(path, options) {
         if (this.existsSync(path))
             throw ErrnoError.With('EEXIST', path, 'mkdir');
         this.createParentDirectoriesSync(path);
-        this.writable.mkdirSync(path, mode, options);
+        return this.writable.mkdirSync(path, options);
     }
     async readdir(path) {
         if (this.isDeleted(path) || !(await this.exists(path)))
@@ -366,8 +310,7 @@ export class CopyOnWriteFS extends FileSystem {
         if (toCreate.length)
             debug('COW: Creating parent directories: ' + toCreate.join(', '));
         for (const path of toCreate.reverse()) {
-            const { uid, gid, mode } = this.statSync(path);
-            this.writable.mkdirSync(path, mode, { uid, gid });
+            this.writable.mkdirSync(path, this.statSync(path));
         }
     }
     /**
@@ -384,8 +327,7 @@ export class CopyOnWriteFS extends FileSystem {
         if (toCreate.length)
             debug('COW: Creating parent directories: ' + toCreate.join(', '));
         for (const path of toCreate.reverse()) {
-            const { uid, gid, mode } = await this.stat(path);
-            await this.writable.mkdir(path, mode, { uid, gid });
+            await this.writable.mkdir(path, await this.stat(path));
         }
     }
     /**
@@ -420,64 +362,38 @@ export class CopyOnWriteFS extends FileSystem {
      * PRECONDITION: File does not exist on writable storage.
      */
     copyToWritableSync(path) {
-        const env_1 = { stack: [], error: void 0, hasError: false };
-        try {
-            const stats = this.statSync(path);
-            stats.mode |= 0o222;
-            if (stats.isDirectory()) {
-                this.writable.mkdirSync(path, stats.mode, stats);
-                for (const k of this.readable.readdirSync(path)) {
-                    this.copyToWritableSync(join(path, k));
-                }
-                return;
+        const stats = this.statSync(path);
+        stats.mode |= 0o222;
+        if (isDirectory(stats)) {
+            this.writable.mkdirSync(path, stats);
+            for (const k of this.readable.readdirSync(path)) {
+                this.copyToWritableSync(join(path, k));
             }
-            const data = new Uint8Array(stats.size);
-            const readable = __addDisposableResource(env_1, this.readable.openFileSync(path, 'r'), false);
-            readable.readSync(data);
-            const writable = __addDisposableResource(env_1, this.writable.createFileSync(path, 'w', stats.mode, stats), false);
-            writable.writeSync(data);
-        }
-        catch (e_1) {
-            env_1.error = e_1;
-            env_1.hasError = true;
-        }
-        finally {
-            __disposeResources(env_1);
+            return;
         }
+        const data = new Uint8Array(stats.size);
+        this.readable.readSync(path, data, 0, data.byteLength);
+        this.writable.createFileSync(path, stats);
+        this.writable.touchSync(path, stats);
+        this.writable.writeSync(path, data, 0);
     }
     async copyToWritable(path) {
-        const env_2 = { stack: [], error: void 0, hasError: false };
-        try {
-            const stats = await this.stat(path);
-            stats.mode |= 0o222;
-            if (stats.isDirectory()) {
-                await this.writable.mkdir(path, stats.mode, stats);
-                for (const k of await this.readable.readdir(path)) {
-                    await this.copyToWritable(join(path, k));
-                }
-                return;
+        const stats = await this.stat(path);
+        stats.mode |= 0o222;
+        if (isDirectory(stats)) {
+            await this.writable.mkdir(path, stats);
+            for (const k of await this.readable.readdir(path)) {
+                await this.copyToWritable(join(path, k));
             }
-            const data = new Uint8Array(stats.size);
-            await this.readable.read(path, data, 0, stats.size);
-            const writable = __addDisposableResource(env_2, await this.writable.createFile(path, 'w', stats.mode, stats), true);
-            await writable.write(data);
-        }
-        catch (e_2) {
-            env_2.error = e_2;
-            env_2.hasError = true;
-        }
-        finally {
-            const result_1 = __disposeResources(env_2);
-            if (result_1)
-                await result_1;
+            return;
         }
+        const data = new Uint8Array(stats.size);
+        await this.readable.read(path, data, 0, stats.size);
+        await this.writable.createFile(path, stats);
+        await this.writable.touch(path, stats);
+        await this.writable.write(path, data, 0);
     }
 }
-/**
- * @hidden @deprecated use `CopyOnWriteFS`
- */
-export class OverlayFS extends CopyOnWriteFS {
-}
 const _CopyOnWrite = {
     name: 'CopyOnWrite',
     options: {
@@ -498,9 +414,3 @@ const _CopyOnWrite = {
  * @internal
  */
 export const CopyOnWrite = _CopyOnWrite;
-/**
- * @deprecated Use `CopyOnWrite`
- * @category Backends and Configuration
- * @internal @hidden
- */
-export const Overlay = _CopyOnWrite;

package/dist/backends/fetch.d.ts

@@ -28,6 +28,7 @@ export interface FetchOptions extends SharedConfig {
 }
 /**
  * A simple filesystem backed by HTTP using the `fetch` API.
+ * @category Internals
  * @internal
  */
 export declare class FetchFS extends IndexFS {

package/dist/backends/fetch.js

@@ -1,9 +1,10 @@
+import { decodeUTF8 } from 'utilium';
 import * as requests from 'utilium/requests.js';
 import { Errno, ErrnoError } from '../internal/error.js';
 import { Index } from '../internal/file_index.js';
 import { IndexFS } from '../internal/index_fs.js';
 import { err, warn } from '../internal/log.js';
-import { decodeUTF8, normalizePath } from '../utils.js';
+import { normalizePath } from '../utils.js';
 import { S_IFREG } from '../vfs/constants.js';
 /** Parse and throw */
 function parseError(path, fs) {
@@ -24,6 +25,7 @@ function parseError(path, fs) {
 }
 /**
  * A simple filesystem backed by HTTP using the `fetch` API.
+ * @category Internals
  * @internal
  */
 export class FetchFS extends IndexFS {

package/dist/backends/index.d.ts

@@ -3,7 +3,7 @@ export * from './cow.js';
 export * from './fetch.js';
 export * from './memory.js';
 export * from './passthrough.js';
-export * from './port/fs.js';
+export * from './port.js';
 export * from './single_buffer.js';
 export * from './store/fs.js';
 export * from './store/map.js';

package/dist/backends/index.js

@@ -3,7 +3,7 @@ export * from './cow.js';
 export * from './fetch.js';
 export * from './memory.js';
 export * from './passthrough.js';
-export * from './port/fs.js';
+export * from './port.js';
 export * from './single_buffer.js';
 export * from './store/fs.js';
 export * from './store/map.js';

package/dist/backends/memory.d.ts

@@ -25,8 +25,6 @@ export interface InMemoryOptions {
     maxSize?: number;
     /** The label to use for the store and file system */
     label?: string;
-    /** @deprecated use `label` */
-    name?: string;
 }
 declare const _InMemory: {
     readonly name: "InMemory";
@@ -39,14 +37,14 @@ declare const _InMemory: {
             readonly type: "string";
             readonly required: false;
         };
-        readonly name: {
-            readonly type: "string";
-            readonly required: false;
-        };
     };
-    readonly create: ({ maxSize, label, name }: InMemoryOptions) => StoreFS<InMemoryStore>;
+    readonly create: ({ maxSize, label }: InMemoryOptions) => StoreFS<InMemoryStore>;
 };
 type _InMemory = typeof _InMemory;
+/**
+ * A backend that uses an in-memory store for storing data
+ * @category Backends and Configuration
+ */
 export interface InMemory extends _InMemory {
 }
 /**

package/dist/backends/memory.js

@@ -35,10 +35,9 @@ const _InMemory = {
     options: {
         maxSize: { type: 'number', required: false },
         label: { type: 'string', required: false },
-        name: { type: 'string', required: false },
     },
-    create({ maxSize, label, name }) {
-        const fs = new StoreFS(new InMemoryStore(maxSize, label !== null && label !== void 0 ? label : name));
+    create({ maxSize, label }) {
+        const fs = new StoreFS(new InMemoryStore(maxSize, label));
         fs.checkRootSync();
         return fs;
     },