@zenfs/core 2.1.1 → 2.2.1

package/dist/backends/backend.d.ts

@@ -1,5 +1,5 @@
 import type { RequiredKeys } from 'utilium';
-import type { FileSystem } from '../internal/filesystem.js';
+import type { CaseFold, FileSystem } from '../internal/filesystem.js';
 type OptionType = 'string' | 'number' | 'bigint' | 'boolean' | 'symbol' | 'undefined' | 'object' | 'function' | string | ((arg: any) => boolean) | {
     [Symbol.hasInstance](instance: any): boolean;
     toString(): string;
@@ -33,6 +33,10 @@ export interface SharedConfig {
      * If set, disables the sync cache and sync operations on async file systems.
      */
     disableAsyncCache?: boolean;
+    /**
+     * If set, sets case folding for the file system(s).
+     */
+    caseFold?: CaseFold;
 }
 /**
  * A backend

package/dist/backends/single_buffer.js

@@ -710,7 +710,7 @@ export class SingleBufferStore extends BufferView {
         return this._fs;
     }
     set fs(fs) {
-        if (this.buffer instanceof SharedArrayBuffer)
+        if (this.buffer.constructor.name === 'SharedArrayBuffer')
             fs === null || fs === void 0 ? void 0 : fs.attributes.set('no_id_tables', true);
         this._fs = fs;
     }

package/dist/config.d.ts

@@ -1,6 +1,12 @@
 import type { Backend, BackendConfiguration, FilesystemOf, SharedConfig } from './backends/backend.js';
 import type { Device, DeviceDriver } from './internal/devices.js';
 import { log } from 'kerium';
+import { FileSystem } from './internal/filesystem.js';
+/**
+ * Update the configuration of a file system.
+ * @category Backends and Configuration
+ */
+export declare function configureFileSystem(fs: FileSystem, config: SharedConfig): void;
 /**
  * Configuration for a specific mount point
  * @category Backends and Configuration

package/dist/config.js

@@ -7,6 +7,16 @@ import { FileSystem } from './internal/filesystem.js';
 import { _setAccessChecks } from './vfs/config.js';
 import * as fs from './vfs/index.js';
 import { mounts } from './vfs/shared.js';
+/**
+ * Update the configuration of a file system.
+ * @category Backends and Configuration
+ */
+export function configureFileSystem(fs, config) {
+    if (config.disableAsyncCache)
+        fs.attributes.set('no_async_preload');
+    if (config.caseFold)
+        fs.attributes.set('case_fold', config.caseFold);
+}
 function isMountConfig(arg) {
     return isBackendConfig(arg) || isBackend(arg) || arg instanceof FileSystem;
 }
@@ -46,8 +56,7 @@ export async function resolveMountConfig(configuration, _depth = 0) {
     }
     checkOptions(backend, configuration);
     const mount = (await backend.create(configuration));
-    if (configuration.disableAsyncCache)
-        mount.attributes.set('no_async_preload');
+    configureFileSystem(mount, configuration);
     await mount.ready();
     return mount;
 }
