@zenfs/core 1.9.4 → 1.9.5

package/dist/backends/memory.d.ts

@@ -10,7 +10,6 @@ export declare class InMemoryStore extends Map<number, Uint8Array> implements Sy
     readonly name = "tmpfs";
     constructor(label?: string | undefined);
     sync(): Promise<void>;
-    clearSync(): void;
     transaction(): SyncMapTransaction;
 }
 declare const _InMemory: {

package/dist/backends/memory.js

@@ -12,9 +12,6 @@ export class InMemoryStore extends Map {
         this.name = 'tmpfs';
     }
     async sync() { }
-    clearSync() {
-        this.clear();
-    }
     transaction() {
         return new SyncMapTransaction(this);
     }

package/dist/backends/port/fs.js

@@ -145,7 +145,7 @@ export async function resolveRemoteMount(port, config, _depth = 0) {
     const stopAndReplay = RPC.catchMessages(port);
     const fs = await resolveMountConfig(config, _depth);
     attachFS(port, fs);
-    stopAndReplay(fs);
+    await stopAndReplay(fs);
     info('Resolved remote mount: ' + fs.toString());
     return fs;
 }

package/dist/backends/port/rpc.d.ts

@@ -10,7 +10,7 @@ type _MessageEvent<T = any> = T | {
 /** @internal */
 export interface Port {
     postMessage(value: unknown, transfer?: TransferListItem[]): void;
-    on?(event: 'message', listener: (value: unknown) => void): this;
+    on?(event: 'message' | 'online', listener: (value: unknown) => void): this;
     off?(event: 'message', listener: (value: unknown) => void): this;
     addEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
     removeEventListener?(type: 'message', listener: (ev: _MessageEvent) => void): void;
@@ -70,4 +70,8 @@ export declare function request<const TRequest extends Request, TValue>(request:
 export declare function handleResponse<const TResponse extends Response>(response: TResponse): void;
 export declare function attach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
 export declare function detach<T extends Message>(port: Port, handler: (message: T) => unknown): void;
-export declare function catchMessages<T extends Backend>(port: Port): (fs: FilesystemOf<T>) => void;
+export declare function catchMessages<T extends Backend>(port: Port): (fs: FilesystemOf<T>) => Promise<void>;
+/**
+ * @internal
+ */
+export declare function waitOnline(port: Port): Promise<void>;

package/dist/backends/port/rpc.js

@@ -64,7 +64,7 @@ export function attach(port, handler) {
         throw err(new ErrnoError(Errno.EINVAL, 'Cannot attach to non-existent port'));
     info('Attached handler to port: ' + handler.name);
     port['on' in port ? 'on' : 'addEventListener']('message', (message) => {
-        handler('data' in message ? message.data : message);
+        handler(typeof message == 'object' && message !== null && 'data' in message ? message.data : message);
     });
 }
 export function detach(port, handler) {
@@ -72,18 +72,29 @@ export function detach(port, handler) {
         throw err(new ErrnoError(Errno.EINVAL, 'Cannot detach from non-existent port'));
     info('Detached handler from port: ' + handler.name);
     port['off' in port ? 'off' : 'removeEventListener']('message', (message) => {
-        handler('data' in message ? message.data : message);
+        handler(typeof message == 'object' && message !== null && 'data' in message ? message.data : message);
     });
 }
 export function catchMessages(port) {
     const events = [];
     const handler = events.push.bind(events);
     attach(port, handler);
-    return function (fs) {
+    return async function (fs) {
         detach(port, handler);
         for (const event of events) {
             const request = 'data' in event ? event.data : event;
-            void handleRequest(port, fs, request);
+            await handleRequest(port, fs, request);
         }
     };
 }
+/**
+ * @internal
+ */
+export async function waitOnline(port) {
+    if (!('on' in port))
+        return; // Only need to wait in Node.js
+    const online = Promise.withResolvers();
+    setTimeout(online.reject, 500);
+    port.on('online', online.resolve);
+    await online.promise;
+}

package/dist/utils.d.ts

@@ -1,7 +1,6 @@
 import type * as fs from 'node:fs';
 import type { ClassLike, OptionalTuple } from 'utilium';
 import { ErrnoError } from './internal/error.js';
-import type { AbsolutePath } from './vfs/path.js';
 declare global {
     function atob(data: string): string;
     function btoa(data: string): string;
@@ -54,7 +53,7 @@ export declare function normalizeTime(time: string | number | Date): number;
  * Normalizes a path
  * @internal
  */
-export declare function normalizePath(p: fs.PathLike): AbsolutePath;
+export declare function normalizePath(p: fs.PathLike, noResolve?: boolean): string;
 /**
  * Normalizes options
  * @param options options to normalize

package/dist/utils.js

@@ -101,15 +101,23 @@ export function normalizeTime(time) {
  * Normalizes a path
  * @internal
  */
-export function normalizePath(p) {
+export function normalizePath(p, noResolve = false) {
+    if (p instanceof URL) {
+        if (p.protocol != 'file:')
+            throw new ErrnoError(Errno.EINVAL, 'URLs must use the file: protocol');
+        p = p.pathname;
+    }
     p = p.toString();
+    if (p.startsWith('file://'))
+        p = p.slice('file://'.length);
     if (p.includes('\x00')) {
         throw new ErrnoError(Errno.EINVAL, 'Path can not contain null character');
     }
     if (p.length == 0) {
         throw new ErrnoError(Errno.EINVAL, 'Path can not be empty');
     }
-    return resolve(p.replaceAll(/[/\\]+/g, '/'));
+    p = p.replaceAll(/[/\\]+/g, '/');
+    return noResolve ? p : resolve(p);
 }
 /**
  * Normalizes options

package/dist/vfs/promises.js

@@ -89,9 +89,8 @@ export class FileHandle {
      */
     async chmod(mode) {
         const numMode = normalizeMode(mode, -1);
-        if (numMode < 0) {
+        if (numMode < 0)
             throw new ErrnoError(Errno.EINVAL, 'Invalid mode.');
-        }
         await this.file.chmod(numMode);
         this._emitChange();
     }
@@ -487,18 +486,18 @@ async function _open($, path, opt) {
     var _a;
     path = normalizePath(path);
     const mode = normalizeMode(opt.mode, 0o644), flag = parseFlag(opt.flag);
-    const { fullPath: realpath, fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
+    const { fullPath, fs, path: resolved, stats } = await _resolve($, path.toString(), opt.preserveSymlinks);
     if (!stats) {
         if ((!isWriteable(flag) && !isAppendable(flag)) || flag == 'r+') {
-            throw ErrnoError.With('ENOENT', realpath, '_open');
+            throw ErrnoError.With('ENOENT', fullPath, '_open');
         }
         // Create the file
         const parentStats = await fs.stat(dirname(resolved));
         if (config.checkAccess && !parentStats.hasAccess(constants.W_OK, $)) {
-            throw ErrnoError.With('EACCES', dirname(realpath), '_open');
+            throw ErrnoError.With('EACCES', dirname(fullPath), '_open');
         }
         if (!parentStats.isDirectory()) {
-            throw ErrnoError.With('ENOTDIR', dirname(realpath), '_open');
+            throw ErrnoError.With('ENOTDIR', dirname(fullPath), '_open');
         }
         const { euid: uid, egid: gid } = (_a = $ === null || $ === void 0 ? void 0 : $.credentials) !== null && _a !== void 0 ? _a : credentials;
         const file = await fs.createFile(resolved, flag, mode, { uid, gid });
@@ -506,10 +505,10 @@ async function _open($, path, opt) {
         return new FileHandle(file, $);
     }
     if (config.checkAccess && !stats.hasAccess(flagToMode(flag), $)) {
-        throw ErrnoError.With('EACCES', realpath, '_open');
+        throw ErrnoError.With('EACCES', fullPath, '_open');
     }
     if (isExclusive(flag)) {
-        throw ErrnoError.With('EEXIST', realpath, '_open');
+        throw ErrnoError.With('EEXIST', fullPath, '_open');
     }
     const handle = new FileHandle(await fs.openFile(resolved, flag), $);
     /*
@@ -768,11 +767,11 @@ export async function symlink(target, path, type = 'file') {
         if (!['file', 'dir', 'junction'].includes(type)) {
             throw new ErrnoError(Errno.EINVAL, 'Invalid symlink type: ' + type);
         }
-        if (await exists.call(this, path)) {
-            throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
-        }
+        path = normalizePath(path);
+        if (await exists.call(this, path))
+            throw ErrnoError.With('EEXIST', path, 'symlink');
         const handle = __addDisposableResource(env_5, await _open(this, path, { flag: 'w+', mode: 0o644, preserveSymlinks: true }), true);
-        await handle.writeFile(target.toString());
+        await handle.writeFile(normalizePath(target, true));
         await handle.file.chmod(constants.S_IFLNK);
     }
     catch (e_5) {
@@ -965,8 +964,7 @@ async function _resolve($, path, preserveSymlinks) {
             return { ...resolved, fullPath: maybePath, stats };
         }
         const target = resolve(realDir, (await readlink.call($, maybePath)).toString());
-        const real = await realpath.call($, target);
-        return { ...resolved, fullPath: real, stats };
+        return await _resolve($, target);
     }
     catch (e) {
         if (e.code == 'ENOENT') {

package/dist/vfs/sync.js

@@ -235,11 +235,12 @@ openSync;
 export function lopenSync(path, flag, mode) {
     return file2fd(_openSync.call(this, path, { flag, mode, preserveSymlinks: true }));
 }
-function _readFileSync(fname, flag, preserveSymlinks) {
+function _readFileSync(path, flag, preserveSymlinks) {
     const env_2 = { stack: [], error: void 0, hasError: false };
     try {
+        path = normalizePath(path);
         // Get file.
-        const file = __addDisposableResource(env_2, _openSync.call(this, fname, { flag, mode: 0o644, preserveSymlinks }), false);
+        const file = __addDisposableResource(env_2, _openSync.call(this, path, { flag, mode: 0o644, preserveSymlinks }), false);
         const stat = file.statSync();
         // Allocate buffer.
         const data = new Uint8Array(stat.size);
@@ -260,7 +261,7 @@ export function readFileSync(path, _options = {}) {
     if (!isReadable(flag)) {
         throw new ErrnoError(Errno.EINVAL, 'Flag passed to readFile must allow for reading.');
     }
-    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path.toString(), options.flag, false));
+    const data = Buffer.from(_readFileSync.call(this, typeof path == 'number' ? fd2file(path).path : path, options.flag, false));
     return options.encoding ? data.toString(options.encoding) : data;
 }
 readFileSync;
@@ -564,13 +565,13 @@ export function symlinkSync(target, path, type = 'file') {
     if (existsSync.call(this, path)) {
         throw ErrnoError.With('EEXIST', path.toString(), 'symlink');
     }
-    writeFileSync.call(this, path, target.toString());
+    writeFileSync.call(this, path, normalizePath(target, true));
     const file = _openSync.call(this, path, { flag: 'r+', mode: 0o644, preserveSymlinks: true });
     file.chmodSync(constants.S_IFLNK);
 }
 symlinkSync;
 export function readlinkSync(path, options) {
-    const value = Buffer.from(_readFileSync.call(this, path.toString(), 'r', true));
+    const value = Buffer.from(_readFileSync.call(this, path, 'r', true));
     const encoding = typeof options == 'object' ? options === null || options === void 0 ? void 0 : options.encoding : options;
     if (encoding == 'buffer') {
         return value;
@@ -657,8 +658,7 @@ function _resolveSync($, path, preserveSymlinks) {
             return { ...resolved, fullPath: maybePath, stats };
         }
         const target = resolve(realDir, readlinkSync.call($, maybePath).toString());
-        const real = realpathSync.call($, target);
-        return { ...resolved, fullPath: real, stats };
+        return _resolveSync($, target);
     }
     catch (e) {
         if (e.code == 'ENOENT') {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.9.4",
+	"version": "1.9.5",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/scripts/test.js

@@ -51,7 +51,7 @@ Output:
     -h, --help          Outputs this help message
     -w, --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
+    -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
     -C, --ci            Continuous integration (CI) mode. This interacts with the Github
                         Checks API for better test status. Requires @octokit/action
@@ -166,9 +166,12 @@ if (options.common) {
 	!options.quiet && console.log('Running common tests...');
 	const { pass, fail } = await status('Common tests');
 	try {
-		execSync(`tsx ${options.inspect ? 'inspect' : ''} --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'`, {
-			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
-		});
+		execSync(
+			`tsx ${options.inspect ? 'inspect' : ''} ${options.force ? '--test-force-exit' : ''} --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'`,
+			{
+				stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
+			}
+		);
 		await pass();
 	} catch {
 		await fail();

package/tests/backend/port.test.ts

@@ -2,6 +2,7 @@ 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 type { InMemoryStore, StoreFS } from '../../dist/index.js';
 import { ErrnoError, InMemory, configure, configureSingle, fs, resolveMountConfig } from '../../dist/index.js';
 
@@ -49,12 +50,13 @@ timeoutChannel.port1.unref();
 // Test configuration
 
 const configPort = new Worker(import.meta.dirname + '/config.worker.js');
+await waitOnline(configPort);
 
 await suite('Remote FS with resolveRemoteMount', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: configPort, timeout: 500 });
+		await configureSingle({ backend: Port, port: configPort, timeout: 100 });
 	});
 
 	test('Write', async () => {
@@ -62,11 +64,11 @@ await suite('Remote FS with resolveRemoteMount', () => {
 	});
 
 	test('Read', async () => {
-		assert((await fs.promises.readFile('/test', 'utf8')) === content);
+		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
 });
 
-await configPort?.terminate();
+await configPort.terminate();
 configPort.unref();
 
 // Test using a message channel
@@ -79,7 +81,7 @@ await suite('FS with MessageChannel', () => {
 	test('configuration', async () => {
 		tmpfs = await resolveMountConfig({ backend: InMemory, name: 'tmp' });
 		attachFS(channel.port2, tmpfs);
-		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 250 });
+		await configureSingle({ backend: Port, port: channel.port1, disableAsyncCache: true, timeout: 100 });
 	});
 
 	test('write', async () => {
@@ -88,12 +90,12 @@ await suite('FS with MessageChannel', () => {
 
 	test('remote content', () => {
 		fs.mount('/tmp', tmpfs);
-		assert(fs.readFileSync('/tmp/test', 'utf8') == content);
+		assert.equal(fs.readFileSync('/tmp/test', 'utf8'), content);
 		fs.umount('/tmp');
 	});
 
 	test('read', async () => {
-		assert((await fs.promises.readFile('/test', 'utf8')) === content);
+		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
 
 	test('readFileSync should throw', () => {
@@ -101,6 +103,8 @@ await suite('FS with MessageChannel', () => {
 	});
 });
 
+channel.port1.close();
+channel.port2.close();
 channel.port1.unref();
 channel.port2.unref();
 
@@ -112,7 +116,7 @@ await suite('Remote FS', () => {
 	const content = 'FS is in a port';
 
 	test('Configuration', async () => {
-		await configureSingle({ backend: Port, port: remotePort, timeout: 500 });
+		await configureSingle({ backend: Port, port: remotePort, timeout: 100 });
 	});
 
 	test('Write', async () => {
@@ -122,8 +126,6 @@ await suite('Remote FS', () => {
 	test('Read', async () => {
 		assert.equal(await fs.promises.readFile('/test', 'utf8'), content);
 	});
-
-	test('Cleanup', async () => {});
 });
 
 await remotePort.terminate();

package/tests/common/path.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { basename, dirname, extname, join, normalize, resolve } from '../../dist/vfs/path.js';
+import * as fs from '../../dist/vfs/index.js';
 
 suite('Path emulation', () => {
 	test('resolve', () => {
@@ -31,4 +32,15 @@ suite('Path emulation', () => {
 		assert.equal(extname('/path/to/file.txt'), '.txt');
 		assert.equal(extname('/path/to/file'), '');
 	});
+
+	test('file:// URL (string)', () => {
+		fs.writeFileSync('/example.txt', 'Yay');
+		assert.equal(fs.readFileSync('file:///example.txt', 'utf-8'), 'Yay');
+	});
+
+	test('file:// URL (URL)', () => {
+		fs.writeFileSync('/example.txt', 'Yay');
+		const url = new URL('file:///example.txt');
+		assert.equal(fs.readFileSync(url, 'utf-8'), 'Yay');
+	});
 });

package/tests/fs/links.test.ts

@@ -27,6 +27,31 @@ suite('Links', () => {
 		assert.equal(await fs.promises.readFile(target, 'utf-8'), await fs.promises.readFile(symlink, 'utf-8'));
 	});
 
+	test('nested symlinks', async () => {
+		// Create the real directory structure
+		const realDir = '/real-dir';
+		const realFile = '/real-dir/realfile.txt';
+		const fileContent = 'hello world';
+		await fs.promises.mkdir(realDir);
+		await fs.promises.writeFile(realFile, fileContent);
+		// Create first symlink (symlink-dir -> real-dir)
+		const symlinkDir = '/symlink-dir';
+		await fs.promises.symlink(realDir, symlinkDir);
+		const symfile = 'symfile.txt';
+		const symlinkFile = join(realDir, symfile);
+		// Create second symlink (symlink-dir -> real-dir)
+		await fs.promises.symlink(realFile, symlinkFile);
+		// Now access file through nested symlinks
+		const nestedPath = join(symlinkDir, symfile);
+		// Verify realpath resolution
+		const resolvedPath = await fs.promises.realpath(nestedPath);
+		assert.equal(resolvedPath, realFile);
+		// Verify content can be read through nested symlinks
+		const content = await fs.promises.readFile(nestedPath, 'utf8');
+		assert.notEqual(content, '/real-dir/realfile.txt');
+		assert.equal(content, fileContent);
+	});
+
 	test('unlink', async () => {
 		await fs.promises.unlink(symlink);
 		assert(!(await fs.promises.exists(symlink)));