@zenfs/core 0.4.1 → 0.5.0

package/dist/file.js

@@ -16,209 +16,118 @@ export var ActionType;
     // Indicates that the code should create the file.
     ActionType[ActionType["CREATE"] = 3] = "CREATE";
 })(ActionType = ActionType || (ActionType = {}));
-/**
- * Represents one of the following file flags. A convenience object.
- *
- * - r: 	Open file for reading. An exception occurs if the file does not exist.
- * - r+: 	Open file for reading and writing. An exception occurs if the file does not exist.
- * - rs: 	Open file for reading in synchronous mode. Instructs the filesystem to not cache writes.
- * - rs+: 	Open file for reading and writing, and opens the file in synchronous mode.
- * - w: 	Open file for writing. The file is created (if it does not exist) or truncated (if it exists).
- * - wx: 	Like 'w' but opens the file in exclusive mode.
- * - w+: 	Open file for reading and writing. The file is created (if it does not exist) or truncated (if it exists).
- * - wx+: 	Like 'w+' but opens the file in exclusive mode.
- * - a: 	Open file for appending. The file is created if it does not exist.
- * - ax: 	Like 'a' but opens the file in exclusive mode.
- * - a+: 	Open file for reading and appending. The file is created if it does not exist.
- * - ax+: 	Like 'a+' but opens the file in exclusive mode.
- *
- * Exclusive mode ensures that the file path is newly created.
- */
-export class FileFlag {
-    /**
-     * Get an object representing the given file flag.
-     * @param flag The string or number representing the flag
-     * @return The FileFlag object representing the flag
-     * @throw when the flag string is invalid
-     */
-    static Get(flag) {
-        // Check cache first.
-        if (!FileFlag.cache.has(flag)) {
-            FileFlag.cache.set(flag, new FileFlag(flag));
-        }
-        return FileFlag.cache.get(flag);
-    }
-    /**
-     * @param flag The string or number representing the flag
-     * @throw when the flag is invalid
-     */
-    constructor(flag) {
-        if (typeof flag == 'number') {
-            flag = FileFlag.StringOf(flag);
-        }
-        if (!FileFlag.validStrings.includes(flag)) {
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid flag string: ' + flag);
-        }
-        this._flag = flag;
-    }
-    /**
-     * @param flag The number representing the flag
-     * @returns The string representing the flag
-     * @throws when the flag number is invalid
-     */
-    static StringOf(flag) {
-        // based on https://github.com/nodejs/node/blob/abbdc3efaa455e6c907ebef5409ac8b0f222f969/lib/internal/fs/utils.js#L619
-        switch (flag) {
-            case O_RDONLY:
-                return 'r';
-            case O_RDONLY | O_SYNC:
-                return 'rs';
-            case O_RDWR:
-                return 'r+';
-            case O_RDWR | O_SYNC:
-                return 'rs+';
-            case O_TRUNC | O_CREAT | O_WRONLY:
-                return 'w';
-            case O_TRUNC | O_CREAT | O_WRONLY | O_EXCL:
-                return 'wx';
-            case O_TRUNC | O_CREAT | O_RDWR:
-                return 'w+';
-            case O_TRUNC | O_CREAT | O_RDWR | O_EXCL:
-                return 'wx+';
-            case O_APPEND | O_CREAT | O_WRONLY:
-                return 'a';
-            case O_APPEND | O_CREAT | O_WRONLY | O_EXCL:
-                return 'ax';
-            case O_APPEND | O_CREAT | O_RDWR:
-                return 'a+';
-            case O_APPEND | O_CREAT | O_RDWR | O_EXCL:
-                return 'ax+';
-            default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid flag number: ' + flag);
-        }
-    }
-    /**
-     * @param flag The string representing the flag
-     * @returns The number representing the flag
-     * @throws when the flag string is invalid
-     */
-    static NumberOf(flag) {
-        switch (flag) {
-            case 'r':
-                return O_RDONLY;
-            case 'rs':
-                return O_RDONLY | O_SYNC;
-            case 'r+':
-                return O_RDWR;
-            case 'rs+':
-                return O_RDWR | O_SYNC;
-            case 'w':
-                return O_TRUNC | O_CREAT | O_WRONLY;
-            case 'wx':
-                return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
-            case 'w+':
-                return O_TRUNC | O_CREAT | O_RDWR;
-            case 'wx+':
-                return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
-            case 'a':
-                return O_APPEND | O_CREAT | O_WRONLY;
-            case 'ax':
-                return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;
-            case 'a+':
-                return O_APPEND | O_CREAT | O_RDWR;
-            case 'ax+':
-                return O_APPEND | O_CREAT | O_RDWR | O_EXCL;
-            default:
-                throw new ApiError(ErrorCode.EINVAL, 'Invalid flag string: ' + flag);
-        }
-    }
-    /**
-     * Get the underlying flag string for this flag.
-     */
-    toString() {
-        return this._flag;
-    }
-    /**
-     * Get the equivalent mode (0b0xxx: read, write, execute)
-     * Note: Execute will always be 0
-     */
-    get mode() {
-        let mode = 0;
-        mode <<= 1;
-        mode += +this.isReadable();
-        mode <<= 1;
-        mode += +this.isWriteable();
-        mode <<= 1;
-        return mode;
-    }
-    /**
-     * Returns true if the file is readable.
-     */
-    isReadable() {
-        return this._flag.indexOf('r') != -1 || this._flag.indexOf('+') != -1;
-    }
-    /**
-     * Returns true if the file is writeable.
-     */
-    isWriteable() {
-        return this._flag.indexOf('w') != -1 || this._flag.indexOf('a') != -1 || this._flag.indexOf('+') != -1;
+const validFlags = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
+export function parseFlag(flag) {
+    if (typeof flag === 'number') {
+        return flagToString(flag);
     }
-    /**
-     * Returns true if the file mode should truncate.
-     */
-    isTruncating() {
-        return this._flag.indexOf('w') !== -1;
+    if (!validFlags.includes(flag)) {
+        throw new Error('Invalid flag string: ' + flag);
     }
-    /**
-     * Returns true if the file is appendable.
-     */
-    isAppendable() {
-        return this._flag.indexOf('a') !== -1;
+    return flag;
+}
+export function flagToString(flag) {
+    switch (flag) {
+        case O_RDONLY:
+            return 'r';
+        case O_RDONLY | O_SYNC:
+            return 'rs';
+        case O_RDWR:
+            return 'r+';
+        case O_RDWR | O_SYNC:
+            return 'rs+';
+        case O_TRUNC | O_CREAT | O_WRONLY:
+            return 'w';
+        case O_TRUNC | O_CREAT | O_WRONLY | O_EXCL:
+            return 'wx';
+        case O_TRUNC | O_CREAT | O_RDWR:
+            return 'w+';
+        case O_TRUNC | O_CREAT | O_RDWR | O_EXCL:
+            return 'wx+';
+        case O_APPEND | O_CREAT | O_WRONLY:
+            return 'a';
+        case O_APPEND | O_CREAT | O_WRONLY | O_EXCL:
+            return 'ax';
+        case O_APPEND | O_CREAT | O_RDWR:
+            return 'a+';
+        case O_APPEND | O_CREAT | O_RDWR | O_EXCL:
+            return 'ax+';
+        default:
+            throw new Error('Invalid flag number: ' + flag);
     }
-    /**
-     * Returns true if the file is open in synchronous mode.
-     */
-    isSynchronous() {
-        return this._flag.indexOf('s') !== -1;
+}
+export function flagToNumber(flag) {
+    switch (flag) {
+        case 'r':
+            return O_RDONLY;
+        case 'rs':
+            return O_RDONLY | O_SYNC;
+        case 'r+':
+            return O_RDWR;
+        case 'rs+':
+            return O_RDWR | O_SYNC;
+        case 'w':
+            return O_TRUNC | O_CREAT | O_WRONLY;
+        case 'wx':
+            return O_TRUNC | O_CREAT | O_WRONLY | O_EXCL;
+        case 'w+':
+            return O_TRUNC | O_CREAT | O_RDWR;
+        case 'wx+':
+            return O_TRUNC | O_CREAT | O_RDWR | O_EXCL;
+        case 'a':
+            return O_APPEND | O_CREAT | O_WRONLY;
+        case 'ax':
+            return O_APPEND | O_CREAT | O_WRONLY | O_EXCL;
+        case 'a+':
+            return O_APPEND | O_CREAT | O_RDWR;
+        case 'ax+':
+            return O_APPEND | O_CREAT | O_RDWR | O_EXCL;
+        default:
+            throw new Error('Invalid flag string: ' + flag);
     }
-    /**
-     * Returns true if the file is open in exclusive mode.
-     */
-    isExclusive() {
-        return this._flag.indexOf('x') !== -1;
+}
+export function flagToMode(flag) {
+    let mode = 0;
+    mode <<= 1;
+    mode += +isReadable(flag);
+    mode <<= 1;
+    mode += +isWriteable(flag);
+    mode <<= 1;
+    return mode;
+}
+export function isReadable(flag) {
+    return flag.indexOf('r') !== -1 || flag.indexOf('+') !== -1;
+}
+export function isWriteable(flag) {
+    return flag.indexOf('w') !== -1 || flag.indexOf('a') !== -1 || flag.indexOf('+') !== -1;
+}
+export function isTruncating(flag) {
+    return flag.indexOf('w') !== -1;
+}
+export function isAppendable(flag) {
+    return flag.indexOf('a') !== -1;
+}
+export function isSynchronous(flag) {
+    return flag.indexOf('s') !== -1;
+}
+export function isExclusive(flag) {
+    return flag.indexOf('x') !== -1;
+}
+export function pathExistsAction(flag) {
+    if (isExclusive(flag)) {
+        return ActionType.THROW;
     }
-    /**
-     * Returns one of the static fields on this object that indicates the
-     * appropriate response to the path existing.
-     */
-    pathExistsAction() {
-        if (this.isExclusive()) {
-            return ActionType.THROW;
-        }
-        if (this.isTruncating()) {
-            return ActionType.TRUNCATE;
-        }
-        return ActionType.NOP;
+    if (isTruncating(flag)) {
+        return ActionType.TRUNCATE;
     }
-    /**
-     * Returns one of the static fields on this object that indicates the
-     * appropriate response to the path not existing.
-     */
-    pathNotExistsAction() {
-        if ((this.isWriteable() || this.isAppendable()) && this._flag != 'r+') {
-            return ActionType.CREATE;
-        }
-        return ActionType.THROW;
+    return ActionType.NOP;
+}
+export function pathNotExistsAction(flag) {
+    if ((isWriteable(flag) || isAppendable(flag)) && flag !== 'r+') {
+        return ActionType.CREATE;
     }
+    return ActionType.THROW;
 }
-/**
- * Contains cached FileMode instances.
- */
-FileFlag.cache = new Map();
-/**
- * Array of valid mode strings.
- */
-FileFlag.validStrings = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', 'ax', 'a+', 'ax+'];
 export class File {
     /**
      * Asynchronous `datasync`.
@@ -284,7 +193,7 @@ export class PreloadFile extends File {
         if (this.stats.size == _buffer.byteLength) {
             return;
         }
-        if (this.flag.isReadable()) {
+        if (isReadable(this.flag)) {
             throw new Error(`Size mismatch: buffer length ${_buffer.byteLength}, stats size ${this.stats.size}`);
         }
         this._dirty = true;
@@ -305,7 +214,7 @@ export class PreloadFile extends File {
      * @return The current file position.
      */
     get position() {
-        if (this.flag.isAppendable()) {
+        if (isAppendable(this.flag)) {
             return this.stats.size;
         }
         return this._position;
@@ -335,7 +244,7 @@ export class PreloadFile extends File {
      */
     truncate(len) {
         this.truncateSync(len);
-        if (this.flag.isSynchronous() && !this.fs.metadata().synchronous) {
+        if (isSynchronous(this.flag) && !this.fs.metadata().synchronous) {
             return this.sync();
         }
     }
@@ -345,7 +254,7 @@ export class PreloadFile extends File {
      */
     truncateSync(len) {
         this._dirty = true;
-        if (!this.flag.isWriteable()) {
+        if (!isWriteable(this.flag)) {
             throw new ApiError(ErrorCode.EPERM, 'File not opened with a writeable mode.');
         }
         this.stats.mtimeMs = Date.now();
@@ -353,7 +262,7 @@ export class PreloadFile extends File {
             const buf = new Uint8Array(len - this._buffer.length);
             // Write will set stats.size for us.
             this.writeSync(buf, 0, buf.length, this._buffer.length);
-            if (this.flag.isSynchronous() && this.fs.metadata().synchronous) {
+            if (isSynchronous(this.flag) && this.fs.metadata().synchronous) {
                 this.syncSync();
             }
             return;
@@ -361,7 +270,7 @@ export class PreloadFile extends File {
         this.stats.size = len;
         // Truncate buffer to 'len'.
         this._buffer = this._buffer.subarray(0, len);
-        if (this.flag.isSynchronous() && this.fs.metadata().synchronous) {
+        if (isSynchronous(this.flag) && this.fs.metadata().synchronous) {
             this.syncSync();
         }
     }
@@ -396,7 +305,7 @@ export class PreloadFile extends File {
     writeSync(buffer, offset = 0, length = this.stats.size, position = 0) {
         this._dirty = true;
         position ?? (position = this.position);
-        if (!this.flag.isWriteable()) {
+        if (!isWriteable(this.flag)) {
             throw new ApiError(ErrorCode.EPERM, 'File not opened with a writeable mode.');
         }
         const endFp = position + length;
@@ -417,7 +326,7 @@ export class PreloadFile extends File {
         this._buffer.set(buffer.slice(offset, offset + length), position);
         const len = this._buffer.byteOffset;
         this.stats.mtimeMs = Date.now();
-        if (this.flag.isSynchronous()) {
+        if (isSynchronous(this.flag)) {
             this.syncSync();
             return len;
         }
@@ -450,7 +359,7 @@ export class PreloadFile extends File {
      * @returns number of bytes written
      */
     readSync(buffer, offset = 0, length = this.stats.size, position = 0) {
-        if (!this.flag.isReadable()) {
+        if (!isReadable(this.flag)) {
             throw new ApiError(ErrorCode.EPERM, 'File not opened with a readable mode.');
         }
         position ?? (position = this.position);

package/dist/filesystem.d.ts

@@ -1,6 +1,6 @@
 import { ApiError } from './ApiError.js';
 import type { Stats } from './stats.js';
-import type { File, FileFlag } from './file.js';
+import type { File } from './file.js';
 import type { Cred } from './cred.js';
 export type NoArgCallback = (e?: ApiError) => unknown;
 export type TwoArgCallback<T> = (e?: ApiError, rv?: T) => unknown;
@@ -71,24 +71,24 @@ export declare abstract class FileSystem {
      * @param p The path to open.
      * @param flag The flag to use when opening the file.
      */
-    abstract openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    abstract openFile(path: string, flag: string, cred: Cred): Promise<File>;
     /**
      * Opens the file at path p with the given flag. The file must exist.
      * @param p The path to open.
      * @param flag The flag to use when opening the file.
      * @return A File object corresponding to the opened file.
      */
-    abstract openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    abstract openFileSync(path: string, flag: string, cred: Cred): File;
     /**
      * Create the file at path p with the given mode. Then, open it with the given
      * flag.
      */
-    abstract createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    abstract createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
     /**
      * Create the file at path p with the given mode. Then, open it with the given
      * flag.
      */
-    abstract createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
+    abstract createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
     /**
      * Asynchronous `unlink`.
      */
@@ -162,8 +162,8 @@ declare abstract class SyncFileSystem extends FileSystem {
     exists(path: string, cred: Cred): Promise<boolean>;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     stat(path: string, cred: Cred): Promise<Stats>;
-    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
-    openFile(path: string, flag: FileFlag, cred: Cred): Promise<File>;
+    createFile(path: string, flag: string, mode: number, cred: Cred): Promise<File>;
+    openFile(path: string, flag: string, cred: Cred): Promise<File>;
     unlink(path: string, cred: Cred): Promise<void>;
     rmdir(path: string, cred: Cred): Promise<void>;
     mkdir(path: string, mode: number, cred: Cred): Promise<void>;
@@ -182,8 +182,8 @@ declare abstract class AsyncFileSystem {
     metadata(): FileSystemMetadata;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
     statSync(path: string, cred: Cred): Stats;
-    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
-    openFileSync(path: string, flag: FileFlag, cred: Cred): File;
+    createFileSync(path: string, flag: string, mode: number, cred: Cred): File;
+    openFileSync(path: string, flag: string, cred: Cred): File;
     unlinkSync(path: string, cred: Cred): void;
     rmdirSync(path: string, cred: Cred): void;
     mkdirSync(path: string, mode: number, cred: Cred): void;
@@ -199,8 +199,8 @@ declare abstract class ReadonlyFileSystem {
     metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
     renameSync(oldPath: string, newPath: string, cred: Cred): void;
-    createFile(path: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
-    createFileSync(path: string, flag: FileFlag, mode: number, cred: Cred): File;
+    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>;

package/dist/stats.d.ts

@@ -154,10 +154,10 @@ export declare abstract class StatsCommon<T extends number | bigint> implements
      */
     hasAccess(mode: number, cred: Cred): boolean;
     /**
-     * Convert the current stats object into a cred object
+     * Convert the current stats object into a credentials object
      * @internal
      */
-    getCred(uid?: number, gid?: number): Cred;
+    cred(uid?: number, gid?: number): Cred;
     /**
      * 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.
@@ -202,3 +202,19 @@ export declare class BigIntStats extends StatsCommon<bigint> implements Node.Big
      */
     static clone(stats: BigIntStats | Stats): BigIntStats;
 }
+/**
+ * @returns true if stats is a file.
+ */
+export declare function isFile(stats: StatsLike): boolean;
+/**
+ * @returns True if stats is a directory.
+ */
+export declare function isDirectory(stats: StatsLike): boolean;
+/**
+ * @returns true if stats is a symbolic link
+ */
+export declare function isSymbolicLink(stats: StatsLike): boolean;
+export declare function isSocket(): boolean;
+export declare function isBlockDevice(): boolean;
+export declare function isCharacterDevice(): boolean;
+export declare function isFIFO(): boolean;

package/dist/stats.js

@@ -1,4 +1,3 @@
-import { Cred } from './cred.js';
 import { S_IFDIR, S_IFLNK, S_IFMT, S_IFREG } from './emulation/constants.js';
 /**
  * Indicates the type of the given file. Applied to 'mode'.
@@ -177,11 +176,18 @@ export class StatsCommon {
         return !result;
     }
     /**
-     * Convert the current stats object into a cred object
+     * Convert the current stats object into a credentials object
      * @internal
      */
-    getCred(uid = Number(this.uid), gid = Number(this.gid)) {
-        return new Cred(uid, gid, Number(this.uid), Number(this.gid), uid, gid);
+    cred(uid = Number(this.uid), gid = Number(this.gid)) {
+        return {
+            uid,
+            gid,
+            suid: Number(this.uid),
+            sgid: Number(this.gid),
+            euid: uid,
+            egid: gid,
+        };
     }
     /**
      * Change the mode of the file. We use this helper function to prevent messing
@@ -246,3 +252,33 @@ export class BigIntStats extends StatsCommon {
     }
 }
 BigIntStats;
+/**
+ * @returns true if stats is a file.
+ */
+export function isFile(stats) {
+    return (Number(stats.mode) & S_IFMT) === S_IFREG;
+}
+/**
+ * @returns True if stats is a directory.
+ */
+export function isDirectory(stats) {
+    return (Number(stats.mode) & S_IFMT) === S_IFDIR;
+}
+/**
+ * @returns true if stats is a symbolic link
+ */
+export function isSymbolicLink(stats) {
+    return (Number(stats.mode) & S_IFMT) === S_IFLNK;
+}
+export function isSocket() {
+    return false;
+}
+export function isBlockDevice() {
+    return false;
+}
+export function isCharacterDevice() {
+    return false;
+}
+export function isFIFO() {
+    return false;
+}

package/license.md

@@ -22,8 +22,8 @@ SOFTWARE.
 
 This license applies to all parts of ZenFS, except for the following items:
 
-- The test fixtures located in `test/fixtures/node`. Their license follows:
-  """
+-   The test fixtures located in `test/fixtures/node`. Their license follows:
+    """
     Copyright Joyent, Inc. and other Node contributors. All rights reserved.
     Permission is hereby granted, free of charge, to any person obtaining a copy
     of this software and associated documentation files (the "Software"), to
@@ -42,4 +42,4 @@ This license applies to all parts of ZenFS, except for the following items:
     LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
     FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
     IN THE SOFTWARE.
-  """
+    """

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "0.4.1",
+	"version": "0.5.0",
 	"description": "A filesystem in your browser",
 	"main": "dist/index.js",
 	"types": "dist",
@@ -41,9 +41,9 @@
 		}
 	},
 	"scripts": {
-		"format": "prettier --write src test",
-		"format:check": "prettier --check src test",
-		"lint": "eslint src test && tsc -p tsconfig.json --noEmit",
+		"format": "prettier --write .",
+		"format:check": "prettier --check .",
+		"lint": "eslint src tests && tsc -p tsconfig.json --noEmit",
 		"test": "cross-env NODE_OPTIONS=--experimental-vm-modules npx jest",
 		"build": "node scripts/build.js",
 		"build:docs": "typedoc --out docs --name ZenFS src/index.ts",
@@ -65,7 +65,7 @@
 		"esbuild": "^0.17.18",
 		"eslint": "^8.36.0",
 		"jest": "^29.5.0",
-		"prettier": "^2.8.7",
+		"prettier": "^3.2.5",
 		"ts-jest": "^29.1.0",
 		"typedoc": "^0.25.1",
 		"typescript": "^4.9.5"

package/readme.md

@@ -1,27 +1,25 @@
 # ZenFS
 
-ZenFS is a file system that emulates the [Node JS file system API](http://nodejs.org/api/fs.html).
+ZenFS is a file system that emulates the [NodeJS filesystem API](http://nodejs.org/api/fs.html).
 
-It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate nicely with other tools.
+It works using a system of backends, which are used by ZenFS to store and retrieve data. ZenFS can also integrate with other tools.
 
 ZenFS is a fork of [BrowserFS](https://github.com/jvilk/BrowserFS).
 
 ## Backends
 
-ZenFS is highly extensible, and includes a few built-in backends:
+ZenFS is modular and extensible. The core includes a few built-in backends:
 
--   `InMemory`: Stores files in-memory. It is a temporary file store that clears when the user navigates away.
--   `Overlay`: Mount a read-only file system as read-write by overlaying a writable file system on top of it. Like Docker's overlayfs, it will only write changed files to the writable file system.
--   `AsyncMirror`: Use an asynchronous backend synchronously. Invaluable for Emscripten; let your Emscripten applications write to larger file stores with no additional effort!
+-   `InMemory`: Stores files in-memory. This is cleared when the runtime ends (e.g. a user navigating away from a web page or a Node process exiting)
+-   `Overlay`: Use read-only file system as read-write by overlaying a writable file system on top of it.
+-   `AsyncMirror`: Use an asynchronous backend synchronously. This is very helpful for asynchronous backends
 
 > [!NOTE]
 > When constructed, `AsyncMirror` loads the entire contents of the async file system into a synchronous backend. It performs operations on the synchronous file system and then queues them to be mirrored onto the asynchronous backend.
 
-More backends can be defined by separate libraries, as long as they implement `FileSystem`.
+ZenFS supports a number of other backends. Many are provided as seperate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and/or providing a `Backend` object.
 
-ZenFS supports a number of other backends. Many are provided as seperate packages under `@zenfs`.
-
-For more information, see the [API documentation for ZenFS](https://zen-fs.github.io/core).
+For more information, see the [docs](https://zen-fs.github.io/core).
 
 ## Installing
 
@@ -32,10 +30,12 @@ npm install @zenfs/core
 ## Usage
 
 > [!NOTE]
-> The examples are written in ESM. If you are using CJS, you can `require` the package. If running in a browser you can add a script tag to your HTML pointing to the `browser.min.js` and use ZenFS via the global `ZenFS` object.
+> The examples are written in ESM.  
+> If you are using CJS, you can `require` the package.  
+> If using a browser environment without support for `type=module` in `script` tags, you can add a `script` tag to your HTML pointing to the `browser.min.js` and use ZenFS with the global `ZenFS` object.
 
 ```js
-import fs from '@zenfs/core';
+import fs from '@zenfs/core'; // You can also use the named export, `fs`
 
 fs.writeFileSync('/test.txt', 'Cool, I can do this in any JS environment (including browsers)!');