@zenfs/core 2.5.2 → 2.5.3

package/dist/backends/single_buffer.d.ts

@@ -8,6 +8,7 @@ import type { Store } from './store/store.js';
 type Lock = Disposable & (() => void);
 declare const MetadataEntry_base: import("memium").StructConstructor<BufferView<any>>;
 declare class MetadataEntry extends MetadataEntry_base {
+    static name: string;
     /** Inode or data ID */
     accessor id: number;
     /** Reserved for 64-bit offset expansion */
@@ -25,6 +26,7 @@ declare const MetadataBlock_base: import("memium/decorators").StructFromTypedArr
  * This is done since IDs are not guaranteed to be sequential.
  */
 export declare class MetadataBlock extends MetadataBlock_base<ArrayBufferLike> {
+    static name: string;
     readonly ['constructor']: typeof MetadataBlock;
     private static readonly lockIndex;
     /**
@@ -57,6 +59,7 @@ declare const SuperBlock_base: import("memium/decorators").StructFromTypedArray<
  * The super block structure for a single-buffer file system
  */
 export declare class SuperBlock extends SuperBlock_base<ArrayBufferLike> {
+    static name: string;
     readonly ['constructor']: typeof SuperBlock;
     constructor(...args: ConstructorParameters<typeof BigUint64Array<ArrayBufferLike>>);
     /**

package/dist/backends/single_buffer.js

@@ -105,7 +105,7 @@ const { format } = new Intl.NumberFormat('en-US', {
 });
 let MetadataEntry = (() => {
     var _a, _b, _c, _d;
-    let _classDecorators = [struct.packed('MetadataEntry')];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -137,8 +137,8 @@ let MetadataEntry = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             MetadataEntry = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'MetadataEntry';
         #id_accessor_storage = __runInitializers(this, _id_initializers, void 0);
         /** Inode or data ID */
         get id() { return this.#id_accessor_storage; }
@@ -162,6 +162,9 @@ let MetadataEntry = (() => {
             super(...arguments);
             __runInitializers(this, _size_extraInitializers);
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return MetadataEntry = _classThis;
 })();
@@ -180,7 +183,7 @@ const max_lock_attempts = 5;
  */
 let MetadataBlock = (() => {
     var _a, _b, _c, _d;
-    let _classDecorators = [struct.packed('MetadataBlock')];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -218,7 +221,8 @@ let MetadataBlock = (() => {
             MetadataBlock = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        static lockIndex = offsetof(MetadataBlock, 'locked') / Int32Array.BYTES_PER_ELEMENT;
+        static name = 'MetadataBlock';
+        static lockIndex;
         #checksum_accessor_storage = __runInitializers(this, _checksum_initializers, void 0);
         /**
          * The crc32c checksum for the metadata block.
@@ -309,6 +313,8 @@ let MetadataBlock = (() => {
     return MetadataBlock = _classThis;
 })();
 export { MetadataBlock };
+// workaround for https://github.com/microsoft/TypeScript/issues/61862
+Object.assign(MetadataBlock, { lockIndex: offsetof(MetadataBlock, 'locked') / Int32Array.BYTES_PER_ELEMENT });
 const sb_magic = 0x62732e7a; // 'z.sb'
 /**
  * Shortcut for minor perf. bump
@@ -320,7 +326,7 @@ const usedBytes = 2;
  */
 let SuperBlock = (() => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-    let _classDecorators = [struct.packed('Superblock')];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -397,8 +403,8 @@ let SuperBlock = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             SuperBlock = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'SuperBlock';
         constructor(...args) {
             super(...args);
             __runInitializers(this, __padding_extraInitializers);
@@ -532,6 +538,9 @@ let SuperBlock = (() => {
             }
             return true;
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return SuperBlock = _classThis;
 })();

package/dist/internal/inode.d.ts

@@ -13,6 +13,7 @@ declare const Attributes_base: import("memium").StructConstructor<BufferView<any
  * @internal
  */
 export declare class Attributes extends Attributes_base {
+    static name: string;
     accessor size: number;
     get byteSize(): number;
     has(name: string): boolean;
@@ -151,6 +152,7 @@ declare const Inode_base: import("memium").StructConstructor<BufferView<any>>;
  * @internal
  */
 export declare class Inode extends Inode_base implements InodeLike {
+    static name: string;
     constructor(...args: ConstructorParameters<typeof BufferView> | [Readonly<Partial<InodeLike>>]);
     accessor data: number;
     /** For future use */

package/dist/internal/inode.js

@@ -51,7 +51,7 @@ export const rootIno = 0;
 const maxDynamicData = 3968;
 let Attribute = (() => {
     var _a, _b;
-    let _classDecorators = [struct.packed('Attribute')];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -73,8 +73,8 @@ let Attribute = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             Attribute = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'Attribute';
         #keySize_accessor_storage = __runInitializers(this, _keySize_initializers, void 0);
         get keySize() { return this.#keySize_accessor_storage; }
         set keySize(value) { this.#keySize_accessor_storage = value; }
@@ -112,6 +112,9 @@ let Attribute = (() => {
             super(...arguments);
             __runInitializers(this, _valueSize_extraInitializers);
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return Attribute = _classThis;
 })();
@@ -122,7 +125,7 @@ let Attribute = (() => {
  */
 let Attributes = (() => {
     var _a;
-    let _classDecorators = [struct.packed('Attributes')];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -139,8 +142,8 @@ let Attributes = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             Attributes = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'Attributes';
         #size_accessor_storage = __runInitializers(this, _size_initializers, void 0);
         get size() { return this.#size_accessor_storage; }
         set size(value) { this.#size_accessor_storage = value; }
@@ -243,6 +246,9 @@ let Attributes = (() => {
             super(...arguments);
             __runInitializers(this, _size_extraInitializers);
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return Attributes = _classThis;
 })();
@@ -330,7 +336,7 @@ export const userModifiableFlags = 0x000380ff;
  */
 let Inode = (() => {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
-    let _classDecorators = [struct.packed('Inode')];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -437,8 +443,8 @@ let Inode = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             Inode = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'Inode';
         constructor(...args) {
             let data = {};
             if (typeof args[0] === 'object' && args[0] !== null && !ArrayBuffer.isView(args[0])) {
@@ -589,6 +595,9 @@ let Inode = (() => {
                 this.ctimeMs = Date.now();
             return hasChanged;
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return Inode = _classThis;
 })();

package/dist/node/promises.js

@@ -55,7 +55,7 @@ import { Exception, rethrow, UV } from 'kerium';
 import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
-import { join, matchesGlob, parse } from '../path.js';
+import { join, matchesGlob } from '../path.js';
 import '../polyfills.js';
 import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import * as _async from '../vfs/async.js';
@@ -354,23 +354,12 @@ export async function exists(path) {
     }
 }
 export async function stat(path, options) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = await _async.resolve(this, path);
-    const $ex = { syscall: 'stat', path };
-    const stats = await fs.stat(resolved).catch(rethrow($ex));
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', $ex);
+    const stats = await _async.stat.call(this, path, false);
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 stat;
 export async function lstat(path, options) {
-    path = normalizePath(path);
-    const $ex = { syscall: 'lstat', path };
-    const { base, dir } = parse(path);
-    const { fs, path: parent } = await _async.resolve(this, dir);
-    const stats = await fs.stat(base ? join(parent, base) : parent).catch(rethrow($ex));
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', $ex);
+    const stats = await _async.stat.call(this, path, true);
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 lstat;

package/dist/node/sync.js

@@ -56,7 +56,7 @@ import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory } from '../internal/inode.js';
-import { join, matchesGlob, parse } from '../path.js';
+import { join, matchesGlob } from '../path.js';
 import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
@@ -87,27 +87,12 @@ export function existsSync(path) {
 }
 existsSync;
 export function statSync(path, options) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = _sync.resolve(this, path);
-    let stats;
-    try {
-        stats = fs.statSync(resolved);
-    }
-    catch (e) {
-        throw setUVMessage(Object.assign(e, { path }));
-    }
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', { syscall: 'stat', path });
+    const stats = _sync.stat.call(this, path, false);
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 statSync;
 export function lstatSync(path, options) {
-    path = normalizePath(path);
-    const { base, dir } = parse(path);
-    const { fs, path: parent } = _sync.resolve(this, dir);
-    const stats = wrap(fs, 'statSync', path)(base ? join(parent, base) : parent);
-    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
-        throw UV('EACCES', { syscall: 'lstat', path });
+    const stats = _sync.stat.call(this, path, true);
     return options?.bigint ? new BigIntStats(stats) : new Stats(stats);
 }
 lstatSync;

package/dist/vfs/acl.d.ts

@@ -19,12 +19,14 @@ export declare const enum Tag {
 }
 declare const Entry_base: import("memium").StructConstructor<BufferView<any>>;
 export declare class Entry extends Entry_base {
+    static name: string;
     accessor tag: Tag;
     accessor perm: number;
     accessor id: number;
 }
 declare const ACL_base: import("memium").StructConstructor<BufferView<any>>;
 export declare class ACL extends ACL_base {
+    static name: string;
     accessor version: number;
     entries: Entry[];
     constructor(...args: ConstructorParameters<typeof BufferView>);

package/dist/vfs/acl.js

@@ -41,7 +41,7 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
 */
 import { withErrno } from 'kerium';
 import { err } from 'kerium/log';
-import { packed, sizeof } from 'memium';
+import { sizeof } from 'memium';
 import { $from, struct, types as t } from 'memium/decorators';
 import { BufferView } from 'utilium/buffer.js';
 import { R_OK, S_IRWXG, S_IRWXO, S_IRWXU, W_OK, X_OK } from '../constants.js';
@@ -69,7 +69,7 @@ export var Tag;
 })(Tag || (Tag = {}));
 let Entry = (() => {
     var _a, _b, _c;
-    let _classDecorators = [struct('ACL.Entry', packed)];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -96,8 +96,8 @@ let Entry = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             Entry = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'ACL.Entry';
         #tag_accessor_storage = __runInitializers(this, _tag_initializers, void 0);
         get tag() { return this.#tag_accessor_storage; }
         set tag(value) { this.#tag_accessor_storage = value; }
@@ -111,13 +111,16 @@ let Entry = (() => {
             super(...arguments);
             __runInitializers(this, _id_extraInitializers);
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return Entry = _classThis;
 })();
 export { Entry };
 let ACL = (() => {
     var _a;
-    let _classDecorators = [struct.packed('ACL')];
+    let _classDecorators = [struct.packed()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -134,8 +137,8 @@ let ACL = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             ACL = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'ACL';
         #version_accessor_storage = __runInitializers(this, _version_initializers, void 0);
         get version() { return this.#version_accessor_storage; }
         set version(value) { this.#version_accessor_storage = value; }
@@ -151,6 +154,9 @@ let ACL = (() => {
                 this.entries.push(new Entry(this.buffer, offset));
             }
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return ACL = _classThis;
 })();

package/dist/vfs/async.d.ts

@@ -2,6 +2,7 @@ import type { PathLike } from 'node:fs';
 import type { V_Context } from '../internal/contexts.js';
 import type { MkdirOptions, OpenOptions, ReaddirOptions, ResolvedPath } from './shared.js';
 import { type ExceptionExtra } from 'kerium';
+import { type InodeLike } from '../internal/inode.js';
 import { Dirent } from './dir.js';
 import { Handle } from './file.js';
 /**
@@ -20,3 +21,4 @@ export declare function mkdir(this: V_Context, path: PathLike, options?: MkdirOp
 export declare function readdir(this: V_Context, path: PathLike, options?: ReaddirOptions): Promise<Dirent[]>;
 export declare function rename(this: V_Context, oldPath: PathLike, newPath: PathLike): Promise<void>;
 export declare function link(this: V_Context, target: PathLike, link: PathLike): Promise<void>;
+export declare function stat(this: V_Context, path: PathLike, lstat: boolean): Promise<InodeLike>;

package/dist/vfs/async.js

@@ -1,4 +1,4 @@
-import { setUVMessage, UV } from 'kerium';
+import { rethrow, setUVMessage, UV } from 'kerium';
 import { decodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { contextOf } from '../internal/contexts.js';
@@ -45,7 +45,7 @@ export async function resolve($, path, preserveSymlinks, extra) {
     const stats = await resolved.fs.stat(resolved.path).catch((e) => {
         if (e.code == 'ENOENT')
             return;
-        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath }));
+        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
     });
     if (!stats)
         return { ...resolved, fullPath: path };
@@ -228,3 +228,20 @@ export async function link(target, link) {
     }
     return await fs.link(resolved, dst.path);
 }
+export async function stat(path, lstat) {
+    path = normalizePath.call(this, path);
+    const extra = { syscall: lstat ? 'lstat' : 'stat', path };
+    let stats;
+    if (!lstat)
+        stats = (await resolve(this, path, false, extra)).stats;
+    else {
+        const { base, dir } = parse(path);
+        const { fs, path: parent } = await resolve(this, dir, false, extra);
+        stats = await fs.stat(base ? join(parent, base) : parent).catch(rethrow(extra));
+    }
+    if (!stats)
+        throw UV('ENOENT', extra);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', extra);
+    return stats;
+}

package/dist/vfs/ioctl.d.ts

@@ -3,6 +3,7 @@ import type { V_Context } from '../context.js';
 import { Inode } from '../internal/inode.js';
 declare const fsxattr_base: import("memium").StructConstructor<BufferView<any>>;
 declare class fsxattr extends fsxattr_base {
+    static name: string;
     /** xflags field value */
     accessor xflags: number;
     /** extsize field value */

package/dist/vfs/ioctl.js

@@ -89,7 +89,7 @@ var XFlag;
 })(XFlag || (XFlag = {}));
 let fsxattr = (() => {
     var _a, _b, _c, _d, _e;
-    let _classDecorators = [struct('fsxattr')];
+    let _classDecorators = [struct()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
@@ -131,8 +131,8 @@ let fsxattr = (() => {
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             fsxattr = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-            __runInitializers(_classThis, _classExtraInitializers);
         }
+        static name = 'fsxattr';
         #xflags_accessor_storage = __runInitializers(this, _xflags_initializers, void 0);
         /** xflags field value */
         get xflags() { return this.#xflags_accessor_storage; }
@@ -170,6 +170,9 @@ let fsxattr = (() => {
                     this.xflags |= XFlag[name];
             }
         }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
     };
     return fsxattr = _classThis;
 })();

package/dist/vfs/sync.d.ts

@@ -1,5 +1,6 @@
 import type { PathLike } from 'node:fs';
 import type { V_Context } from '../context.js';
+import type { InodeLike } from '../internal/inode.js';
 import type { MkdirOptions, OpenOptions, ReaddirOptions, ResolvedPath } from './shared.js';
 import { type ExceptionExtra } from 'kerium';
 import { Dirent } from './dir.js';
@@ -21,3 +22,4 @@ export declare function mkdir(this: V_Context, path: PathLike, options?: MkdirOp
 export declare function readdir(this: V_Context, path: PathLike, options?: ReaddirOptions): Dirent[];
 export declare function rename(this: V_Context, oldPath: PathLike, newPath: PathLike): void;
 export declare function link(this: V_Context, target: PathLike, link: PathLike): void;
+export declare function stat(this: V_Context, path: PathLike, lstat: boolean): InodeLike;

package/dist/vfs/sync.js

@@ -32,7 +32,7 @@ export function resolve($, path, preserveSymlinks, extra) {
         return resolve($, target, preserveSymlinks, extra);
     }
     catch (e) {
-        setUVMessage(Object.assign(e, { syscall: 'stat', path }));
+        setUVMessage(Object.assign(e, { syscall: 'stat', path, ...extra }));
         if (preserveSymlinks)
             throw e;
     }
@@ -47,7 +47,7 @@ export function resolve($, path, preserveSymlinks, extra) {
     catch (e) {
         if (e.code === 'ENOENT')
             return { ...resolved, fullPath: path };
-        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath }));
+        throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
     }
     if (!isSymbolicLink(stats)) {
         return { ...resolved, fullPath: maybePath, stats };
@@ -245,3 +245,26 @@ export function link(target, link) {
     }
     return fs.linkSync(resolved, dst.path);
 }
+export function stat(path, lstat) {
+    path = normalizePath.call(this, path);
+    const extra = { syscall: lstat ? 'lstat' : 'stat', path };
+    let stats;
+    if (!lstat)
+        stats = resolve(this, path, false, extra).stats;
+    else {
+        const { base, dir } = parse(path);
+        const { fs, path: parent } = resolve(this, dir, false, extra);
+        try {
+            stats = fs.statSync(base ? join(parent, base) : parent);
+        }
+        catch (e) {
+            setUVMessage(Object.assign(e, extra));
+            throw e;
+        }
+    }
+    if (!stats)
+        throw UV('ENOENT', extra);
+    if (checkAccess && !hasAccess(this, stats, constants.R_OK))
+        throw UV('EACCES', extra);
+    return stats;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.5.2",
+	"version": "2.5.3",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -15,7 +15,7 @@
 	],
 	"bin": {
 		"make-index": "scripts/make-index.js",
-		"zenfs-test": "scripts/test.js",
+		"zenfs-test": "scripts/test.ts",
 		"zci": "scripts/ci-cli.js"
 	},
 	"files": [
@@ -75,7 +75,7 @@
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.3.4",
-		"memium": "^0.3.10",
+		"memium": "^0.4.0",
 		"readable-stream": "^4.5.2",
 		"utilium": "^2.5.0"
 	},

package/scripts/{test.js → test.ts}

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+// NOTE: Not compiled, use erasable TS only
 import { execSync } from 'node:child_process';
 import { existsSync, globSync, mkdirSync, rmSync } from 'node:fs';
 import { join, parse, basename } from 'node:path';
@@ -24,6 +25,7 @@ const { values: options, positionals } = parseArgs({
 		inspect: { short: 'I', type: 'boolean', default: false },
 		skip: { short: 's', type: 'string', multiple: true, default: [] },
 		'exit-on-fail': { short: 'e', type: 'boolean' },
+		runs: { short: 'r', type: 'string' },
 
 		// Coverage and performance
 		coverage: { type: 'string', default: 'tests/.coverage' },
@@ -49,6 +51,7 @@ Behavior:
     -b, --build           Run the npm build script prior to running tests
     -c, --common          Also run tests not specific to any backend
     -e, --exit-on-fail    If any tests suites fail, exit immediately
+    -r, --runs <n>        Run tests n times and print average result
     -t, --test <glob>     Which FS test suite(s) to run
     -f, --force           Whether to use --test-force-exit
     -I, --inspect         Use the inspector for debugging
@@ -104,7 +107,13 @@ if (options.report) {
 }
 
 let ci;
-if (options.ci) ci = await import('./ci.js');
+if (options.ci) {
+	if (options.runs) {
+		console.error('Cannot use --ci with --runs');
+		process.exit(1);
+	}
+	ci = await import('./ci.js');
+}
 
 options.verbose && options.force && console.debug('Forcing tests to exit (--test-force-exit)');
 
@@ -135,50 +144,13 @@ if (options.auto) {
 	!options.quiet && console.log(`Auto-detected ${sum} test setup files`);
 }
 
-async function status(name) {
-	const start = performance.now();
-
-	if (options.ci) await ci.startCheck(name);
-
-	const time = () => {
-		let delta = Math.round(performance.now() - start),
-			unit = 'ms';
-
-		if (delta > 5000) {
-			delta /= 1000;
-			unit = 's';
-		}
-
-		return styleText('dim', `(${delta} ${unit})`);
-	};
-
-	const maybeName = options.verbose ? `: ${name}` : '';
-
-	return {
-		async pass() {
-			if (!options.quiet) console.log(`${styleText('green', 'passed')}${maybeName} ${time()}`);
-			if (options.ci) await ci.completeCheck(name, 'success');
-		},
-		async skip() {
-			if (!options.quiet) console.log(`${styleText('yellow', 'skipped')}${maybeName} ${time()}`);
-			if (options.ci) await ci.completeCheck(name, 'skipped');
-		},
-		async fail() {
-			console.error(`${styleText(['red', 'bold'], 'failed')}${maybeName} ${time()}`);
-			if (options.ci) await ci.completeCheck(name, 'failure');
-			process.exitCode = 1;
-			if (options['exit-on-fail']) process.exit();
-		},
-	};
-}
-
 if (!options.preserve) rmSync(options.coverage, { force: true, recursive: true });
 mkdirSync(options.coverage, { recursive: true });
 
 /**
  * Generate the command used to run the tests
  */
-function makeCommand(profileName, ...rest) {
+function makeCommand(profileName: string, ...rest: string[]): string {
 	const command = [
 		'tsx --trace-deprecation',
 		options.inspect ? '--inspect' : '',
@@ -196,19 +168,81 @@ function makeCommand(profileName, ...rest) {
 	return command;
 }
 
-if (options.common) {
-	const command = makeCommand('common', `'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'`);
+function duration(ms: number) {
+	ms = Math.round(ms);
+	let unit = 'ms';
 
-	if (!options.quiet) process.stdout.write('Running common tests...' + (options.verbose ? '\n' : ' '));
-	const { pass, fail } = await status('Common tests');
-	try {
-		execSync(command, {
-			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
-		});
-		await pass();
-	} catch {
-		await fail();
+	if (ms > 5000) {
+		ms /= 1000;
+		unit = 's';
 	}
+
+	return ms + ' ' + unit;
+}
+
+const nRuns = Number.isSafeInteger(parseInt(options.runs)) ? parseInt(options.runs) : 1;
+
+interface RunTestOptions {
+	name: string;
+	args: string[];
+	statusName?: string;
+	shouldSkip?(): boolean;
+}
+
+async function runTests(config: RunTestOptions) {
+	const statusName = config.statusName || config.name;
+
+	const command = makeCommand(config.name, ...config.args);
+
+	let totalTime = 0;
+	for (let i = 0; i < nRuns; i++) {
+		const start = performance.now();
+
+		if (options.ci) await ci.startCheck(statusName);
+
+		const time = () => styleText('dim', `(${duration(Math.round(performance.now() - start))})`);
+
+		let identText = options.verbose ? `: ${statusName}` : '';
+
+		if (nRuns != 1) identText += ` [${i + 1}/${nRuns}]`;
+
+		if (!options.quiet) {
+			if (options.verbose) console.log('Running tests:', config.name);
+			else process.stdout.write(`Running tests: ${config.name}... `);
+		}
+
+		if (config.shouldSkip?.()) {
+			if (!options.quiet) console.log(`${styleText('yellow', 'skipped')}${identText} ${time()}`);
+			if (options.ci) await ci.completeCheck(statusName, 'skipped');
+			return;
+		}
+
+		try {
+			execSync(command, {
+				stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
+			});
+			if (!options.quiet) console.log(`${styleText('green', 'passed')}${identText} ${time()}`);
+			if (options.ci) await ci.completeCheck(statusName, 'success');
+			totalTime += performance.now() - start;
+		} catch {
+			console.error(`${styleText(['red', 'bold'], 'failed')}${identText} ${time()}`);
+			if (options.ci) await ci.completeCheck(statusName, 'failure');
+			process.exitCode = 1;
+			if (options['exit-on-fail']) process.exit();
+			return;
+		}
+	}
+	if (nRuns != 1) {
+		console.log('Average', config.name, 'time:', styleText('blueBright', duration(totalTime / nRuns)));
+	}
+}
+
+if (options.common) {
+	await runTests({
+		name: 'common',
+		args: [`'tests/*.test.ts'`, `'tests/**/!(fs)/*.test.ts'`],
+		statusName: 'Common tests',
+	});
 }
 
 const testsGlob = join(import.meta.dirname, `../tests/fs/${options.test || '*'}.test.ts`);
@@ -223,28 +257,13 @@ for (const setupFile of positionals) {
 
 	const name = options['file-names'] && !options.ci ? setupFile : parse(setupFile).name;
 
-	const command = makeCommand(name, `'${testsGlob.replaceAll("'", "\\'")}'`, process.env.CMD);
-
-	if (!options.quiet) {
-		if (options.verbose) console.log('Running tests:', name);
-		else process.stdout.write(`Running tests: ${name}... `);
-	}
-
-	const { pass, fail, skip } = await status(name);
-
-	if (basename(setupFile).startsWith('_')) {
-		await skip();
-		continue;
-	}
-
-	try {
-		execSync(command, {
-			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
-		});
-		await pass();
-	} catch {
-		await fail();
-	}
+	await runTests({
+		name,
+		args: [`'${testsGlob.replaceAll("'", "\\'")}'`, process.env.CMD],
+		shouldSkip() {
+			return basename(setupFile).startsWith('_');
+		},
+	});
 }
 
 if (!options.preserve) report();