@zenfs/core 0.17.0 → 0.18.0

package/dist/mixins/mutexed.js

@@ -106,9 +106,17 @@ export function Mutexed(FS) {
          * If the path is currently locked, waits for it to be unlocked.
          * @internal
          */
-        async lock(path) {
+        async lock(path, syscall) {
             const previous = this.locks.get(path);
             const lock = this.addLock(path);
+            const stack = new Error().stack;
+            setTimeout(() => {
+                if (lock.isLocked) {
+                    const error = ErrnoError.With('EDEADLK', path, syscall);
+                    error.stack += stack?.slice('Error'.length);
+                    throw error;
+                }
+            }, 5000);
             await previous?.done();
             return lock;
         }
@@ -120,7 +128,7 @@ export function Mutexed(FS) {
         lockSync(path) {
             if (this.locks.has(path)) {
                 // Non-null assertion: we already checked locks has path
-                throw ErrnoError.With('EBUSY', path, 'lockSync');
+                throw ErrnoError.With('EBUSY', path, 'lock');
             }
             return this.addLock(path);
         }
@@ -132,12 +140,12 @@ export function Mutexed(FS) {
             return !!this.locks.get(path)?.isLocked;
         }
         /* eslint-disable @typescript-eslint/no-unused-vars */
-        async rename(oldPath, newPath, cred) {
+        async rename(oldPath, newPath) {
             const env_1 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_1, await this.lock(oldPath), false);
+                const _ = __addDisposableResource(env_1, await this.lock(oldPath, 'rename'), false);
                 // @ts-expect-error 2513
-                await super.rename(oldPath, newPath, cred);
+                await super.rename(oldPath, newPath);
             }
             catch (e_1) {
                 env_1.error = e_1;
@@ -147,12 +155,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_1);
             }
         }
-        renameSync(oldPath, newPath, cred) {
+        renameSync(oldPath, newPath) {
             const env_2 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_2, this.lockSync(oldPath), false);
                 // @ts-expect-error 2513
-                return super.renameSync(oldPath, newPath, cred);
+                return super.renameSync(oldPath, newPath);
             }
             catch (e_2) {
                 env_2.error = e_2;
@@ -162,12 +170,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_2);
             }
         }
-        async stat(path, cred) {
+        async stat(path) {
             const env_3 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_3, await this.lock(path), false);
+                const _ = __addDisposableResource(env_3, await this.lock(path, 'stat'), false);
                 // @ts-expect-error 2513
-                return await super.stat(path, cred);
+                return await super.stat(path);
             }
             catch (e_3) {
                 env_3.error = e_3;
@@ -177,12 +185,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_3);
             }
         }
-        statSync(path, cred) {
+        statSync(path) {
             const env_4 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_4, this.lockSync(path), false);
                 // @ts-expect-error 2513
-                return super.statSync(path, cred);
+                return super.statSync(path);
             }
             catch (e_4) {
                 env_4.error = e_4;
@@ -192,12 +200,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_4);
             }
         }
-        async openFile(path, flag, cred) {
+        async openFile(path, flag) {
             const env_5 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_5, await this.lock(path), false);
+                const _ = __addDisposableResource(env_5, await this.lock(path, 'openFile'), false);
                 // @ts-expect-error 2513
-                return await super.openFile(path, flag, cred);
+                return await super.openFile(path, flag);
             }
             catch (e_5) {
                 env_5.error = e_5;
@@ -207,12 +215,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_5);
             }
         }
-        openFileSync(path, flag, cred) {
+        openFileSync(path, flag) {
             const env_6 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_6, this.lockSync(path), false);
                 // @ts-expect-error 2513
-                return super.openFileSync(path, flag, cred);
+                return super.openFileSync(path, flag);
             }
             catch (e_6) {
                 env_6.error = e_6;
@@ -222,12 +230,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_6);
             }
         }
-        async createFile(path, flag, mode, cred) {
+        async createFile(path, flag, mode) {
             const env_7 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_7, await this.lock(path), false);
+                const _ = __addDisposableResource(env_7, await this.lock(path, 'createFile'), false);
                 // @ts-expect-error 2513
-                return await super.createFile(path, flag, mode, cred);
+                return await super.createFile(path, flag, mode);
             }
             catch (e_7) {
                 env_7.error = e_7;
@@ -237,12 +245,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_7);
             }
         }