@@ -98,10 +107,11 @@ export function addDevice(driver, options) {
  * @see Configuration
  */
 export async function configure(configuration) {
-    var _a;
-    const uid = 'uid' in configuration ? configuration.uid || 0 : 0;
-    const gid = 'gid' in configuration ? configuration.gid || 0 : 0;
-    Object.assign(defaultContext.credentials, createCredentials({ uid, gid }));
+    var _a, _b;
+    Object.assign(defaultContext.credentials, createCredentials({
+        uid: configuration.uid || 0,
+        gid: configuration.gid || 0,
+    }));
     _setAccessChecks(!configuration.disableAccessChecks);
     if (configuration.log)
         log.configure(configuration.log);
@@ -111,13 +121,17 @@ export async function configure(configuration) {
             const point = _point.startsWith('/') ? _point : '/' + _point;
             if (isBackendConfig(mountConfig)) {
                 (_a = mountConfig.disableAsyncCache) !== null && _a !== void 0 ? _a : (mountConfig.disableAsyncCache = configuration.disableAsyncCache || false);
+                (_b = mountConfig.caseFold) !== null && _b !== void 0 ? _b : (mountConfig.caseFold = configuration.caseFold);
             }
             if (point == '/')
                 fs.umount('/');
             await mount(point, await resolveMountConfig(mountConfig));
         }
     }
-    if (configuration.addDevices) {
+    for (const fs of mounts.values()) {
+        configureFileSystem(fs, configuration);
+    }
+    if (configuration.addDevices && !mounts.has('/dev')) {
         const devfs = new DeviceFS();
         devfs.addDefaults();
         await devfs.ready();

package/dist/index.js

@@ -10,4 +10,5 @@ export * from './vfs/index.js';
 export { fs };
 import * as fs from './vfs/index.js';
 export default fs;
-globalThis.__zenfs__ = fs;
+import $pkg from '../package.json' with { type: 'json' };
+globalThis.__zenfs__ = Object.assign(Object.create(fs), { _version: $pkg.version });

package/dist/internal/filesystem.d.ts

@@ -29,13 +29,14 @@ export interface UsageInfo {
      */
     freeNodes?: number;
 }
+export type CaseFold = 'upper' | 'lower';
 /**
  * Attributes that control how the file system interacts with the VFS.
  * No options are set by default.
  * @category Internals
  * @internal
  */
-export type FileSystemAttributes = {
+export interface FileSystemAttributes {
     /**
      * If set disables async file systems from preloading their contents.
      * This means *sync operations will not work* (unless the contents are cached)
@@ -79,7 +80,11 @@ export type FileSystemAttributes = {
      * @experimental
      */
     sync: void;
-};
+    /**
+     * If set, the VFS layer will convert paths to lower/upper case.
+     */
+    case_fold?: CaseFold;
+}
 /**
  * Options used when creating files and directories.
  * This weird naming and such is to preserve backward compatibility.

package/dist/internal/filesystem.js

@@ -39,8 +39,7 @@ export class FileSystem {
             this.attributes.set('default_stream_write');
     }
     toString() {
-        var _a;
-        return `${this.name} ${(_a = this.label) !== null && _a !== void 0 ? _a : ''} (${this._mountPoint ? 'mounted on ' + this._mountPoint : 'unmounted'})`;
+        return `${this.name} ${this.label ? JSON.stringify(this.label) : ''} (${this._mountPoint ? 'mounted on ' + this._mountPoint : 'unmounted'})`;
     }
     /**
      * Default implementation.

package/dist/internal/index_fs.js

@@ -128,6 +128,7 @@ export class IndexFS extends FileSystem {
             size: 0,
             uid: parent.mode & S_ISUID ? parent.uid : options.uid,
             gid: parent.mode & S_ISGID ? parent.gid : options.gid,
+            nlink: 1,
         });
         this.index.set(path, inode);
         return inode;

package/dist/mixins/async.d.ts

@@ -1,5 +1,5 @@
 import type { FileSystem } from '../internal/filesystem.js';
-import type { _SyncFSKeys, AsyncFSMethods, Mixin } from './shared.js';
+import { type _SyncFSKeys, type AsyncFSMethods, type Mixin } from './shared.js';
 /**
  * @internal
  * @category Internals
@@ -16,7 +16,13 @@ export interface AsyncMixin extends Pick<FileSystem, Exclude<_SyncFSKeys, 'exist
      * @internal @protected
      */
     _sync?: FileSystem;
+    /**
+     * @deprecated Use {@link sync | `sync`} instead
+     */
     queueDone(): Promise<void>;
+    /**
+     * @deprecated Use {@link sync | `sync`} instead
+     */
     ready(): Promise<void>;
 }
 /**

package/dist/mixins/async.js

@@ -1,6 +1,6 @@
+import { _asyncFSKeys } from './shared.js';
 import { withErrno } from 'kerium';
 import { crit, debug, err } from 'kerium/log';
-import { getAllPrototypes } from 'utilium';
 import { StoreFS } from '../backends/store/fs.js';
 import { isDirectory } from '../internal/inode.js';
 import { join } from '../path.js';
@@ -16,11 +16,17 @@ import { join } from '../path.js';
  */
 export function Async(FS) {
     class AsyncFS extends FS {
+        /**
+         * @deprecated Use {@link sync | `sync`} instead
+         */
         async done() {
-            await this._promise;
+            return this.sync();
         }
+        /**
+         * @deprecated Use {@link sync | `sync`} instead
+         */
         queueDone() {
-            return this.done();
+            return this.sync();
         }
         _async(promise) {
             this._promise = this._promise.then(() => promise);
@@ -91,8 +97,8 @@ export function Async(FS) {
         }
         unlinkSync(path) {
             this.checkSync();
-            this._sync.unlinkSync(path);
             this._async(this.unlink(path));
+            this._sync.unlinkSync(path);
         }
         rmdirSync(path) {
             this.checkSync();
@@ -114,8 +120,8 @@ export function Async(FS) {
             this._async(this.link(srcpath, dstpath));
         }
         async sync() {
-            this.checkSync();
-            this._sync.syncSync();
+            if (!this.attributes.has('no_async_preload') && this._sync)
+                this._sync.syncSync();
             await this._promise;
         }
         syncSync() {
@@ -180,19 +186,19 @@ export function Async(FS) {
          * Patch all async methods to also call their synchronous counterparts unless called from themselves (either sync or async)
          */
         _patchAsync() {
-            const methods = Array.from(getAllPrototypes(this))
-                .flatMap(Object.getOwnPropertyNames)
-                .filter(key => typeof this[key] == 'function' && `${key}Sync` in this);
-            debug('Async: patching methods: ' + methods.join(', '));
-            for (const key of methods) {
+            debug(`Async: patched ${_asyncFSKeys.length} methods`);
+            for (const key of _asyncFSKeys) {
                 // TS does not narrow the union based on the key
-                const originalMethod = this[key];
+                const originalMethod = this[key].bind(this);
                 this[key] = async (...args) => {
-                    var _a, _b, _c;
-                    const result = await originalMethod.apply(this, args);
-                    const stack = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.split('\n').slice(2).join('\n');
-                    // !stack == From the async queue
-                    if ((stack === null || stack === void 0 ? void 0 : stack.includes(`at <computed> [as ${key}]`)) || (stack === null || stack === void 0 ? void 0 : stack.includes(`${key}Sync `)) || !stack)
+                    var _a, _b;
+                    const result = await originalMethod(...args);
+                    const stack = new Error().stack.split('\n').slice(2).join('\n');
+                    // From the async queue
+                    if (!stack
+                        || stack.includes(`at <computed> [as ${key}]`)
+                        || stack.includes(`at async <computed> [as ${key}]`)
+                        || stack.includes(`${key}Sync `))
                         return result;
                     if (!this._isInitialized) {
                         this._skippedCacheUpdates++;
@@ -200,10 +206,16 @@ export function Async(FS) {
                     }
                     try {
                         // @ts-expect-error 2556 - The type of `args` is not narrowed
-                        (_c = (_b = this._sync) === null || _b === void 0 ? void 0 : _b[`${key}Sync`]) === null || _c === void 0 ? void 0 : _c.call(_b, ...args);
+                        (_b = (_a = this._sync) === null || _a === void 0 ? void 0 : _a[`${key}Sync`]) === null || _b === void 0 ? void 0 : _b.call(_a, ...args);
                     }
                     catch (e) {
-                        throw err(withErrno(e.errno, e.message + ' (Out of sync!)'));
+                        const stack = e.stack.split('\n').slice(3).join('\n');
+                        if (stack.includes(`at <computed> [as ${key}]`)
+                            || stack.includes(`at async <computed> [as ${key}]`)
+                            || stack.includes(`${key}Sync `))
+                            return result;
+                        e.message += ' (Out of sync!)';
+                        throw err(e);
                     }
                     return result;
                 };

package/dist/mixins/mutexed.d.ts

@@ -30,7 +30,7 @@ export declare class _MutexedFS<T extends FileSystem> implements FileSystem {
     get name(): string;
     get label(): string | undefined;
     set label(value: string | undefined);
-    get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void> & Map<string, any>;
+    get attributes(): import("utilium").ConstMap<import("../internal/filesystem.js").FileSystemAttributes, keyof import("../internal/filesystem.js").FileSystemAttributes, void | import("../internal/filesystem.js").CaseFold | undefined> & Map<string, any>;
     get _uuid(): UUID;
     set _uuid(value: UUID);
     get uuid(): UUID;

package/dist/mixins/shared.d.ts

@@ -18,15 +18,18 @@ export type _SyncFSKeys = Exclude<Extract<keyof FileSystem, `${string}Sync`>, '_
 export type _AsyncFSKeys = {
     [K in _SyncFSKeys]: K extends `${infer T}Sync` ? T : never;
 }[_SyncFSKeys];
+export declare const _asyncFSKeys: ["rename", "stat", "touch", "createFile", "unlink", "rmdir", "mkdir", "readdir", "exists", "link", "sync", "read", "write"];
 /**
  * Asynchronous `FileSystem` methods. This is a convenience type for all of the async operations.
  * @category Internals
  * @internal
  */
-export type AsyncFSMethods = Pick<FileSystem, _AsyncFSKeys>;
+export interface AsyncFSMethods extends Pick<FileSystem, _AsyncFSKeys> {
+}
 /**
  * Concrete `FileSystem`. This is a convenience type.
  * @category Internals
  * @internal
  */
-export type ConcreteFS = ExtractProperties<FileSystem, any>;
+export interface ConcreteFS extends ExtractProperties<FileSystem, any> {
+}

package/dist/mixins/shared.js

@@ -1,5 +1,19 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-empty-object-type,@typescript-eslint/no-explicit-any */
 /*
     Code shared by various mixins
 */
-export {};
+export const _asyncFSKeys = [
+    'rename',
+    'stat',
+    'touch',
+    'createFile',
+    'unlink',
+    'rmdir',
+    'mkdir',
+    'readdir',
+    'exists',
+    'link',
+    'sync',
+    'read',
+    'write',
+];

package/dist/path.d.ts

@@ -14,3 +14,4 @@ export declare function basename(path: string, suffix?: string): string;
 export declare function extname(path: string): string;
 export declare function format(pathObject: ParsedPath): string;
 export declare function parse(path: string): ParsedPath;
+export declare function matchesGlob(pattern: string, str: string): boolean;

package/dist/path.js

@@ -21,6 +21,7 @@ OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 import { defaultContext } from './internal/contexts.js';
+import { globToRegex } from './utils.js';
 export const sep = '/';
 function validateObject(str, name) {
     if (typeof str != 'object') {
@@ -419,3 +420,6 @@ export function parse(path) {
         ret.dir = '/';
     return ret;
 }
+export function matchesGlob(pattern, str) {
+    return globToRegex(pattern).test(str);
+}

package/dist/readline.d.ts

@@ -85,6 +85,7 @@ export declare class Interface extends EventEmitter<InterfaceEvents> implements
      */
     getMaxListeners(): number;
     [Symbol.asyncIterator](): AsyncIteratorObject<string>;
+    [Symbol.dispose](): void;
     [Symbol.asyncDispose](): Promise<void>;
     rawListeners(event: keyof InterfaceEvents): ((...args: any[]) => void)[];
 }

package/dist/readline.js

@@ -365,6 +365,9 @@ export class Interface extends EventEmitter {
             },
         };
     }
+    [Symbol.dispose]() {
+        this.close();
+    }
     async [Symbol.asyncDispose]() {
         if (this._closed)
             return;

package/dist/utils.d.ts

@@ -53,3 +53,8 @@ export declare function normalizeOptions(options: fs.WriteFileOptions | (fs.Enco
     flag: string;
     mode: number;
 };
+/**
+ * Converts a glob pattern to a regular expression
+ * @internal
+ */
+export declare function globToRegex(pattern: string): RegExp;

package/dist/utils.js

@@ -96,3 +96,15 @@ export function normalizeOptions(options, encoding = 'utf8', flag, mode = 0) {
         mode: normalizeMode('mode' in options ? options === null || options === void 0 ? void 0 : options.mode : null, mode),
     };
 }
+/**
+ * Converts a glob pattern to a regular expression
+ * @internal
+ */
+export function globToRegex(pattern) {
+    pattern = pattern
+        .replace(/([.?+^$(){}|[\]/])/g, '$1')
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${pattern}$`);
+}

package/dist/vfs/promises.d.ts

@@ -128,7 +128,7 @@ export declare class FileHandle implements promises.FileHandle {
      * Read file data using a `ReadableStream`.
      * The handle will not be closed automatically.
      */
-    readableWebStream(options?: promises.ReadableWebStreamOptions & StreamOptions): NodeReadableStream<Uint8Array>;
+    readableWebStream(options?: StreamOptions): NodeReadableStream<Uint8Array>;
     /**
      * Not part of the Node.js API!
      *
@@ -136,7 +136,7 @@ export declare class FileHandle implements promises.FileHandle {
      * The handle will not be closed automatically.
      * @internal
      */
-    writableWebStream(options?: promises.ReadableWebStreamOptions & StreamOptions): WritableStream;
+    writableWebStream(options?: StreamOptions): WritableStream;
     /**
      * Creates a readline Interface object that allows reading the file line by line
      * @param options Options for creating a read stream

package/dist/vfs/promises.js

@@ -55,10 +55,10 @@ import { Exception, rethrow, setUVMessage, UV } from 'kerium';
 import { decodeUTF8, pick } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
 import { hasAccess, InodeFlags, isBlockDevice, isCharacterDevice, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { dirname, join, parse, resolve } from '../path.js';
+import { dirname, join, matchesGlob, parse, resolve } from '../path.js';
 import '../polyfills.js';
 import { createInterface } from '../readline.js';
-import { __assertType, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { __assertType, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -1219,19 +1219,12 @@ export function glob(pattern, opt) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = opt || {};
     // Escape special characters in pattern
-    const regexPatterns = pattern.map(p => {
-        p = p
-            .replace(/([.?+^$(){}|[\]/])/g, '$1')
-            .replace(/\*\*/g, '.*')
-            .replace(/\*/g, '[^/]*')
-            .replace(/\?/g, '.');
-        return new RegExp(`^${p}$`);
-    });
+    const regexPatterns = pattern.map(globToRegex);
     async function* recursiveList(dir) {
         const entries = await readdir(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
             const fullPath = withFileTypes ? entry.path : dir + '/' + entry;
-            if (exclude((withFileTypes ? entry : fullPath)))
+            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**
              * @todo is the pattern.source check correct?

package/dist/vfs/shared.js

@@ -55,12 +55,17 @@ export function resolveMount(path, ctx) {
     const sortedMounts = [...mounts].sort((a, b) => (a[0].length > b[0].length ? -1 : 1)); // descending order of the string length
     for (const [mountPoint, fs] of sortedMounts) {
         // We know path is normalized, so it would be a substring of the mount point.
-        if (_isParentOf(mountPoint, path)) {
-            path = path.slice(mountPoint.length > 1 ? mountPoint.length : 0); // Resolve the path relative to the mount point
-            if (path === '')
-                path = root;
-            return { fs, path, mountPoint, root };
-        }
+        if (!_isParentOf(mountPoint, path))
+            continue;
+        path = path.slice(mountPoint.length > 1 ? mountPoint.length : 0); // Resolve the path relative to the mount point
+        if (path === '')
+            path = root;
+        const case_fold = fs.attributes.get('case_fold');
+        if (case_fold === 'lower')
+            path = path.toLowerCase();
+        if (case_fold === 'upper')
+            path = path.toUpperCase();
+        return { fs, path, mountPoint, root };
     }
     throw alert(new Exception(Errno.EIO, 'No file system for ' + path));
 }

package/dist/vfs/sync.js

@@ -56,8 +56,8 @@ import { decodeUTF8, encodeUTF8 } from 'utilium';
 import { defaultContext } from '../internal/contexts.js';
 import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory, isSymbolicLink } from '../internal/inode.js';
-import { dirname, join, parse, resolve } from '../path.js';
-import { __assertType, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
+import { dirname, join, matchesGlob, parse, resolve } from '../path.js';
+import { __assertType, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from './config.js';
 import * as constants from './constants.js';
 import { Dir, Dirent } from './dir.js';
@@ -860,20 +860,13 @@ export function globSync(pattern, options = {}) {
     pattern = Array.isArray(pattern) ? pattern : [pattern];
     const { cwd = '/', withFileTypes = false, exclude = () => false } = options;
     // Escape special characters in pattern
-    const regexPatterns = pattern.map(p => {
-        p = p
-            .replace(/([.?+^$(){}|[\]/])/g, '\\$1')
-            .replace(/\*\*/g, '.*')
-            .replace(/\*/g, '[^/]*')
-            .replace(/\?/g, '.');
-        return new RegExp(`^${p}$`);
-    });
+    const regexPatterns = pattern.map(globToRegex);
     const results = [];
     function recursiveList(dir) {
         const entries = readdirSync(dir, { withFileTypes, encoding: 'utf8' });
         for (const entry of entries) {
             const fullPath = withFileTypes ? entry.path : dir + '/' + entry;
-            if (exclude((withFileTypes ? entry : fullPath)))
+            if (typeof exclude != 'function' ? exclude.some(p => matchesGlob(p, fullPath)) : exclude((withFileTypes ? entry : fullPath)))
                 continue;
             /**
              * @todo is the pattern.source check correct?

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.1.1",
+	"version": "2.2.1",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -67,7 +67,7 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@types/node": "^22.10.1 <22.13.7",
+		"@types/node": "^22.15.2",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.3.4",
@@ -81,10 +81,10 @@
 		"@types/eslint__js": "^8.42.3",
 		"c8": "^10.1.2",
 		"eslint": "^9.15.0",
-		"globals": "^15.9.0",
+		"globals": "^16.0.0",
 		"prettier": "^3.2.5",
 		"tsx": "^4.19.1",
-		"typedoc": "^0.27.1",
+		"typedoc": "^0.28.0",
 		"typescript": "^5.7.2",
 		"typescript-eslint": "^8.16.0"
 	}

package/readme.md

@@ -1,23 +1,28 @@
 # ZenFS
 
-ZenFS is a cross-platform library 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 with other tools.
+ZenFS is a cross-platform library that emulates the [Node.js 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 with other tools.
 
 ## Backends
 
-ZenFS is modular and extensible. The core includes some built-in backends:
+ZenFS is modular and easily extended. The core includes some built-in backends:
 
 - `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)
-- `CopyOnWrite`: Use readable and writable file systems with ([copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write)).
+- `CopyOnWrite`: Use readable and writable file systems with [copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write).
 - `Fetch`: Downloads files over HTTP with the `fetch` API
 - `Port`: Interacts with a remote over a `MessagePort`-like interface (e.g. a worker)
 - `Passthrough`: Use an existing `node:fs` interface with ZenFS
 - `SingleBuffer`: A backend contained within a single buffer. Can be used for synchronous multi-threaded operations using `SharedArrayBuffer`
 
-ZenFS supports a number of other backends. Many are provided as separate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
+ZenFS supports a number of other backends.
+Many are provided as separate packages under `@zenfs`.
+More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
 
 You can find all of the packages available over on [NPM](https://www.npmjs.com/org/zenfs).
 
-As an added bonus, all ZenFS backends support synchronous operations. All of the backends included with the core are cross-platform.
+As an added bonus, all ZenFS backends support synchronous operations.
+Additionally, all of the backends included with the core are cross-platform.
 
 For more information, see the [docs](https://zenfs.dev/core).
 
@@ -27,7 +32,9 @@ For more information, see the [docs](https://zenfs.dev/core).
 npm install @zenfs/core
 ```
 
-If you're using ZenFS, especially for big projects, please consider supporting the project. Thousands of hours have been dedicated to its development. Your acknowledgment or financial support would go a long way toward improving ZenFS and its community.
+If you're using ZenFS, especially for big projects, please consider supporting the project.
+Thousands of hours have been dedicated to its development.
+Your acknowledgment or financial support would go a long way toward improving ZenFS and its community.
 
 ## Usage
 
@@ -149,7 +156,7 @@ fs.umount('/mnt/zip'); // finished using the zip
 
 ### Devices and device files
 
-ZenFS includes experimental support for device files. These are designed to follow Linux's device file behavior, for consistency and ease of use. You can automatically add some normal devices with the `addDevices` configuration option:
+ZenFS includes support for device files. These are designed to follow Linux's device file behavior, for consistency and ease of use. You can automatically add some normal devices with the `addDevices` configuration option:
 
 ```ts
 await configure({
@@ -208,9 +215,9 @@ A huge thank you to [![Deco.cx logo](https://avatars.githubusercontent.com/deco-
 
 ## Building
 
-- Make sure you have Node and NPM installed. You must have Node v18 or newer.
+- Make sure you have Node and NPM installed. You must have Node v22 or newer.
 - Install dependencies with `npm install`
-- Build using `npm run build`
+- Build using `npx tsc` or `npm run build`
 - You can find the built code in `dist`.
 
 ### Testing

package/tests/common/casefold.test.ts

@@ -0,0 +1,19 @@
+import assert from 'node:assert/strict';
+import { suite, test } from 'node:test';
+import { mounts, configure, fs } from '../../dist/index.js';
+
+suite('Case folding', () => {
+	test('Configuration', async () => {
+		await configure({ caseFold: 'lower' });
+		assert.equal(mounts.get('/')?.attributes.get('case_fold'), 'lower');
+	});
+
+	test('Write', () => {
+		fs.writeFileSync('/Test.txt', 'test');
+		assert(fs.existsSync('/test.txt'));
+	});
+
+	test('Read', () => {
+		assert.equal(fs.readFileSync('/TEST.txt', 'utf8'), 'test');
+	});
+});

package/tests/fs/directory.test.ts

@@ -21,7 +21,7 @@ suite('Directories', () => {
 	test('mkdir', async () => {
 		await fs.promises.mkdir('/one', 0o755);
 		assert(await fs.promises.exists('/one'));
-		await assert.rejects(fs.promises.mkdir('/one', 0o755), /EEXIST/);
+		await assert.rejects(fs.promises.mkdir('/one', 0o755), { code: 'EEXIST' });
 	});
 
 	test('mkdirSync', async () => await fs.promises.mkdir('/two', 0o000));