@zenfs/core 1.11.4 → 2.1.0

package/dist/vfs/watchers.d.ts

@@ -2,7 +2,7 @@ import type { EventEmitter as NodeEventEmitter } from 'node:events';
 import type * as fs from 'node:fs';
 import type { V_Context } from '../context.js';
 import { EventEmitter } from 'eventemitter3';
-import { type Stats } from '../stats.js';
+import { type Stats } from './stats.js';
 /**
  * Base class for file system watchers.
  * Provides event handling capabilities for watching file system changes.
@@ -75,5 +75,5 @@ export declare function removeWatcher(path: string, watcher: FSWatcher): void;
 /**
  * @internal @hidden
  */
-export declare function emitChange(context: V_Context, eventType: fs.WatchEventType, filename: string): void;
+export declare function emitChange($: V_Context, eventType: fs.WatchEventType, filename: string): void;
 export {};

package/dist/vfs/watchers.js

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'eventemitter3';
-import { ErrnoError } from '../internal/error.js';
-import { isStatsEqual } from '../stats.js';
+import { UV } from 'kerium';
+import { basename, dirname, join, relative } from '../path.js';
 import { normalizePath } from '../utils.js';
-import { basename, dirname, join, relative } from './path.js';
+import { isStatsEqual } from './stats.js';
 import { statSync } from './sync.js';
 /**
  * Base class for file system watchers.
@@ -29,19 +29,19 @@ class Watcher extends EventEmitter {
         this.path = path;
     }
     setMaxListeners() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.setMaxListeners');
+        throw UV('ENOSYS', 'Watcher.setMaxListeners');
     }
     getMaxListeners() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.getMaxListeners');
+        throw UV('ENOSYS', 'Watcher.getMaxListeners');
     }
     prependListener() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.prependListener');
+        throw UV('ENOSYS', 'Watcher.prependListener');
     }
     prependOnceListener() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.prependOnceListener');
+        throw UV('ENOSYS', 'Watcher.prependOnceListener');
     }
     rawListeners() {
-        throw ErrnoError.With('ENOSYS', this.path, 'Watcher.rawListeners');
+        throw UV('ENOSYS', 'Watcher.rawListeners');
     }
     ref() {
         return this;
@@ -138,10 +138,10 @@ export function removeWatcher(path, watcher) {
 /**
  * @internal @hidden
  */