-        createFileSync(path, flag, mode, cred) {
+        createFileSync(path, flag, mode) {
             const env_8 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_8, this.lockSync(path), false);
                 // @ts-expect-error 2513
-                return super.createFileSync(path, flag, mode, cred);
+                return super.createFileSync(path, flag, mode);
             }
             catch (e_8) {
                 env_8.error = e_8;
@@ -252,12 +260,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_8);
             }
         }
-        async unlink(path, cred) {
+        async unlink(path) {
             const env_9 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_9, await this.lock(path), false);
+                const _ = __addDisposableResource(env_9, await this.lock(path, 'unlink'), false);
                 // @ts-expect-error 2513
-                await super.unlink(path, cred);
+                await super.unlink(path);
             }
             catch (e_9) {
                 env_9.error = e_9;
@@ -267,12 +275,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_9);
             }
         }
-        unlinkSync(path, cred) {
+        unlinkSync(path) {
             const env_10 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_10, this.lockSync(path), false);
                 // @ts-expect-error 2513
-                return super.unlinkSync(path, cred);
+                return super.unlinkSync(path);
             }
             catch (e_10) {
                 env_10.error = e_10;
@@ -282,12 +290,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_10);
             }
         }
-        async rmdir(path, cred) {
+        async rmdir(path) {
             const env_11 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_11, await this.lock(path), false);
+                const _ = __addDisposableResource(env_11, await this.lock(path, 'rmdir'), false);
                 // @ts-expect-error 2513
-                await super.rmdir(path, cred);
+                await super.rmdir(path);
             }
             catch (e_11) {
                 env_11.error = e_11;
@@ -297,12 +305,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_11);
             }
         }
-        rmdirSync(path, cred) {
+        rmdirSync(path) {
             const env_12 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_12, this.lockSync(path), false);
                 // @ts-expect-error 2513
-                return super.rmdirSync(path, cred);
+                return super.rmdirSync(path);
             }
             catch (e_12) {
                 env_12.error = e_12;
@@ -312,12 +320,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_12);
             }
         }
-        async mkdir(path, mode, cred) {
+        async mkdir(path, mode) {
             const env_13 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_13, await this.lock(path), false);
+                const _ = __addDisposableResource(env_13, await this.lock(path, 'mkdir'), false);
                 // @ts-expect-error 2513
-                await super.mkdir(path, mode, cred);
+                await super.mkdir(path, mode);
             }
             catch (e_13) {
                 env_13.error = e_13;
@@ -327,12 +335,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_13);
             }
         }
-        mkdirSync(path, mode, cred) {
+        mkdirSync(path, mode) {
             const env_14 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_14, this.lockSync(path), false);
                 // @ts-expect-error 2513
-                return super.mkdirSync(path, mode, cred);
+                return super.mkdirSync(path, mode);
             }
             catch (e_14) {
                 env_14.error = e_14;
@@ -342,12 +350,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_14);
             }
         }
-        async readdir(path, cred) {
+        async readdir(path) {
             const env_15 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_15, await this.lock(path), false);
+                const _ = __addDisposableResource(env_15, await this.lock(path, 'readdir'), false);
                 // @ts-expect-error 2513
-                return await super.readdir(path, cred);
+                return await super.readdir(path);
             }
             catch (e_15) {
                 env_15.error = e_15;
@@ -357,12 +365,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_15);
             }
         }
-        readdirSync(path, cred) {
+        readdirSync(path) {
             const env_16 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_16, this.lockSync(path), false);
                 // @ts-expect-error 2513
-                return super.readdirSync(path, cred);
+                return super.readdirSync(path);
             }
             catch (e_16) {
                 env_16.error = e_16;
@@ -372,11 +380,11 @@ export function Mutexed(FS) {
                 __disposeResources(env_16);
             }
         }
-        async exists(path, cred) {
+        async exists(path) {
             const env_17 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_17, await this.lock(path), false);
-                return await super.exists(path, cred);
+                const _ = __addDisposableResource(env_17, await this.lock(path, 'exists'), false);
+                return await super.exists(path);
             }
             catch (e_17) {
                 env_17.error = e_17;
@@ -386,11 +394,11 @@ export function Mutexed(FS) {
                 __disposeResources(env_17);
             }
         }
-        existsSync(path, cred) {
+        existsSync(path) {
             const env_18 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_18, this.lockSync(path), false);
-                return super.existsSync(path, cred);
+                return super.existsSync(path);
             }
             catch (e_18) {
                 env_18.error = e_18;
@@ -400,12 +408,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_18);
             }
         }
