@zenfs/core 1.2.10 → 1.3.1

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

package/dist/emulation/shared.js

@@ -69,6 +69,15 @@ export function resolveMount(path) {
     }
     throw new ErrnoError(Errno.EIO, 'ZenFS not initialized with a file system');
 }
+/**
+ * Wait for all file systems to be ready and synced.
+ * May be removed at some point.
+ * @experimental @internal
+ */
+export async function _synced() {
+    await Promise.all([...mounts.values()].map(m => m.ready()));
+    return;
+}
 /**
  * Reverse maps the paths in text from the mounted FileSystem to the global path
  * @hidden
@@ -87,7 +96,10 @@ export function fixError(e, paths) {
     if (typeof e.stack == 'string') {
         e.stack = fixPaths(e.stack, paths);
     }
-    e.message = fixPaths(e.message, paths);
+    try {
+        e.message = fixPaths(e.message, paths);
+    }
+    catch { }
     return e;
 }
 /**

package/dist/emulation/sync.js

@@ -147,7 +147,7 @@ export function unlinkSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(path);
     try {
-        if (config.checkAccess && !(cache.getStatsSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
+        if (config.checkAccess && !(cache.stats.getSync(path) || fs.statSync(resolved)).hasAccess(constants.W_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'unlink');
         }
         fs.unlinkSync(resolved);
@@ -393,7 +393,7 @@ export function rmdirSync(path) {
     path = normalizePath(path);
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     try {
-        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
+        const stats = cache.stats.getSync(path) || fs.statSync(resolved);
         if (!stats.isDirectory()) {
             throw ErrnoError.With('ENOTDIR', resolved, 'rmdir');
         }
@@ -446,8 +446,8 @@ export function readdirSync(path, options) {
     const { fs, path: resolved } = resolveMount(realpathSync(path));
     let entries;
     try {
-        const stats = cache.getStatsSync(path) || fs.statSync(resolved);
-        cache.setStatsSync(path, stats);
+        const stats = cache.stats.getSync(path) || fs.statSync(resolved);
+        cache.stats.setSync(path, stats);
         if (config.checkAccess && !stats.hasAccess(constants.R_OK)) {
             throw ErrnoError.With('EACCES', resolved, 'readdir');
         }
@@ -462,8 +462,8 @@ export function readdirSync(path, options) {
     // Iterate over entries and handle recursive case if needed
     const values = [];
     for (const entry of entries) {
-        const entryStat = cache.getStatsSync(join(path, entry)) || fs.statSync(join(resolved, entry));
-        cache.setStatsSync(join(path, entry), entryStat);
+        const entryStat = cache.stats.getSync(join(path, entry)) || fs.statSync(join(resolved, entry));
+        cache.stats.setSync(join(path, entry), entryStat);
         if (options?.withFileTypes) {
             values.push(new Dirent(entry, entryStat));
         }
@@ -489,7 +489,7 @@ export function readdirSync(path, options) {
         }
     }
     if (!options?._isIndirect) {
-        cache.clearStatsSync();
+        cache.stats.clearSync();
     }
     return values;
 }
@@ -593,14 +593,15 @@ lutimesSync;
 export function realpathSync(path, options) {
     path = normalizePath(path);
     const { base, dir } = parse(path);
-    const lpath = join(dir == '/' ? '/' : realpathSync(dir), base);
+    const lpath = join(dir == '/' ? '/' : cache.paths.getSync(dir) || realpathSync(dir), base);
     const { fs, path: resolvedPath, mountPoint } = resolveMount(lpath);
     try {
         const stats = fs.statSync(resolvedPath);
         if (!stats.isSymbolicLink()) {
             return lpath;
         }
-        return realpathSync(mountPoint + readlinkSync(lpath, options).toString());
+        const target = mountPoint + readlinkSync(lpath, options).toString();
+        return cache.paths.getSync(target) || realpathSync(target);
     }
     catch (e) {
         if (e.code == 'ENOENT') {
@@ -626,7 +627,7 @@ export function rmSync(path, options) {
     path = normalizePath(path);
     let stats;
     try {
-        stats = cache.getStatsSync(path) || statSync(path);
+        stats = cache.stats.getSync(path) || statSync(path);
     }
     catch (error) {
         if (error.code != 'ENOENT' || !options?.force)
@@ -635,7 +636,7 @@ export function rmSync(path, options) {
     if (!stats) {
         return;
     }
-    cache.setStatsSync(path, stats);
+    cache.stats.setSync(path, stats);
     switch (stats.mode & constants.S_IFMT) {
         case constants.S_IFDIR:
             if (options?.recursive) {
@@ -654,11 +655,11 @@ export function rmSync(path, options) {
         case constants.S_IFIFO:
         case constants.S_IFSOCK:
         default:
-            cache.clearStatsSync();
+            cache.stats.clearSync();
             throw new ErrnoError(Errno.EPERM, 'File type not supported', path, 'rm');
     }
     if (!options?._isIndirect) {
-        cache.clearStatsSync();
+        cache.stats.clearSync();
     }
 }
 rmSync;

package/dist/file.d.ts

@@ -38,7 +38,7 @@ export declare function isTruncating(flag: string): boolean;
 export declare function isAppendable(flag: string): boolean;
 export declare function isSynchronous(flag: string): boolean;
 export declare function isExclusive(flag: string): boolean;
-export declare abstract class File {
+export declare abstract class File<FS extends FileSystem = FileSystem> {
     /**
      * @internal
      * The file system that created the file
@@ -138,12 +138,7 @@ export declare abstract class File {
  * An implementation of `File` that operates completely in-memory.
  * `PreloadFile`s are backed by a `Uint8Array`.
  */