-export function emitChange(context, eventType, filename) {
+export function emitChange($, eventType, filename) {
     var _a;
-    if (context)
-        filename = join((_a = context.root) !== null && _a !== void 0 ? _a : '/', filename);
+    if ($)
+        filename = join((_a = $.root) !== null && _a !== void 0 ? _a : '/', filename);
     filename = normalizePath(filename);
     // Notify watchers, including ones on parent directories if they are watching recursively
     for (let path = filename; path != '/'; path = dirname(path)) {
@@ -149,7 +149,7 @@ export function emitChange(context, eventType, filename) {
         if (!watchersForPath)
             continue;
         for (const watcher of watchersForPath) {
-            watcher.emit('change', eventType, relative(path, filename) || basename(filename));
+            watcher.emit('change', eventType, relative.call(watcher._context, path, filename) || basename(filename));
         }
     }
 }

package/dist/vfs/xattr.d.ts

@@ -0,0 +1,116 @@
+import type { BufferEncodingOption, ObjectEncodingOptions } from 'node:fs';
+import type { V_Context } from '../context.js';
+/**
+ * Extended attribute name with namespace prefix.
+ * Format is namespace.attributename where namespace is one of:
+ * - user: User attributes
+ * - trusted: Trusted attributes (privileged)
+ * - system: System attributes
+ * - security: Security attributes
+ *
+ * Note: Currently only the 'user' namespace is supported.
+ */
+export type Name = `${'user' | 'trusted' | 'system' | 'security'}.${string}`;
+/**
+ * Options for xattr operations.
+ */
+export interface Options {
+    /**
+     * If true, don't follow symlinks.
+     * @default false
+     */
+    noFollow?: boolean;
+    /**
+     * Encoding for attribute values.
+     * If 'buffer' or undefined, the value is returned as a Buffer.
+     * Otherwise, the value is returned as a string using the specified encoding.
+     * @default undefined
+     */
+    encoding?: BufferEncoding | 'buffer';
+}
+/**
+ * Options for setting extended attributes.
+ * Extends the base Options with additional flags for create/replace behavior.
+ */
+export interface SetOptions extends Options {
+    /**
+     * If true, fail if the attribute already exists.
+     * @default false
+     */
+    create?: boolean;
+    /**
+     * If true, fail if the attribute does not exist.
+     * @default false
+     */
+    replace?: boolean;
+}
+/**
+ * Gets the value of an extended attribute.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to get
+ * @param opt Options for the operation
+ * @returns A buffer containing the attribute value when encoding is 'buffer' or undefined, or a string when a string encoding is specified
+ */
+export declare function get(this: V_Context, path: string, name: Name, opt?: Options & (BufferEncodingOption | {
+    encoding?: null;
+})): Promise<Uint8Array>;
+export declare function get(this: V_Context, path: string, name: Name, opt: Options & ObjectEncodingOptions): Promise<string>;
+/**
+ * Synchronously gets the value of an extended attribute.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to get
+ * @param opt Options for the operation
+ * @returns A buffer containing the attribute value when encoding is 'buffer' or undefined, or a string when a string encoding is specified
+ */
+export declare function getSync(this: V_Context, path: string, name: Name, opt?: Options & (BufferEncodingOption | {
+    encoding?: null;
+})): Uint8Array;
+export declare function getSync(this: V_Context, path: string, name: Name, opt: Options & ObjectEncodingOptions): string;
+/**
+ * Sets the value of an extended attribute.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to set
+ * @param value Value to set
+ * @param opt Options for the operation
+ */
+export declare function set(this: V_Context, path: string, name: Name, value: string | Uint8Array, opt?: SetOptions): Promise<void>;
+/**
+ * Synchronously sets the value of an extended attribute.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to set
+ * @param value Value to set
+ * @param opt Options for the operation
+ */
+export declare function setSync(this: V_Context, path: string, name: Name, value: string | Uint8Array, opt?: SetOptions): void;
+/**
+ * Removes an extended attribute from a file.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to remove
+ */
+export declare function remove(this: V_Context, path: string, name: Name): Promise<void>;
+/**
+ * Synchronously removes an extended attribute from a file.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to remove
+ */
+export declare function removeSync(this: V_Context, path: string, name: Name): void;
+/**
+ * Lists all extended attributes of a file.
+ *
+ * @param path Path to the file
+ * @returns Array of attribute names
+ */
+export declare function list(this: V_Context, path: string): Promise<Name[]>;
+/**
+ * Synchronously lists all extended attributes of a file.
+ *
+ * @param path Path to the file
+ * @returns Array of attribute names
+ */
+export declare function listSync(this: V_Context, path: string): Name[];

package/dist/vfs/xattr.js

@@ -0,0 +1,201 @@
+import { Buffer } from 'buffer';
+import { rethrow, setUVMessage, UV } from 'kerium';
+import { Attributes, hasAccess } from '../internal/inode.js';
+import { normalizePath } from '../utils.js';
+import { checkAccess } from './config.js';
+import { R_OK, W_OK } from './constants.js';
+import { resolveMount } from './shared.js';
+const _allowedRestrictedNames = [];
+/**
+ * Check permission for the attribute name.
+ * For now, only attributes in the 'user' namespace are supported.
+ * @throws ENOTSUP for attributes in namespaces other than 'user'
+ */
+function checkName($, name, path, syscall) {
+    if (!name.startsWith('user.') && !_allowedRestrictedNames.includes(name))
+        throw UV('ENOTSUP', syscall, path);
+}
+export async function get(path, name, opt = {}) {
+    var _a;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path, this);
+    checkName(this, name, path, 'xattr.get');
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.get', path));
+    if (checkAccess && !hasAccess(this, inode, R_OK))
+        throw UV('EACCES', 'xattr.get', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const value = inode.attributes.get(name);
+    if (!value)
+        throw UV('ENODATA', 'xattr.get', path);
+    const buffer = Buffer.from(value);
+    return opt.encoding == 'buffer' || !opt.encoding ? buffer : buffer.toString(opt.encoding);
+}
+export function getSync(path, name, opt = {}) {
+    var _a;
+    path = normalizePath(path);
+    checkName(this, name, path, 'xattr.get');
+    const { fs, path: resolved } = resolveMount(path, this);
+    let inode;
+    try {
+        inode = fs.statSync(resolved);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+    if (checkAccess && !hasAccess(this, inode, R_OK))
+        throw UV('EACCES', 'xattr.get', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const value = inode.attributes.get(name);
+    if (!value)
+        throw UV('ENODATA', 'xattr.get', path);
+    const buffer = Buffer.from(value);
+    return opt.encoding == 'buffer' || !opt.encoding ? buffer : buffer.toString(opt.encoding);
+}
+/**
+ * Sets the value of an extended attribute.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to set
+ * @param value Value to set
+ * @param opt Options for the operation
+ */
+export async function set(path, name, value, opt = {}) {
+    var _a;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path, this);
+    checkName(this, name, path, 'xattr.set');
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.set', path));
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.set', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (opt.create && attr)
+        throw UV('EEXIST', 'xattr.set', path);
+    if (opt.replace && !attr)
+        throw UV('ENODATA', 'xattr.set', path);
+    inode.attributes.set(name, Buffer.from(value));
+    await fs.touch(resolved, inode).catch(rethrow('xattr.set', path));
+}
+/**
+ * Synchronously sets the value of an extended attribute.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to set
+ * @param value Value to set
+ * @param opt Options for the operation
+ */
+export function setSync(path, name, value, opt = {}) {
+    var _a;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path, this);
+    checkName(this, name, path, 'xattr.set');
+    let inode;
+    try {
+        inode = fs.statSync(resolved);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.set', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (opt.create && attr)
+        throw UV('EEXIST', 'xattr.set', path);
+    if (opt.replace && !attr)
+        throw UV('ENODATA', 'xattr.set', path);
+    inode.attributes.set(name, Buffer.from(value));
+    try {
+        fs.touchSync(resolved, inode);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+}
+/**
+ * Removes an extended attribute from a file.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to remove
+ */
+export async function remove(path, name) {
+    var _a;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path, this);
+    checkName(this, name, path, 'xattr.remove');
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.remove', path));
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.remove', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (!attr)
+        throw UV('ENODATA', 'xattr.remove', path);
+    inode.attributes.remove(name);
+    await fs.touch(resolved, inode);
+}
+/**
+ * Synchronously removes an extended attribute from a file.
+ *
+ * @param path Path to the file
+ * @param name Name of the attribute to remove
+ */
+export function removeSync(path, name) {
+    var _a;
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path, this);
+    checkName(this, name, path, 'xattr.remove');
+    let inode;
+    try {
+        inode = fs.statSync(resolved);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+    if (checkAccess && !hasAccess(this, inode, W_OK))
+        throw UV('EACCES', 'xattr.remove', path);
+    (_a = inode.attributes) !== null && _a !== void 0 ? _a : (inode.attributes = new Attributes());
+    const attr = inode.attributes.get(name);
+    if (!attr)
+        throw UV('ENODATA', 'xattr.remove', path);
+    inode.attributes.remove(name);
+    try {
+        fs.touchSync(resolved, inode);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+}
+/**
+ * Lists all extended attributes of a file.
+ *
+ * @param path Path to the file
+ * @returns Array of attribute names
+ */
+export async function list(path) {
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path, this);
+    const inode = await fs.stat(resolved).catch(rethrow('xattr.list', path));
+    if (!inode.attributes)
+        return [];
+    return inode.attributes.keys().toArray();
+}
+/**
+ * Synchronously lists all extended attributes of a file.
+ *
+ * @param path Path to the file
+ * @returns Array of attribute names
+ */
+export function listSync(path) {
+    path = normalizePath(path);
+    const { fs, path: resolved } = resolveMount(path, this);
+    let inode;
+    try {
+        inode = fs.statSync(resolved);
+    }
+    catch (e) {
+        throw setUVMessage(Object.assign(e, { path }));
+    }
+    if (!inode.attributes)
+        return [];
+    return inode.attributes.keys().toArray();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.11.4",
+	"version": "2.1.0",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -67,11 +67,13 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@types/node": "^22.10.1",
+		"@types/node": "^22.10.1 <22.13.7",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
+		"kerium": "^1.3.4",
+		"memium": "^0.2.0",
 		"readable-stream": "^4.5.2",
-		"utilium": "^1.3.3"
+		"utilium": "^2.3.3"
 	},
 	"devDependencies": {
 		"@eslint/js": "^9.8.0",

package/readme.md

@@ -7,7 +7,7 @@ ZenFS is a cross-platform library that emulates the [NodeJS filesystem API](http
 ZenFS is modular and extensible. 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)
-- `Overlay`: Use a read-only file system as read-write by overlaying a writable file system on top of it. ([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

package/scripts/test.js

@@ -9,7 +9,7 @@ const { values: options, positionals } = parseArgs({
 	options: {
 		// Output
 		help: { short: 'h', type: 'boolean', default: false },
-		verbose: { short: 'w', type: 'boolean', default: false },
+		verbose: { short: 'v', type: 'boolean', default: false },
 		quiet: { short: 'q', type: 'boolean', default: false },
 		log: { short: 'l', type: 'string', default: '' },
 		'file-names': { short: 'N', type: 'boolean', default: false },
@@ -49,7 +49,7 @@ Behavior:
 
 Output:
     -h, --help          Outputs this help message
-    -w, --verbose       Output verbose messages
+    -v, --verbose       Output verbose messages
     -q, --quiet         Don't output normal messages
     -l, --logs <level>  Change the default log level for test output. Level can be a number or string
     -N, --file-names    Use full file paths for tests from setup files instead of the base name

package/tests/assignment.ts

@@ -10,8 +10,8 @@
 	- ReadStream and WriteStream are excluded since they are polyfilled from another module
 */
 
-import { fs as zen } from '../src/index.js';
 import type * as node from 'node:fs';
+import { fs as zen } from '../src/index.js';
 
 type Mock = {
 	[K in Exclude<keyof typeof node, 'ReadStream' | 'WriteStream'>]: Omit<(typeof node)[K], '__promisify__' | 'native'>;

package/tests/backend/config.worker.js

@@ -1,5 +1,8 @@
 import { parentPort } from 'node:worker_threads';
-import { resolveRemoteMount } from '../../dist/backends/port/fs.js';
+import { resolveRemoteMount } from '../../dist/backends/port.js';
 import { InMemory } from '../../dist/backends/memory.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs('<config>');
 
 await resolveRemoteMount(parentPort, { backend: InMemory });

package/tests/backend/fetch.test.ts

@@ -4,6 +4,9 @@ import { suite, test } from 'node:test';
 import { Worker } from 'node:worker_threads';
 import { Fetch, configureSingle, fs, mounts, type FetchFS } from '../../dist/index.js';
 import { baseUrl, defaultEntries, indexPath, whenServerReady } from '../fetch/config.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs();
 
 const server = new Worker(join(import.meta.dirname, '../fetch/server.js'));
 

package/tests/backend/port.test.ts

@@ -1,10 +1,11 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { MessageChannel, Worker } from 'node:worker_threads';
-import { Port, attachFS } from '../../dist/backends/port/fs.js';
-import { waitOnline } from '../../dist/backends/port/rpc.js';
+import { Port, attachFS, waitOnline } from '../../dist/backends/port.js';
 import type { InMemoryStore, StoreFS } from '../../dist/index.js';
-import { ErrnoError, InMemory, configure, configureSingle, fs, resolveMountConfig } from '../../dist/index.js';
+import { InMemory, configure, configureSingle, fs, resolveMountConfig } from '../../dist/index.js';
+import { setupLogs } from '../logs.js';
+setupLogs();
 
 // Tests a mis-configured `Port` using a MessageChannel
 
@@ -13,35 +14,20 @@ timeoutChannel.port2.unref();
 
 await suite('Timeout', { timeout: 1000 }, () => {
 	test('Misconfiguration', async () => {
-		let error: ErrnoError;
-		try {
-			await configure({
-				mounts: {
-					'/tmp-timeout': { backend: InMemory, name: 'tmp' },
-					'/port': { backend: Port, port: timeoutChannel.port1, timeout: 100 },
-				},
-			});
-		} catch (e) {
-			assert(e instanceof ErrnoError);
-			error = e;
-		}
-		assert(error! instanceof ErrnoError);
-		assert.equal(error.code, 'EIO');
-		assert(error.message.includes('RPC Failed'));
+		const configured = configure({
+			mounts: {
+				'/tmp-timeout': { backend: InMemory, label: 'tmp' },
+				'/port': { backend: Port, port: timeoutChannel.port1, timeout: 100 },
+			},
+		});
+
+		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
 	});
 
 	test('Remote not attached', async () => {
-		let error: ErrnoError;
-		try {
-			await configureSingle({ backend: Port, port: timeoutChannel.port1, timeout: 100 });
-			await fs.promises.writeFile('/test', 'anything');
-		} catch (e) {
-			assert(e instanceof ErrnoError);
-			error = e;
-		}
-		assert(error! instanceof ErrnoError);
-		assert.equal(error.code, 'EIO');
-		assert(error.message.includes('RPC Failed'));
+		const configured = configureSingle({ backend: Port, port: timeoutChannel.port1, timeout: 100 });
+
+		await assert.rejects(configured, { code: 'EIO', message: /RPC Failed/ });
 	});
 });
 
@@ -56,7 +42,7 @@ await suite('Remote FS with resolveRemoteMount', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: configPort, timeout: 100 });
+		await configureSingle({ backend: Port, port: configPort, timeout: 500 });
 	});
 
 	test('Write', async () => {
@@ -79,9 +65,9 @@ let tmpfs: StoreFS<InMemoryStore>;
 
 await suite('FS with MessageChannel', () => {
 	test('configuration', async () => {
-		tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
+		tmpfs = await resolveMountConfig({ backend: InMemory, label: 'tmp' });
 		attachFS(channel.port2, tmpfs);
-		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 100 });
+		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 500 });
 	});
 
 	test('write', async () => {
@@ -116,7 +102,7 @@ await suite('Remote FS', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: remotePort, timeout: 100 });
+		await configureSingle({ backend: Port, port: remotePort, timeout: 500 });
 	});
 
 	test('Write', async () => {

package/tests/backend/remote.worker.js

@@ -1,5 +1,8 @@
 import { parentPort } from 'node:worker_threads';
-import { attachFS } from '../../dist/backends/port/fs.js';
+import { attachFS } from '../../dist/backends/port.js';
 import { mounts } from '../../dist/index.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs('<remote>');
 
 attachFS(parentPort, mounts.get('/'));

package/tests/backend/single-buffer.test.ts

@@ -0,0 +1,53 @@
+import assert from 'node:assert';
+import { suite, test } from 'node:test';
+import { Worker } from 'worker_threads';
+import { fs, mount, resolveMountConfig, SingleBuffer } from '../../dist/index.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs();
+
+await suite('SingleBuffer', () => {
+	test('filesystem restoration from original buffer (with same metadata)', async () => {
+		const buffer = new ArrayBuffer(0x100000);
+
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer });
+		mount('/mnt', writable);
+
+		fs.writeFileSync('/mnt/example.ts', 'console.log("hello world")', 'utf-8');
+		const stats = fs.statSync('/mnt/example.ts');
+
+		const snapshot = await resolveMountConfig({ backend: SingleBuffer, buffer });
+		mount('/snapshot', snapshot);
+
+		const snapshotStats = fs.statSync('/snapshot/example.ts');
+
+		assert.deepEqual(snapshotStats, stats);
+	});
+
+	test('cross-thread SharedArrayBuffer', async () => {
+		const sharedBuffer = new SharedArrayBuffer(0x100000);
+
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer: sharedBuffer });
+		fs.mkdirSync('/shared');
+		mount('/shared', writable);
+
+		const worker = new Worker(import.meta.dirname + '/single-buffer.worker.js', { workerData: sharedBuffer });
+
+		// Pause while we wait for the worker to emit the 'continue' message, which
+		// means it has mounted the filesystem and created /worker-file.ts
+		const { promise, resolve, reject } = Promise.withResolvers<void>();
+
+		setTimeout(reject, 1000);
+		worker.on('message', message => {
+			if (message === 'continue') resolve();
+			else reject(message ?? new Error('Failed'));
+		});
+
+		await promise;
+
+		await worker.terminate();
+		worker.unref();
+
+		assert(fs.existsSync('/shared/worker-file.ts'));
+	});
+});

package/tests/backend/single-buffer.worker.js

@@ -0,0 +1,30 @@
+import assert from 'node:assert';
+import { writeFileSync as _write } from 'node:fs';
+import { parentPort, workerData } from 'node:worker_threads';
+import { configureSingle, fs, SingleBuffer } from '../../dist/index.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs('<worker>');
+
+const content = 'console.log("this file was created by the worker")';
+
+const view = new Uint8Array(workerData);
+
+if (process.env.DEBUG) _write('tmp/shared.bin', view);
+
+try {
+	await configureSingle({
+		backend: SingleBuffer,
+		buffer: workerData,
+	});
+
+	fs.writeFileSync('/worker-file.ts', content, 'utf-8');
+
+	assert.equal(fs.readFileSync('/worker-file.ts', 'utf-8'), content);
+} catch (e) {
+	if (process.env.DEBUG) _write('tmp/shared.bin', view);
+	console.error(e);
+	parentPort.postMessage(e);
+}
+
+parentPort.postMessage('continue');