@zenfs/core 2.6.1 → 2.6.3

package/dist/utils.js

@@ -51,6 +51,14 @@ export function validateFD(fd) {
         code: 'ERR_OUT_OF_RANGE',
     });
 }
+/**
+ * Whether an error means the path does not resolve to an entry. Used for `throwIfNoEntry`.
+ * @internal @hidden
+ */
+export function _isNoEntry(e) {
+    const { code } = (e ?? {});
+    return code == 'ENOENT' || code == 'ENOTDIR';
+}
 /**
  * Normalizes a time to milliseconds since the epoch.
  * Note numbers and numeric strings are seconds, like Node's `toUnixTimestamp`.
@@ -140,3 +148,12 @@ export function _tempDirName(prefix) {
     // Like Node, the prefix is a path. A relative one is resolved against the working directory, not `/tmp`.
     return `${normalizePath(prefix, true)}${Date.now()}-${Math.random().toString(36).slice(2)}`;
 }
+/**
+ * Resolves the global `Temporal`, which is not implemented by all runtimes.
+ * @internal @hidden
+ */
+export function _temporal() {
+    if ('Temporal' in globalThis && typeof globalThis.Temporal !== 'undefined')
+        return globalThis.Temporal;
+    throw withErrno('ENOTSUP', 'Temporal is not supported by this runtime');
+}

package/dist/vfs/async.js

@@ -102,7 +102,7 @@ export async function resolve($, path, preserveSymlinks, extra) {
             throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
         }));
     if (!stats)
-        return { ...resolved, fullPath: path };
+        return { ...resolved, fullPath: maybePath };
     if (!isSymbolicLink(stats)) {
         return { ...resolved, fullPath: maybePath, stats };
     }