-        async link(srcpath, dstpath, cred) {
+        async link(srcpath, dstpath) {
             const env_19 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_19, await this.lock(srcpath), false);
+                const _ = __addDisposableResource(env_19, await this.lock(srcpath, 'link'), false);
                 // @ts-expect-error 2513
-                await super.link(srcpath, dstpath, cred);
+                await super.link(srcpath, dstpath);
             }
             catch (e_19) {
                 env_19.error = e_19;
@@ -415,12 +423,12 @@ export function Mutexed(FS) {
                 __disposeResources(env_19);
             }
         }
-        linkSync(srcpath, dstpath, cred) {
+        linkSync(srcpath, dstpath) {
             const env_20 = { stack: [], error: void 0, hasError: false };
             try {
                 const _ = __addDisposableResource(env_20, this.lockSync(srcpath), false);
                 // @ts-expect-error 2513
-                return super.linkSync(srcpath, dstpath, cred);
+                return super.linkSync(srcpath, dstpath);
             }
             catch (e_20) {
                 env_20.error = e_20;
@@ -433,7 +441,7 @@ export function Mutexed(FS) {
         async sync(path, data, stats) {
             const env_21 = { stack: [], error: void 0, hasError: false };
             try {
-                const _ = __addDisposableResource(env_21, await this.lock(path), false);
+                const _ = __addDisposableResource(env_21, await this.lock(path, 'sync'), false);
                 // @ts-expect-error 2513
                 await super.sync(path, data, stats);
             }

package/dist/mixins/readonly.d.ts

@@ -1,25 +1,24 @@
-import { type Cred } from '../cred.js';
-import { type File } from '../file.js';
-import { type Stats } from '../stats.js';
+import type { File } from '../file.js';
 import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
+import type { Stats } from '../stats.js';
 import type { Mixin } from './shared.js';
 /**
  * Implements the non-readonly methods to throw `EROFS`
  */
 export declare function Readonly<T extends typeof FileSystem>(FS: T): Mixin<T, {
     metadata(): FileSystemMetadata;
-    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
-    renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
-    createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
-    unlink(path: string, cred: Cred): Promise<void>;
-    unlinkSync(path: string, cred: Cred): void;
-    rmdir(path: string, cred: Cred): Promise<void>;
-    rmdirSync(path: string, cred: Cred): void;
-    mkdir(path: string, mode: number, cred: Cred): Promise<void>;
-    mkdirSync(path: string, mode: number, cred: Cred): void;
-    link(srcpath: string, dstpath: string, cred: Cred): Promise<void>;
-    linkSync(srcpath: string, dstpath: string, cred: Cred): void;
+    rename(oldPath: string, newPath: string): Promise<void>;
+    renameSync(oldPath: string, newPath: string): void;
+    createFile(path: string, flag: string, mode: number): Promise<File>;
+    createFileSync(path: string, flag: string, mode: number): File;
+    unlink(path: string): Promise<void>;
+    unlinkSync(path: string): void;
+    rmdir(path: string): Promise<void>;
+    rmdirSync(path: string): void;
+    mkdir(path: string, mode: number): Promise<void>;
+    mkdirSync(path: string, mode: number): void;
+    link(srcpath: string, dstpath: string): Promise<void>;
+    linkSync(srcpath: string, dstpath: string): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
 }>;

package/dist/mixins/readonly.js

@@ -9,40 +9,40 @@ export function Readonly(FS) {
             return { ...super.metadata(), readonly: true };
         }
         /* eslint-disable @typescript-eslint/no-unused-vars */
-        async rename(oldPath, newPath, cred) {
+        async rename(oldPath, newPath) {
             throw new ErrnoError(Errno.EROFS);
         }
-        renameSync(oldPath, newPath, cred) {
+        renameSync(oldPath, newPath) {
             throw new ErrnoError(Errno.EROFS);
         }
-        async createFile(path, flag, mode, cred) {
+        async createFile(path, flag, mode) {
             throw new ErrnoError(Errno.EROFS);
         }
-        createFileSync(path, flag, mode, cred) {
+        createFileSync(path, flag, mode) {
             throw new ErrnoError(Errno.EROFS);
         }
-        async unlink(path, cred) {
+        async unlink(path) {
             throw new ErrnoError(Errno.EROFS);
         }
-        unlinkSync(path, cred) {
+        unlinkSync(path) {
             throw new ErrnoError(Errno.EROFS);
         }
-        async rmdir(path, cred) {
+        async rmdir(path) {
             throw new ErrnoError(Errno.EROFS);
         }
-        rmdirSync(path, cred) {
+        rmdirSync(path) {
             throw new ErrnoError(Errno.EROFS);
         }
-        async mkdir(path, mode, cred) {
+        async mkdir(path, mode) {
             throw new ErrnoError(Errno.EROFS);
         }
-        mkdirSync(path, mode, cred) {
+        mkdirSync(path, mode) {
             throw new ErrnoError(Errno.EROFS);
         }
-        async link(srcpath, dstpath, cred) {
+        async link(srcpath, dstpath) {
             throw new ErrnoError(Errno.EROFS);
         }
-        linkSync(srcpath, dstpath, cred) {
+        linkSync(srcpath, dstpath) {
             throw new ErrnoError(Errno.EROFS);
         }
         async sync(path, data, stats) {

package/dist/mixins/sync.js

@@ -4,35 +4,35 @@
 /* eslint-disable @typescript-eslint/require-await */
 export function Sync(FS) {
     class SyncFS extends FS {
-        async exists(path, cred) {
-            return this.existsSync(path, cred);
+        async exists(path) {
+            return this.existsSync(path);
         }
-        async rename(oldPath, newPath, cred) {
-            return this.renameSync(oldPath, newPath, cred);
+        async rename(oldPath, newPath) {
+            return this.renameSync(oldPath, newPath);
         }
-        async stat(path, cred) {
-            return this.statSync(path, cred);
+        async stat(path) {
+            return this.statSync(path);
         }
-        async createFile(path, flag, mode, cred) {
-            return this.createFileSync(path, flag, mode, cred);
+        async createFile(path, flag, mode) {
+            return this.createFileSync(path, flag, mode);
         }
-        async openFile(path, flag, cred) {
-            return this.openFileSync(path, flag, cred);
+        async openFile(path, flag) {
+            return this.openFileSync(path, flag);
         }
-        async unlink(path, cred) {
-            return this.unlinkSync(path, cred);
+        async unlink(path) {
+            return this.unlinkSync(path);
         }
-        async rmdir(path, cred) {
-            return this.rmdirSync(path, cred);
+        async rmdir(path) {
+            return this.rmdirSync(path);
         }
-        async mkdir(path, mode, cred) {
-            return this.mkdirSync(path, mode, cred);
+        async mkdir(path, mode) {
+            return this.mkdirSync(path, mode);
         }
-        async readdir(path, cred) {
-            return this.readdirSync(path, cred);
+        async readdir(path) {
+            return this.readdirSync(path);
         }
-        async link(srcpath, dstpath, cred) {
-            return this.linkSync(srcpath, dstpath, cred);
+        async link(srcpath, dstpath) {
+            return this.linkSync(srcpath, dstpath);
         }
         async sync(path, data, stats) {
             return this.syncSync(path, data, stats);

package/dist/stats.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" resolution-mode="require"/>
 import type * as Node from 'fs';
-import type { Cred } from './cred.js';
+import type { Credentials } from './credentials.js';
 import { S_IFDIR, S_IFLNK, S_IFREG } from './emulation/constants.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
@@ -150,12 +150,12 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      * @returns True if the request has access, false if the request does not
      * @internal
      */
-    hasAccess(mode: number, cred: Cred): boolean;
+    hasAccess(mode: number, cred: Credentials): boolean;
     /**
      * Convert the current stats object into a credentials object
      * @internal
      */
-    cred(uid?: number, gid?: number): Cred;
+    cred(uid?: number, gid?: number): Credentials;
     /**
      * Change the mode of the file. We use this helper function to prevent messing
      * up the type of the file, which is encoded in mode.
@@ -185,12 +185,19 @@ export declare class Stats extends StatsCommon<number> implements Node.Stats, St
 }
 /**
  * Stats with bigint
- * @todo Implement with bigint instead of wrapping Stats
- * @internal
  */
 export declare class BigIntStats extends StatsCommon<bigint> implements Node.BigIntStats, StatsLike {
     protected _isBigint: true;
 }
+/**
+ * Determines if the file stats have changed by comparing relevant properties.
+ *
+ * @param left The previous stats.
+ * @param right The current stats.
+ * @returns `true` if stats have changed; otherwise, `false`.
+ * @internal
+ */
+export declare function isStatsEqual<T extends number | bigint>(left: StatsCommon<T>, right: StatsCommon<T>): boolean;
 /**
  * @internal
  */

package/dist/stats.js

@@ -194,8 +194,6 @@ export class Stats extends StatsCommon {
 Stats;
 /**
  * Stats with bigint
- * @todo Implement with bigint instead of wrapping Stats
- * @internal
  */
 export class BigIntStats extends StatsCommon {
     constructor() {
@@ -203,6 +201,17 @@ export class BigIntStats extends StatsCommon {
         this._isBigint = true;
     }
 }
+/**
+ * Determines if the file stats have changed by comparing relevant properties.
+ *
+ * @param left The previous stats.
+ * @param right The current stats.
+ * @returns `true` if stats have changed; otherwise, `false`.
+ * @internal
+ */
+export function isStatsEqual(left, right) {
+    return left.size == right.size && +left.atime == +right.atime && +left.mtime == +right.mtime && +left.ctime == +right.ctime && left.mode == right.mode;
+}
 /**
  * @internal
  */

package/dist/utils.d.ts

@@ -1,11 +1,10 @@
 /// <reference types="node" resolution-mode="require"/>
 /// <reference types="node" resolution-mode="require"/>
+import type * as fs from 'node:fs';
 import type { OptionalTuple } from 'utilium';
-import { ErrnoError } from './error.js';
-import type { Cred } from './cred.js';
 import { type AbsolutePath } from './emulation/path.js';
+import { ErrnoError } from './error.js';
 import type { FileSystem } from './filesystem.js';
-import type * as fs from 'node:fs';
 declare global {
     function atob(data: string): string;
     function btoa(data: string): string;
@@ -14,7 +13,7 @@ declare global {
  * Synchronous recursive makedir.
  * @hidden
  */
-export declare function mkdirpSync(path: string, mode: number, cred: Cred, fs: FileSystem): void;
+export declare function mkdirpSync(path: string, mode: number, fs: FileSystem): void;
 /**
  * Calculates levenshtein distance.
  * @hidden
@@ -82,8 +81,3 @@ export declare function normalizeOptions(options: fs.WriteFileOptions | (fs.Enco
     flag: string;
     mode: number;
 };
-/**
- * Do nothing
- * @internal
- */
-export declare function nop(): void;

package/dist/utils.js

@@ -1,13 +1,13 @@
-import { ErrnoError, Errno } from './error.js';
 import { dirname, resolve } from './emulation/path.js';
+import { Errno, ErrnoError } from './error.js';
 /**
  * Synchronous recursive makedir.
  * @hidden
  */
-export function mkdirpSync(path, mode, cred, fs) {
-    if (!fs.existsSync(path, cred)) {
-        mkdirpSync(dirname(path), mode, cred, fs);
-        fs.mkdirSync(path, mode, cred);
+export function mkdirpSync(path, mode, fs) {
+    if (!fs.existsSync(path)) {
+        mkdirpSync(dirname(path), mode, fs);
+        fs.mkdirSync(path, mode);
     }
 }
 function _min(d0, d1, d2, bx, ay) {
@@ -114,24 +114,14 @@ export function decode(input) {
  * @hidden
  */
 export function decodeDirListing(data) {
-    return JSON.parse(decode(data), (k, v) => {
-        if (k == '') {
-            return v;
-        }
-        return BigInt(v);
-    });
+    return JSON.parse(decode(data), (k, v) => (k == '' ? v : BigInt(v)));
 }
 /**
  * Encodes a directory listing
  * @hidden
  */
 export function encodeDirListing(data) {
-    return encode(JSON.stringify(data, (k, v) => {
-        if (k == '') {
-            return v;
-        }
-        return v.toString();
-    }));
+    return encode(JSON.stringify(data, (k, v) => (k == '' ? v : v.toString())));
 }
 /**
  * converts Date or number to a integer UNIX timestamp
@@ -219,10 +209,3 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
         mode: normalizeMode('mode' in options ? options?.mode : null, mode),
     };
 }
-/**
- * Do nothing
- * @internal
- */
-export function nop() {
-    // do nothing
-}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.17.0",
+	"version": "0.18.0",
 	"description": "A filesystem, anywhere",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",
@@ -40,7 +40,8 @@
 	"exports": {
 		".": "./dist/index.js",
 		"./*": "./dist/*",
-		"./promises": "./dist/emulation/promises.js"
+		"./promises": "./dist/emulation/promises.js",
+		"./mixins": "./dist/mixins/index.js"
 	},
 	"scripts": {
 		"format": "prettier --write .",
@@ -64,7 +65,7 @@
 		"eventemitter3": "^5.0.1",
 		"minimatch": "^9.0.3",
 		"readable-stream": "^4.5.2",
-		"utilium": "^0.4.0"
+		"utilium": ">=0.4.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",