-export declare class PreloadFile<FS extends FileSystem> extends File {
-    /**
-     * The file system that created the file.
-     * @internal
-     */
-    fs: FS;
+export declare class PreloadFile<FS extends FileSystem> extends File<FS> {
     readonly flag: string;
     readonly stats: Stats;
     /**
@@ -166,12 +161,7 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
      * Creates a file with `path` and, optionally, the given contents.
      * Note that, if contents is specified, it will be mutated by the file.
      */
-    constructor(
-    /**
-     * The file system that created the file.
-     * @internal
-     */
-    fs: FS, path: string, flag: string, stats: Stats, 
+    constructor(fs: FS, path: string, flag: string, stats: Stats, 
     /**
      * A buffer containing the entire contents of the file.
      */
@@ -255,8 +245,6 @@ export declare class PreloadFile<FS extends FileSystem> extends File {
     utimesSync(atime: Date, mtime: Date): void;
     _setType(type: FileType): Promise<void>;
     _setTypeSync(type: FileType): void;
-    [Symbol.asyncDispose](): Promise<void>;
-    [Symbol.dispose](): void;
 }
 /**
  * For the file systems which do not sync to anything.

package/dist/file.js

@@ -114,11 +114,11 @@ export class File {
         this.fs = fs;
         this.path = path;
     }
-    [Symbol.asyncDispose]() {
-        return this.close();
+    async [Symbol.asyncDispose]() {
+        await this.close();
     }
     [Symbol.dispose]() {
-        return this.closeSync();
+        this.closeSync();
     }
     /**
      * Default implementation maps to `sync`.
@@ -142,18 +142,12 @@ export class PreloadFile extends File {
      * Creates a file with `path` and, optionally, the given contents.
      * Note that, if contents is specified, it will be mutated by the file.
      */
-    constructor(
-    /**
-     * The file system that created the file.
-     * @internal
-     */
-    fs, path, flag, stats, 
+    constructor(fs, path, flag, stats, 
     /**
      * A buffer containing the entire contents of the file.
      */
     _buffer = new Uint8Array(new ArrayBuffer(0, fs.metadata().noResizableBuffers ? {} : { maxByteLength: size_max }))) {
         super(fs, path);
-        this.fs = fs;
         this.flag = flag;
         this.stats = stats;
         this._buffer = _buffer;
@@ -280,12 +274,12 @@ export class PreloadFile extends File {
         if (length > this._buffer.length) {
             const data = new Uint8Array(length - this._buffer.length);
             // Write will set stats.size and handle syncing.
-            this.writeSync(data, 0, data.length, this._buffer.length);
+            this._write(data, 0, data.length, this._buffer.length);
             return;
         }
         this.stats.size = length;
         // Truncate.
-        this._buffer = this._buffer.slice(0, length);
+        this._buffer = length ? this._buffer.slice(0, length) : new Uint8Array();
     }
     async truncate(length) {
         this._truncate(length);
@@ -484,12 +478,6 @@ export class PreloadFile extends File {
         this.stats.mode = (this.stats.mode & ~S_IFMT) | type;
         this.syncSync();
     }
-    async [Symbol.asyncDispose]() {
-        await this.close();
-    }
-    [Symbol.dispose]() {
-        this.closeSync();
-    }
 }
 /**
  * For the file systems which do not sync to anything.

package/dist/index.d.ts

@@ -22,3 +22,10 @@ export * from './emulation/index.js';
 import * as fs from './emulation/index.js';
 export { fs };
 export default fs;
+declare global {
+    /**
+     * Global FS emulation. Do not use unless absolutely needed.
+     * @hidden
+     */
+    var __zenfs__: typeof fs;
+}

package/dist/index.js

@@ -22,3 +22,4 @@ export * from './emulation/index.js';
 import * as fs from './emulation/index.js';
 export { fs };
 export default fs;
+globalThis.__zenfs__ = fs;

package/dist/inode.d.ts

@@ -1,26 +1,17 @@
 import { Stats, type StatsLike } from './stats.js';
-/**
- * Alias for an ino.
- * This will be helpful if in the future inode numbers/IDs are changed to strings or numbers.
- */
-export type Ino = bigint;
 /**
  * Room inode
  * @hidden
  */
 export declare const rootIno = 0n;
-/**
- * Generate a random ino
- * @internal
- */
-export declare function randomIno(): Ino;
 /**
  * Generic inode definition that can easily be serialized.
+ * @internal
+ * @todo [BREAKING]
  */
 export declare class Inode implements StatsLike {
-    get data(): Uint8Array;
-    constructor(buffer?: ArrayBufferLike);
-    ino: Ino;
+    constructor(buffer?: ArrayBufferLike | ArrayBufferView);
+    data: bigint;
     size: number;
     mode: number;
     nlink: number;
@@ -30,6 +21,7 @@ export declare class Inode implements StatsLike {
     birthtimeMs: number;
     mtimeMs: number;
     ctimeMs: number;
+    ino: bigint;
     /**
      * Handy function that converts the Inode to a Node Stats object.
      */

package/dist/inode.js

@@ -36,38 +36,28 @@ var __setFunctionName = (this && this.__setFunctionName) || function (f, name, p
     if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
     return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
 };
-import { deserialize, serialize, sizeof, struct, types as t } from 'utilium';
+import { deserialize, sizeof, struct, types as t } from 'utilium';
 import { Stats } from './stats.js';
+import { randomBigInt } from './utils.js';
 /**
  * Room inode
  * @hidden
  */
 export const rootIno = 0n;
-/**
- * Generates a random 32 bit integer, then converts to a hex string
- */
-function _random() {
-    return Math.round(Math.random() * 2 ** 32).toString(16);
-}
-/**
- * Generate a random ino
- * @internal
- */
-export function randomIno() {
-    return BigInt('0x' + _random() + _random());
-}
 /**
  * Generic inode definition that can easily be serialized.
+ * @internal
+ * @todo [BREAKING]
  */
 let Inode = (() => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
     let _classDecorators = [struct()];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _ino_decorators;
-    let _ino_initializers = [];
-    let _ino_extraInitializers = [];
+    let _data_decorators;
+    let _data_initializers = [];
+    let _data_extraInitializers = [];
     let _size_decorators;
     let _size_initializers = [];
     let _size_extraInitializers = [];
@@ -95,13 +85,13 @@ let Inode = (() => {
     let _ctimeMs_decorators;
     let _ctimeMs_initializers = [];
     let _ctimeMs_extraInitializers = [];
+    let _ino_decorators;
+    let _ino_initializers = [];
+    let _ino_extraInitializers = [];
     var Inode = _classThis = class {
-        get data() {
-            return serialize(this);
-        }
         constructor(buffer) {
-            this.ino = __runInitializers(this, _ino_initializers, void 0);
-            this.size = (__runInitializers(this, _ino_extraInitializers), __runInitializers(this, _size_initializers, void 0));
+            this.data = __runInitializers(this, _data_initializers, void 0);
+            this.size = (__runInitializers(this, _data_extraInitializers), __runInitializers(this, _size_initializers, void 0));
             this.mode = (__runInitializers(this, _size_extraInitializers), __runInitializers(this, _mode_initializers, void 0));
             this.nlink = (__runInitializers(this, _mode_extraInitializers), __runInitializers(this, _nlink_initializers, void 0));
             this.uid = (__runInitializers(this, _nlink_extraInitializers), __runInitializers(this, _uid_initializers, void 0));
@@ -110,16 +100,33 @@ let Inode = (() => {
             this.birthtimeMs = (__runInitializers(this, _atimeMs_extraInitializers), __runInitializers(this, _birthtimeMs_initializers, void 0));
             this.mtimeMs = (__runInitializers(this, _birthtimeMs_extraInitializers), __runInitializers(this, _mtimeMs_initializers, void 0));
             this.ctimeMs = (__runInitializers(this, _mtimeMs_extraInitializers), __runInitializers(this, _ctimeMs_initializers, void 0));
-            __runInitializers(this, _ctimeMs_extraInitializers);
+            this.ino = (__runInitializers(this, _ctimeMs_extraInitializers), __runInitializers(this, _ino_initializers, void 0));
+            __runInitializers(this, _ino_extraInitializers);
             if (buffer) {
-                if (buffer.byteLength < sizeof(Inode)) {
-                    throw new RangeError(`Can not create an inode from a buffer less than ${sizeof(Inode)} bytes`);
+                const sz_inode = sizeof(Inode);
+                const oldSize = sz_inode - sizeof('uint64');
+                if (buffer.byteLength < oldSize) {
+                    throw new RangeError(`Can not create an inode from a buffer less than ${oldSize} bytes`);
+                }
+                // Expand the buffer so it is the right size
+                if (buffer.byteLength < sz_inode) {
+                    const newBuffer = new Uint32Array(sz_inode);
+                    // Fill the new buffer with current data
+                    newBuffer.set(new Uint32Array(ArrayBuffer.isView(buffer) ? buffer.buffer : buffer));
+                    /* 	Add a random ino.
+                        This will be different from the actual one,
+                        but `ino` isn't used anywhere so it should be fine.
+                    */
+                    const randomIno = crypto.getRandomValues(new Uint32Array(2));
+                    newBuffer.set(randomIno, sz_inode - 2);
+                    buffer = newBuffer;
                 }
                 deserialize(this, buffer);
                 return;
             }
             // set defaults on a fresh inode
-            this.ino = randomIno();
+            this.ino = randomBigInt();
+            this.data = randomBigInt();
             this.nlink = 1;
             this.size = 4096;
             const now = Date.now();
@@ -184,7 +191,7 @@ let Inode = (() => {
     __setFunctionName(_classThis, "Inode");
     (() => {
         const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-        _ino_decorators = [(_a = t).uint64.bind(_a)];
+        _data_decorators = [(_a = t).uint64.bind(_a)];
         _size_decorators = [(_b = t).uint32.bind(_b)];
         _mode_decorators = [(_c = t).uint16.bind(_c)];
         _nlink_decorators = [(_d = t).uint32.bind(_d)];
@@ -194,7 +201,8 @@ let Inode = (() => {
         _birthtimeMs_decorators = [(_h = t).float64.bind(_h)];
         _mtimeMs_decorators = [(_j = t).float64.bind(_j)];
         _ctimeMs_decorators = [(_k = t).float64.bind(_k)];
-        __esDecorate(null, null, _ino_decorators, { kind: "field", name: "ino", static: false, private: false, access: { has: obj => "ino" in obj, get: obj => obj.ino, set: (obj, value) => { obj.ino = value; } }, metadata: _metadata }, _ino_initializers, _ino_extraInitializers);
+        _ino_decorators = [(_l = t).uint64.bind(_l)];
+        __esDecorate(null, null, _data_decorators, { kind: "field", name: "data", static: false, private: false, access: { has: obj => "data" in obj, get: obj => obj.data, set: (obj, value) => { obj.data = value; } }, metadata: _metadata }, _data_initializers, _data_extraInitializers);
         __esDecorate(null, null, _size_decorators, { kind: "field", name: "size", static: false, private: false, access: { has: obj => "size" in obj, get: obj => obj.size, set: (obj, value) => { obj.size = value; } }, metadata: _metadata }, _size_initializers, _size_extraInitializers);
         __esDecorate(null, null, _mode_decorators, { kind: "field", name: "mode", static: false, private: false, access: { has: obj => "mode" in obj, get: obj => obj.mode, set: (obj, value) => { obj.mode = value; } }, metadata: _metadata }, _mode_initializers, _mode_extraInitializers);
         __esDecorate(null, null, _nlink_decorators, { kind: "field", name: "nlink", static: false, private: false, access: { has: obj => "nlink" in obj, get: obj => obj.nlink, set: (obj, value) => { obj.nlink = value; } }, metadata: _metadata }, _nlink_initializers, _nlink_extraInitializers);
@@ -204,6 +212,7 @@ let Inode = (() => {
         __esDecorate(null, null, _birthtimeMs_decorators, { kind: "field", name: "birthtimeMs", static: false, private: false, access: { has: obj => "birthtimeMs" in obj, get: obj => obj.birthtimeMs, set: (obj, value) => { obj.birthtimeMs = value; } }, metadata: _metadata }, _birthtimeMs_initializers, _birthtimeMs_extraInitializers);
         __esDecorate(null, null, _mtimeMs_decorators, { kind: "field", name: "mtimeMs", static: false, private: false, access: { has: obj => "mtimeMs" in obj, get: obj => obj.mtimeMs, set: (obj, value) => { obj.mtimeMs = value; } }, metadata: _metadata }, _mtimeMs_initializers, _mtimeMs_extraInitializers);
         __esDecorate(null, null, _ctimeMs_decorators, { kind: "field", name: "ctimeMs", static: false, private: false, access: { has: obj => "ctimeMs" in obj, get: obj => obj.ctimeMs, set: (obj, value) => { obj.ctimeMs = value; } }, metadata: _metadata }, _ctimeMs_initializers, _ctimeMs_extraInitializers);
+        __esDecorate(null, null, _ino_decorators, { kind: "field", name: "ino", static: false, private: false, access: { has: obj => "ino" in obj, get: obj => obj.ino, set: (obj, value) => { obj.ino = value; } }, metadata: _metadata }, _ino_initializers, _ino_extraInitializers);
         __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 });

package/dist/mixins/async.d.ts

@@ -7,16 +7,9 @@ export type AsyncOperation = {
     [K in keyof AsyncFSMethods]: [K, ...Parameters<FileSystem[K]>];
 }[keyof AsyncFSMethods];
 /**
- * Async() implements synchronous methods on an asynchronous file system
- *
- * Implementing classes must define `_sync` for the synchronous file system used as a cache.
- *
- * Synchronous methods on an asynchronous FS are implemented by performing operations over the in-memory copy,
- * while asynchronously pipelining them to the backing store.
- * During loading, the contents of the async file system are preloaded into the synchronous store.
- *
+ * @internal
  */
-export declare function Async<T extends typeof FileSystem>(FS: T): Mixin<T, {
+export interface Async {
     /**
      * @internal @protected
      */
@@ -33,4 +26,16 @@ export declare function Async<T extends typeof FileSystem>(FS: T): Mixin<T, {
     readdirSync(path: string): string[];
     linkSync(srcpath: string, dstpath: string): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}>;
+}
+/**
+ * Async() implements synchronous methods on an asynchronous file system
+ *
+ * Implementing classes must define `_sync` for the synchronous file system used as a cache.
+ *
+ * Synchronous methods on an asynchronous FS are implemented by performing operations over the in-memory copy,
+ * while asynchronously pipelining them to the backing store.
+ * During loading, the contents of the async file system are preloaded into the synchronous store.
+ *
+ */
+export declare function Async<const T extends typeof FileSystem>(FS: T): Mixin<T, Async>;
+export declare function asyncPatch<T extends typeof FileSystem>(fs: Mixin<T, Async>): void;

package/dist/mixins/async.js

@@ -80,6 +80,7 @@ export function Async(FS) {
         }
         async ready() {
             await super.ready();
+            await this.queueDone();
             if (this._isInitialized || this._disableSync) {
                 return;
             }
@@ -131,7 +132,7 @@ export function Async(FS) {
         }
         openFileSync(path, flag) {
             this.checkSync(path, 'openFile');
-            const file = this._sync.openFileSync(path, flag);
+            const file = this._sync.openFileSync(path, flag + '+');
             const stats = file.statSync();
             const buffer = new Uint8Array(stats.size);
             file.readSync(buffer);
@@ -228,3 +229,4 @@ export function Async(FS) {
     }
     return AsyncFS;
 }
+export function asyncPatch(fs) { }

package/dist/utils.d.ts

@@ -50,13 +50,6 @@ export declare function decodeDirListing(data: Uint8Array): Record<string, bigin
  */
 export declare function encodeDirListing(data: Record<string, bigint>): Uint8Array;
 export type Callback<Args extends unknown[] = []> = (e?: ErrnoError, ...args: OptionalTuple<Args>) => unknown;
-/**
- * converts Date or number to a integer UNIX timestamp
- * Grabbed from NodeJS sources (lib/fs.js)
- *
- * @internal
- */
-export declare function _toUnixTimestamp(time: Date | number): number;
 /**
  * Normalizes a mode
  * @internal
@@ -88,3 +81,8 @@ export declare function normalizeOptions(options: fs.WriteFileOptions | (fs.Enco
     mode: number;
 };
 export type Concrete<T extends ClassLike> = Pick<T, keyof T> & (new (...args: any[]) => InstanceType<T>);
+/**
+ * Generate a random ino
+ * @internal
+ */
+export declare function randomBigInt(): bigint;