@@ -184,16 +184,36 @@ export async function readlink(path) {
     return decodeUTF8(data);
 }
 export async function mkdir(path, options = {}) {
-    path = normalizePath(path);
+    const original = normalizePath(path);
     const { euid: uid, egid: gid } = contextOf(this).credentials;
     const { mode = 0o777, recursive } = options;
-    const { fs, path: resolved } = resolveMount(path, this, { syscall: 'mkdir' });
-    const __create = async (path, resolved, parent) => {
+    const $ex = { syscall: 'mkdir', path: original };
+    const { fullPath: realParent } = await resolve(this, dirname(original), false, $ex);
+    const { fs, path: target } = resolveMount(join(realParent, basename(original)), this, $ex);
+    const followed = realParent != dirname(original);
+    let firstCreated;
+    const __create = async (path, resolved) => {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
+            const parentPath = dirname(resolved);
+            const parent = recursive && parentPath != '/' ? await __create(dirname(path), parentPath) : await fs.stat(parentPath);
+            const _ = __addDisposableResource(env_2, await lockPath(fs, parentPath, 'rw', parent), false);
+            if (recursive) {
+                const existing = cacheOf(fs).get(resolved)?.inode ?? (await fs.stat(resolved).catch(() => null));
+                if (existing) {
+                    const stats = isSymbolicLink(existing) ? (await resolve(this, path, false, $ex)).stats : existing;
+                    if (!stats)
+                        throw UV('ENOENT', $ex);
+                    if (!isDirectory(stats))
+                        throw UV(resolved == target ? 'EEXIST' : 'ENOTDIR', $ex);
+                    return existing;
+                }
+                // Node reports the link itself with ENOTDIR here, while `mkdirSync` reports the requested path with ENOENT
+                if (followed && (await fs.exists(join(parentPath, basename(path)))))
+                    throw UV('ENOTDIR', 'mkdir', path);
+            }
             if (checkAccess && !hasAccess(this, parent, constants.W_OK))
                 throw UV('EACCES', 'mkdir', path);
-            const _ = __addDisposableResource(env_2, await lockPath(fs, dirname(resolved), 'rw', parent), false);
             const inode = await fs
                 .mkdir(resolved, {
                 mode,
@@ -201,6 +221,8 @@ export async function mkdir(path, options = {}) {
                 gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
             })
                 .catch(rethrow({ syscall: 'mkdir', path }));
+            if (recursive)
+                firstCreated ??= path;
             emitChange(this, 'rename', path);
             return inode;
         }
@@ -212,22 +234,8 @@ export async function mkdir(path, options = {}) {
             __disposeResources(env_2);
         }
     };
-    if (!recursive) {
-        await __create(path, resolved, await fs.stat(dirname(resolved)));
-        return;
-    }
-    const dirs = [];
-    let origDir = path;
-    for (let dir = resolved; !(await fs.exists(dir)); dir = dirname(dir), origDir = dirname(origDir)) {
-        dirs.unshift([origDir, dir]);
-    }
-    if (!dirs.length)
-        return;
-    const stats = [await fs.stat(dirname(dirs[0][1]))];
-    for (const [i, [path, resolved]] of dirs.entries()) {
-        stats.push(await __create(path, resolved, stats[i]));
-    }
-    return dirs[0][0];
+    await __create(original, target);
+    return firstCreated;
 }
 export async function readdir(path, options = {}) {
     path = normalizePath(path);

package/dist/vfs/shared.js

@@ -97,14 +97,16 @@ export function resolveMount(path, ctx, extra) {
 export function _statfs(fs, bigint) {
     const md = fs.usage();
     const bs = md.blockSize || 4096;
+    const type = bigint ? BigInt : Number;
     return {
-        type: (bigint ? BigInt : Number)(fs.type),
-        bsize: (bigint ? BigInt : Number)(bs),
-        ffree: (bigint ? BigInt : Number)(md.freeNodes || size_max),
-        files: (bigint ? BigInt : Number)(md.totalNodes || size_max),
-        bavail: (bigint ? BigInt : Number)(md.freeSpace / bs),
-        bfree: (bigint ? BigInt : Number)(md.freeSpace / bs),
-        blocks: (bigint ? BigInt : Number)(md.totalSpace / bs),
+        type: type(fs.type),
+        bsize: type(bs),
+        frsize: type(bs),
+        ffree: type(md.freeNodes || size_max),
+        files: type(md.totalNodes || size_max),
+        bavail: type(md.freeSpace / bs),
+        bfree: type(md.freeSpace / bs),
+        blocks: type(md.totalSpace / bs),
     };
 }
 /**

package/dist/vfs/sync.js

@@ -100,7 +100,7 @@ export function resolve($, path, preserveSymlinks, extra) {
     }
     catch (e) {
         if (e.code === 'ENOENT')
-            return { ...resolved, fullPath: path };
+            return { ...resolved, fullPath: maybePath };
         throw setUVMessage(Object.assign(e, { syscall: 'stat', path: maybePath, ...extra }));
     }
     if (!isSymbolicLink(stats)) {
@@ -189,21 +189,48 @@ export function readlink(path) {
     return decodeUTF8(data);
 }
 export function mkdir(path, options = {}) {
-    path = normalizePath(path);
-    const { fs, path: resolved } = resolve(this, path);
+    const original = normalizePath(path);
+    const $ex = { syscall: 'mkdir', path: original };
+    const { fullPath: realParent } = resolve(this, dirname(original), false, $ex);
+    const { fs, path: target } = resolveMount(join(realParent, basename(original)), this, $ex);
+    const followed = realParent != dirname(original);
     const { euid: uid, egid: gid } = contextOf(this).credentials;
     const { mode = 0o777, recursive } = options;
-    const __create = (path, resolved, parent) => {
+    let firstCreated;
+    const __create = (path, resolved) => {
         const env_2 = { stack: [], error: void 0, hasError: false };
         try {
+            const parentPath = dirname(resolved);
+            const parent = recursive && parentPath != '/' ? __create(dirname(path), parentPath) : fs.statSync(parentPath);
+            if (recursive) {
+                let existing;
+                try {
+                    existing = cacheOf(fs).get(resolved)?.inode ?? fs.statSync(resolved);
+                }
+                catch {
+                    // It doesn't exist yet
+                }
+                if (existing) {
+                    const stats = isSymbolicLink(existing) ? resolve(this, path, false, $ex).stats : existing;
+                    if (!stats)
+                        throw UV('ENOENT', $ex);
+                    if (!isDirectory(stats))
+                        throw UV(resolved == target ? 'EEXIST' : 'ENOTDIR', $ex);
+                    return existing;
+                }
+                if (followed && fs.existsSync(join(parentPath, basename(path))))
+                    throw UV('ENOENT', $ex);
+            }
             if (checkAccess && !hasAccess(this, parent, constants.W_OK))
-                throw UV('EACCES', 'mkdir', dirname(path));
-            const _ = __addDisposableResource(env_2, lockPathSync(fs, dirname(resolved), 'rw', parent), false);
+                throw UV('EACCES', 'mkdir', path);
+            const _ = __addDisposableResource(env_2, lockPathSync(fs, parentPath, 'rw', parent), false);
             const inode = wrap(fs, 'mkdirSync', { path, syscall: 'mkdir' })(resolved, {
                 mode,
                 uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
                 gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
             });
+            if (recursive)
+                firstCreated ??= path;
             emitChange(this, 'rename', path);
             return inode;
         }
@@ -215,21 +242,8 @@ export function mkdir(path, options = {}) {
             __disposeResources(env_2);
         }
     };
-    if (!recursive) {
-        __create(path, resolved, fs.statSync(dirname(resolved)));
-        return;
-    }
-    const dirs = [];
-    for (let dir = resolved, original = path; !fs.existsSync(dir); dir = dirname(dir), original = dirname(original)) {
-        dirs.unshift({ resolved: dir, original });
-    }
-    if (!dirs.length)
-        return;
-    const stats = [fs.statSync(dirname(dirs[0].resolved))];
-    for (const [i, dir] of dirs.entries()) {
-        stats.push(__create(dir.original, dir.resolved, stats[i]));
-    }
-    return dirs[0].original;
+    __create(original, target);
+    return firstCreated;
 }
 export function readdir(path, options = {}) {
     path = normalizePath(path);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "2.6.1",
+	"version": "2.6.3",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",
@@ -71,18 +71,18 @@
 		"prepublishOnly": "npm run build"
 	},
 	"dependencies": {
-		"@types/node": "^25.2.0",
+		"@types/node": "^26.0.0",
 		"buffer": "^6.0.3",
 		"eventemitter3": "^5.0.1",
 		"kerium": "^1.4.2",
-		"memium": "^0.4.0",
+		"memium": "^1.0.0",
 		"readable-stream": "^4.5.2",
 		"utilium": "^3.0.0"
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
 		"@octokit/action": "^8.0.4",
-		"c8": "^11.0.0",
+		"c8": "^12.0.0",
 		"eslint": "^10.1.0",
 		"globals": "^17.3.0",
 		"prettier": "^3.2.5",

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

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+import { parentPort, workerData } from 'node:worker_threads';
+import { SuperBlock } from '../../dist/backends/single_buffer.js';
+import { setupLogs } from '../logs.js';
+
+setupLogs('<worker>');
+
+const { buffer, gate, rotations } = workerData;
+
+const superblock = new SuperBlock(buffer);
+
+parentPort.postMessage('ready');
+
+Atomics.wait(gate, 0, 0, 1000);
+
+const offsets = [];
+for (let i = 0; i < rotations; i++) offsets.push(superblock.rotateMetadata().byteOffset);
+
+parentPort.postMessage(offsets);

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

@@ -3,7 +3,9 @@ import assert from 'node:assert';
 import { randomBytes } from 'node:crypto';
 import { suite, test } from 'node:test';
 import { Worker } from 'worker_threads';
+import { sizeof } from 'memium';
 import { fs, mount, resolveMountConfig, SingleBuffer, vfs } from '@zenfs/core';
+import { MetadataBlock, SuperBlock } from '@zenfs/core/backends/single_buffer.js';
 import { setupLogs } from '../logs.js';
 
 setupLogs();
@@ -53,6 +55,88 @@ await suite('SingleBuffer', () => {
 		assert(fs.existsSync('/shared/worker-file.ts'));
 	});
 
+	test('aligns metadata when used_bytes is unaligned #309', () => {
+		// Writers reserve data of any length, so used_bytes can sit at any remainder when the metadata block is rotated.
+		for (const used of [8192n, 8193n, 8194n, 8195n]) {
+			const superblock = new SuperBlock(new ArrayBuffer(0x100000));
+			superblock.used_bytes = used;
+
+			const metadata = superblock.rotateMetadata();
+			const expected = Number((used + 3n) & ~3n);
+
+			assert.strictEqual(metadata.byteOffset, expected, `metadata offset for used_bytes ${used}`);
+			assert.strictEqual(superblock.used_bytes, BigInt(expected + sizeof(MetadataBlock)), `used_bytes after rotating from ${used}`);
+		}
+	});
+
+	test('refuses to rotate metadata past the end of the filesystem', () => {
+		const exhausted = new SuperBlock(new ArrayBuffer(sizeof(SuperBlock) + sizeof(MetadataBlock) + 4));
+		const exhaustedUsed = exhausted.used_bytes;
+
+		assert.throws(() => exhausted.rotateMetadata(), { code: 'ENOSPC' }, 'rotating without room should fail with ENOSPC');
+		assert.strictEqual(exhausted.used_bytes, exhaustedUsed, 'a failed rotation must not consume space');
+
+		const constrained = new SuperBlock(new ArrayBuffer(0x100000));
+		constrained.total_bytes = BigInt(sizeof(SuperBlock) + sizeof(MetadataBlock) + 4);
+		const constrainedUsed = constrained.used_bytes;
+
+		assert.throws(() => constrained.rotateMetadata(), { code: 'ENOSPC' }, 'rotating past total_bytes should fail with ENOSPC');
+		assert.strictEqual(constrained.used_bytes, constrainedUsed, 'a failed rotation must not consume space');
+		assert(constrained.used_bytes <= constrained.total_bytes, 'used_bytes must never exceed total_bytes');
+	});
+
+	test('concurrent rotation keeps every metadata block reachable', async () => {
+		const rotations = 100;
+		const buffer = new SharedArrayBuffer(0x200000);
+		const gate = new Int32Array(new SharedArrayBuffer(Int32Array.BYTES_PER_ELEMENT));
+
+		const superblock = new SuperBlock(buffer);
+		const original = superblock.metadata_offset;
+
+		const worker = new Worker(import.meta.dirname + '/single-buffer-rotate.worker.js', { workerData: { buffer, gate, rotations } });
+
+		const ready = Promise.withResolvers<void>();
+		const finished = Promise.withResolvers<number[]>();
+		const expired = setTimeout(() => {
+			const error = new Error('the worker did not finish rotating');
+			ready.reject(error);
+			finished.reject(error);
+		}, 1000);
+
+		worker.on('error', error => {
+			ready.reject(error);
+			finished.reject(error);
+		});
+		worker.on('message', message => (message === 'ready' ? ready.resolve() : finished.resolve(message as number[])));
+
+		try {
+			await ready.promise;
+
+			Atomics.store(gate, 0, 1);
+			Atomics.notify(gate, 0);
+
+			const mine: number[] = [];
+			for (let i = 0; i < rotations; i++) mine.push(superblock.rotateMetadata().byteOffset);
+
+			const theirs = await finished.promise;
+
+			const chain = new Set<number>();
+			for (let block: MetadataBlock | undefined = new SuperBlock(buffer).metadata; block; block = block.previous) {
+				if (chain.has(block.byteOffset)) break;
+				chain.add(block.byteOffset);
+			}
+
+			assert.strictEqual(new Set([...mine, ...theirs]).size, rotations * 2, 'two rotations reserved the same offset');
+			assert.strictEqual(chain.size, rotations * 2 + 1, 'blocks are missing from the chain');
+
+			for (const offset of [original, ...mine, ...theirs]) assert(chain.has(offset), `the block at ${offset} is not in the chain`);
+		} finally {
+			clearTimeout(expired);
+			await worker.terminate();
+			worker.unref();
+		}
+	});
+
 	test('reliability across varied file sizes', async () => {
 		const mountPoint = '/sbfs-reliability';
 		const verifyMountPoint = '/sbfs-verify';
@@ -98,4 +182,26 @@ await suite('SingleBuffer', () => {
 			vfs.umount(mountPoint);
 		}
 	});
+
+	test('keeps metadata aligned when files have uneven sizes #309', async () => {
+		const mountPoint = '/sbfs-rotation';
+		const buffer = new ArrayBuffer(0x400000);
+		const writable = await resolveMountConfig({ backend: SingleBuffer, buffer, label: 'rotation' });
+		mount(mountPoint, writable);
+
+		// Uneven writes leave used_bytes between alignment boundaries when the metadata block fills up.
+		const sizes = [1, 17, 257, 3, 5, 13, 1023, 4095, 7, 9];
+		try {
+			for (let i = 0; i < 400; i++) {
+				const content = Buffer.alloc(sizes[i % sizes.length], i & 0xff);
+				fs.writeFileSync(`${mountPoint}/f${i}.txt`, content);
+			}
+			for (let i = 0; i < 400; i += 37) {
+				const expected = Buffer.alloc(sizes[i % sizes.length], i & 0xff);
+				assert.deepStrictEqual(fs.readFileSync(`${mountPoint}/f${i}.txt`), expected, `content mismatch at f${i}.txt`);
+			}
+		} finally {
+			vfs.umount(mountPoint);
+		}
+	});
 });

package/tests/common/context.test.ts

@@ -78,4 +78,50 @@ suite('Context', () => {
 
 		assert.equal(ctx.realpathSync('.'), '/test');
 	});
+
+	test('globSync should keep the context', () => {
+		ctx.mkdirSync('/globbed');
+		ctx.writeFileSync('/globbed/inside.txt', 'in the context');
+
+		fs.mkdirSync('/globbed');
+		fs.writeFileSync('/globbed/outside.txt', 'not in the context');
+
+		const results = ctx.globSync('**/*.txt', { cwd: '/' });
+		assert(results.includes('globbed/inside.txt'), 'should match files in the context root');
+		assert(!results.includes('globbed/outside.txt'), 'should not match files outside the context root');
+	});
+
+	test('glob should keep the context', async () => {
+		const results = await Array.fromAsync(ctx.promises.glob('**/*.txt', { cwd: '/' }));
+
+		assert(results.includes('globbed/inside.txt'));
+		assert(!results.includes('globbed/outside.txt'), 'should not match files outside the context root');
+	});
+
+	test('glob resolves a relative cwd against the context', () => {
+		const { pwd } = context;
+		context.pwd = '/';
+
+		assert.deepEqual(ctx.globSync('*', { cwd: '/globbed' }), ['inside.txt']);
+		assert.deepEqual(ctx.globSync('*', { cwd: 'globbed' }), ['inside.txt']);
+
+		context.pwd = pwd;
+	});
+
+	test('glob defaults cwd to the working directory of the context', () => {
+		const { pwd } = context;
+		context.pwd = '/globbed';
+
+		assert.deepEqual(ctx.globSync('*'), ['inside.txt']);
+
+		context.pwd = pwd;
+	});
+
+	test('copyFileSync should keep the context #307', () => {
+		ctx.writeFileSync('/source.txt', 'not in real root!');
+		ctx.copyFileSync('/source.txt', '/copy.txt');
+
+		assert.equal(ctx.readFileSync('/copy.txt', 'utf-8'), 'not in real root!');
+		assert(fs.readdirSync('/ctx').includes('copy.txt'));
+	});
 });

package/tests/common/glob.test.ts

@@ -13,6 +13,8 @@ fs.writeFileSync('/glob/c.js', 'c');
 fs.writeFileSync('/glob/sub/d.txt', 'd');
 fs.writeFileSync('/glob/sub/e.js', 'e');
 fs.writeFileSync('/glob/sub/deep/f.txt', 'f');
+fs.symlinkSync('sub', '/glob/link');
+fs.symlinkSync('/glob/nowhere', '/glob/dangling');
 
 suite('globSync', () => {
 	test('wildcard in root', () => {
@@ -82,6 +84,66 @@ suite('globSync', () => {
 		assert(!results.includes('glob/c.js'), 'should exclude .js files');
 		assert(results.includes('glob/a.txt'), 'should still include .txt files');
 	});
+
+	test('cwd option', () => {
+		const results = fs.globSync('*', { cwd: '/glob' });
+		assert(results.includes('a.txt'), 'results should be relative to cwd');
+		assert(results.includes('sub'));
+		assert(!results.includes('glob/a.txt'), 'results should not be relative to the root');
+	});
+
+	test('patterns are relative to cwd', () => {
+		assert.deepEqual(fs.globSync('*.txt', { cwd: '/glob/sub' }), ['d.txt']);
+		assert.deepEqual(fs.globSync('deep/*.txt', { cwd: '/glob/sub' }), ['deep/f.txt']);
+	});
+
+	test('absolute patterns are relative to cwd', () => {
+		assert.deepEqual(fs.globSync('/glob/sub/*.txt', { cwd: '/glob' }), ['sub/d.txt']);
+		assert.deepEqual(fs.globSync('/glob/sub/*.txt', { cwd: '/glob/sub' }), ['d.txt']);
+	});
+
+	test('exclude receives paths relative to cwd', () => {
+		const seen: string[] = [];
+		fs.globSync('*', {
+			cwd: '/glob',
+			exclude: path => {
+				seen.push(path);
+				return false;
+			},
+		});
+		assert(seen.includes('a.txt'), 'should be given cwd-relative paths');
+		assert(!seen.some(p => p.startsWith('/')), 'should not be given absolute paths');
+	});
+
+	test('globstar does not follow symlinks by default', () => {
+		const results = fs.globSync('/glob/**/*.txt');
+		assert(results.includes('glob/sub/d.txt'), 'should include the real directory');
+		assert(!results.includes('glob/link/d.txt'), 'should not descend into a symlinked directory');
+	});
+
+	test('followSymlinks option', () => {
+		const results = fs.globSync('/glob/**/*.txt', { followSymlinks: true });
+		assert(results.includes('glob/link/d.txt'), 'should descend into a symlinked directory');
+		assert(results.includes('glob/link/deep/f.txt'), 'should descend recursively');
+		assert(results.includes('glob/sub/d.txt'), 'should still include the real directory');
+	});
+
+	test('a symlink named by the pattern is always descended into', () => {
+		const results = fs.globSync('/glob/link/*.txt');
+		assert(results.includes('glob/link/d.txt'), 'should not need followSymlinks when the pattern names the link');
+	});
+
+	test('the symlink itself is still matched', () => {
+		for (const followSymlinks of [false, true]) {
+			const results = fs.globSync('/glob/*', { followSymlinks });
+			assert(results.includes('glob/link'), `should match the link itself (followSymlinks: ${followSymlinks})`);
+		}
+	});
+
+	test('dangling symlinks do not throw', () => {
+		const results = fs.globSync('/glob/**', { followSymlinks: true });
+		assert(results.includes('glob/dangling'), 'should match a dangling link without following it');
+	});
 });
 
 await suite('promises.glob', () => {
@@ -132,4 +194,27 @@ await suite('promises.glob', () => {
 		const results = await Array.fromAsync(fs.promises.glob('/glob/*.xyz'));
 		assert.equal(results.length, 0);
 	});
+
+	test('globstar does not follow symlinks by default', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/**/*.txt'));
+		assert(results.includes('glob/sub/d.txt'));
+		assert(!results.includes('glob/link/d.txt'), 'should not descend into a symlinked directory');
+	});
+
+	test('followSymlinks option', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/**/*.txt', { followSymlinks: true }));
+		assert(results.includes('glob/link/d.txt'));
+		assert(results.includes('glob/link/deep/f.txt'));
+		assert(results.includes('glob/sub/d.txt'));
+	});
+
+	test('a symlink named by the pattern is always descended into', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/link/*.txt'));
+		assert(results.includes('glob/link/d.txt'));
+	});
+
+	test('dangling symlinks do not throw', async () => {
+		const results = await Array.fromAsync(fs.promises.glob('/glob/**', { followSymlinks: true }));
+		assert(results.includes('glob/dangling'));
+	});
 });