@zenfs/core 2.6.1 → 2.6.2

package/dist/backends/cow.d.ts

@@ -46,6 +46,7 @@ export declare class Journal extends EventEmitter<{
     fromString(value: string): this;
     add(op: JournalOperation, path: string): void;
     has(op: JournalOperation, path: string): boolean;
+    delete(op: JournalOperation, path: string): void;
     isDeleted(path: string): boolean;
 }
 /**

package/dist/backends/cow.js

@@ -53,6 +53,9 @@ export class Journal extends EventEmitter {
                 return true;
         return false;
     }
+    delete(op, path) {
+        this.entries = this.entries.filter(entry => entry.op != op || entry.path != path);
+    }
     isDeleted(path) {
         let deleted = false;
         for (const entry of this.entries) {
@@ -168,6 +171,9 @@ export class CopyOnWriteFS extends FileSystem {
             if (this.isDeleted(oldPath))
                 throw withErrno('ENOENT');
         }
+        if (await this.readable.exists(oldPath))
+            this.journal.add('delete', oldPath);
+        this.journal.delete('delete', newPath);
         this.renameInos(oldPath, newPath);
     }
     renameSync(oldPath, newPath) {
@@ -179,6 +185,9 @@ export class CopyOnWriteFS extends FileSystem {
             if (this.isDeleted(oldPath))
                 throw withErrno('ENOENT');
         }
+        if (this.readable.existsSync(oldPath))
+            this.journal.add('delete', oldPath);
+        this.journal.delete('delete', newPath);
         this.renameInos(oldPath, newPath);
     }
     async stat(path) {
@@ -211,19 +220,25 @@ export class CopyOnWriteFS extends FileSystem {
     }
     async createFile(path, options) {
         await this.createParentDirectories(path);
-        return this.remapIno(path, await this.writable.createFile(path, options));
+        const inode = await this.writable.createFile(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     createFileSync(path, options) {
         this.createParentDirectoriesSync(path);
-        return this.remapIno(path, this.writable.createFileSync(path, options));
+        const inode = this.writable.createFileSync(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     async link(srcpath, dstpath) {
         await this.copyForWrite(srcpath);
         await this.writable.link(srcpath, dstpath);
+        this.journal.delete('delete', dstpath);
     }
     linkSync(srcpath, dstpath) {
         this.copyForWriteSync(srcpath);
         this.writable.linkSync(srcpath, dstpath);
+        this.journal.delete('delete', dstpath);
     }
     async unlink(path) {
         if (!(await this.exists(path)))
@@ -285,19 +300,27 @@ export class CopyOnWriteFS extends FileSystem {
         if (await this.exists(path))
             throw withErrno('EEXIST');
         await this.createParentDirectories(path);
-        return this.remapIno(path, await this.writable.mkdir(path, options));
+        const inode = await this.writable.mkdir(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     mkdirSync(path, options) {
         if (this.existsSync(path))
             throw withErrno('EEXIST');
         this.createParentDirectoriesSync(path);
-        return this.remapIno(path, this.writable.mkdirSync(path, options));
+        const inode = this.writable.mkdirSync(path, options);
+        this.journal.delete('delete', path);
+        return this.remapIno(path, inode);
     }
     async readdir(path) {
-        if (this.isDeleted(path) || !(await this.exists(path)))
+        if (this.isDeleted(path))
+            throw withErrno('ENOENT');
+        const readable = await this.readable.stat(path).catch(() => null);
+        const writable = await this.writable.stat(path).catch(() => null);
+        if (!readable && !writable)
             throw withErrno('ENOENT');
-        const entries = (await this.readable.exists(path)) ? await this.readable.readdir(path) : [];
-        if (await this.writable.exists(path))
+        const entries = readable && isDirectory(readable) ? await this.readable.readdir(path) : [];
+        if (writable && isDirectory(writable))
             for (const entry of await this.writable.readdir(path)) {
                 if (!entries.includes(entry))
                     entries.push(entry);
@@ -305,10 +328,26 @@ export class CopyOnWriteFS extends FileSystem {
         return entries.filter(entry => !this.isDeleted(join(path, entry)));
     }
     readdirSync(path) {
-        if (this.isDeleted(path) || !this.existsSync(path))
+        if (this.isDeleted(path))
+            throw withErrno('ENOENT');
+        let readable = null;
+        let writable = null;
+        try {
+            readable = this.readable.statSync(path);
+        }
+        catch {
+            // Not on the readable layer
+        }
+        try {
+            writable = this.writable.statSync(path);
+        }
+        catch {
+            // Not on the writable layer
+        }
+        if (!readable && !writable)
             throw withErrno('ENOENT');
-        const entries = this.readable.existsSync(path) ? this.readable.readdirSync(path) : [];
-        if (this.writable.existsSync(path))
+        const entries = readable && isDirectory(readable) ? this.readable.readdirSync(path) : [];
+        if (writable && isDirectory(writable))
             for (const entry of this.writable.readdirSync(path)) {
                 if (!entries.includes(entry))
                     entries.push(entry);

package/dist/node/promises.js

@@ -55,7 +55,7 @@ import { Exception, rethrow, UV } from 'kerium';
 import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { hasAccess, InodeFlags, isDirectory } from '../internal/inode.js';
-import { dirname, join, matchesGlob } from '../path.js';
+import { dirname, join, matchesGlob, resolve } from '../path.js';
 import '../polyfills.js';
 import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime, validateFD } from '../utils.js';
 import * as _async from '../vfs/async.js';
@@ -1081,8 +1081,16 @@ export async function cp(source, destination, opts) {
             await Promise.all(entries.map(_cp));
             break;
         }
-        case constants.S_IFREG:
         case constants.S_IFLNK:
+            if (opts?.dereference) {
+                await copyFile.call(this, source, destination);
+            }
+            else {
+                const link = await readlink.call(this, source);
+                await symlink.call(this, opts?.verbatimSymlinks ? link : resolve.call(this, dirname(source), link), destination);
+            }
+            break;
+        case constants.S_IFREG:
             await copyFile.call(this, source, destination);
             break;
         case constants.S_IFBLK:

package/dist/node/sync.js

@@ -56,7 +56,7 @@ import { encodeUTF8 } from 'utilium';
 import * as constants from '../constants.js';
 import { wrap } from '../internal/error.js';
 import { hasAccess, isDirectory } from '../internal/inode.js';
-import { dirname, join, matchesGlob } from '../path.js';
+import { dirname, join, matchesGlob, resolve } from '../path.js';
 import { _tempDirName, globToRegex, normalizeMode, normalizeOptions, normalizePath, normalizeTime } from '../utils.js';
 import { checkAccess } from '../vfs/config.js';
 import { deleteFD, fromFD, toFD } from '../vfs/file.js';
@@ -202,7 +202,6 @@ export function writeFileSync(path, data, _options = {}) {
             : _sync.open.call(this, path.toString(), {
                 flag,
                 mode: options.mode,
-                preserveSymlinks: true,
             }), false);
         file.writeSync(encodedData, 0, encodedData.byteLength, 0);
         emitChange(this, 'change', path.toString());
@@ -237,7 +236,6 @@ export function appendFileSync(filename, data, _options = {}) {
         : _sync.open.call(this, normalizePath(filename), {
             flag,
             mode: options.mode,
-            preserveSymlinks: true,
         });
     file.writeSync(encodedData, 0, encodedData.byteLength);
     if (typeof file != 'number')
@@ -567,9 +565,9 @@ export function mkdtempDisposableSync(prefix, options) {
 export function copyFileSync(source, destination, flags) {
     source = normalizePath(source);
     destination = normalizePath(destination);
-    if (flags && flags & constants.COPYFILE_EXCL && existsSync(destination))
+    if (flags && flags & constants.COPYFILE_EXCL && existsSync.call(this, destination))
         throw UV('EEXIST', 'copyFile', destination);
-    writeFileSync.call(this, destination, readFileSync(source));
+    writeFileSync.call(this, destination, readFileSync.call(this, source));
     emitChange(this, 'rename', destination.toString());
 }
 copyFileSync;
@@ -647,8 +645,16 @@ export function cpSync(source, destination, opts) {
                 cpSync.call(this, join(source, dirent.name), join(destination, dirent.name), opts);
             }
             break;
-        case constants.S_IFREG:
         case constants.S_IFLNK:
+            if (opts?.dereference) {
+                copyFileSync.call(this, source, destination);
+            }
+            else {
+                const link = readlinkSync.call(this, source, 'utf8');
+                symlinkSync.call(this, opts?.verbatimSymlinks ? link : resolve.call(this, dirname(source), link), destination);
+            }
+            break;
+        case constants.S_IFREG:
             copyFileSync.call(this, source, destination);
             break;
         case constants.S_IFBLK:

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/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.2",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/tests/common/context.test.ts

@@ -78,4 +78,12 @@ suite('Context', () => {
 
 		assert.equal(ctx.realpathSync('.'), '/test');
 	});
+
+	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/fs/concurrency.test.ts

@@ -87,4 +87,27 @@ suite('Concurrency', config('write', 'async'), () => {
 		await writer.close();
 		assert.equal(await fs.promises.readFile('/issue-303-close.txt', 'utf8'), 'DIRTYnal');
 	});
+
+	test('concurrent recursive mkdir of overlapping trees does not fail #308', async () => {
+		const paths = ['/308/a', '/308/a', '/308/a/b', '/308/a/b', '/308/c', '/308/c', '/308-2', '/308-2'];
+
+		const results = await Promise.allSettled(paths.map(path => fs.promises.mkdir(path, { recursive: true })));
+
+		const rejected = results.filter(r => r.status == 'rejected');
+		assert.deepEqual(
+			rejected.map(r => r.reason.code ?? r.reason.message),
+			[]
+		);
+
+		for (const path of paths) assert((await fs.promises.stat(path)).isDirectory());
+	});
+
+	test('parallel recursive mkdir of the same path creates it once #308', async () => {
+		const results = await Promise.all(Array.from({ length: 8 }, () => fs.promises.mkdir('/308-same/nested', { recursive: true })));
+
+		assert.deepEqual(
+			results.filter(result => result !== undefined),
+			['/308-same']
+		);
+	});
 });

package/tests/fs/directory.test.ts

@@ -45,6 +45,13 @@ suite('Directories', config('directories'), () => {
 		assert.equal((await fs.promises.stat('/recursiveP/A/B/C/D')).mode, fs.constants.S_IFDIR | 0o777);
 	});
 
+	test('mkdir, recursive with a file in the way', config('async'), async () => {
+		await fs.promises.writeFile('/recursiveF', 'Sample content');
+
+		await assert.rejects(fs.promises.mkdir('/recursiveF', { recursive: true }), { code: 'EEXIST', path: '/recursiveF' });
+		await assert.rejects(fs.promises.mkdir('/recursiveF/A/B', { recursive: true }), { code: 'ENOTDIR', path: '/recursiveF/A/B' });
+	});
+
 	test('mkdirSync, recursive', config('sync'), () => {
 		assert.equal(fs.mkdirSync('/recursiveS/A/B', { recursive: true, mode: 0o755 }), '/recursiveS');
 		assert.equal(fs.mkdirSync('/recursiveS/A/B/C/D', { recursive: true, mode: 0o777 }), '/recursiveS/A/B/C');
@@ -57,6 +64,13 @@ suite('Directories', config('directories'), () => {
 		assert.equal(fs.statSync('/recursiveS/A/B/C/D').mode, fs.constants.S_IFDIR | 0o777);
 	});
 
+	test('mkdirSync, recursive with a file in the way', config('sync'), () => {
+		fs.writeFileSync('/recursiveSF', 'Sample content');
+
+		assert.throws(() => fs.mkdirSync('/recursiveSF', { recursive: true }), { code: 'EEXIST', path: '/recursiveSF' });
+		assert.throws(() => fs.mkdirSync('/recursiveSF/A/B', { recursive: true }), { code: 'ENOTDIR', path: '/recursiveSF/A/B' });
+	});
+
 	test('rmdir (non-empty)', config('async'), async () => {
 		await fs.promises.mkdir('/rmdirTest');
 		await fs.promises.mkdir('/rmdirTest/rmdirTest2');
@@ -165,4 +179,11 @@ suite('Directories', config('directories'), () => {
 		fs.writeFileSync('/мой-файл.txt', 'HELLO!', 'utf-8');
 		assert(fs.readdirSync('/').includes('мой-файл.txt'));
 	});
+
+	test('re-creating a deleted path still shows up in readdir #305', config('sync'), () => {
+		fs.unlinkSync('/elipses.txt');
+		fs.writeFileSync('/elipses.txt', '...');
+
+		assert(fs.readdirSync('/').includes('elipses.txt'));
+	});
 });

package/tests/fs/links.test.ts

@@ -83,4 +83,150 @@ suite('Links', config('symlinks'), () => {
 		const linkContent = await fs.promises.readFile(link, 'utf8');
 		assert.equal(targetContent, linkContent);
 	});
+
+	test('mkdir does not follow a symlink at the final component', config('async'), async () => {
+		await fs.promises.mkdir('/mkdir-real');
+		await fs.promises.symlink('/mkdir-real', '/mkdir-link');
+		await fs.promises.writeFile('/mkdir-file', 'contents');
+		await fs.promises.symlink('/mkdir-file', '/mkdir-flink');
+		await fs.promises.symlink('/mkdir-missing', '/mkdir-dangling');
+
+		await assert.rejects(fs.promises.mkdir('/mkdir-link'), { code: 'EEXIST' });
+		await assert.rejects(fs.promises.mkdir('/mkdir-dangling'), { code: 'EEXIST' });
+		await assert.rejects(fs.promises.mkdir('/mkdir-flink', { recursive: true }), { code: 'EEXIST' });
+		await assert.rejects(fs.promises.mkdir('/mkdir-dangling', { recursive: true }), { code: 'ENOENT' });
+
+		// A link pointing at a directory satisfies a recursive mkdir and is left as a link
+		assert.equal(await fs.promises.mkdir('/mkdir-link', { recursive: true }), undefined);
+		assert((await fs.promises.lstat('/mkdir-link')).isSymbolicLink());
+		assert(!(await fs.promises.exists('/mkdir-missing')));
+	});
+
+	test('mkdir follows symlinks for intermediate components', config('async'), async () => {
+		assert.equal(await fs.promises.mkdir('/mkdir-link/direct'), undefined);
+		assert.equal(await fs.promises.mkdir('/mkdir-link/nested/deep', { recursive: true }), '/mkdir-link/nested');
+
+		assert.deepEqual((await fs.promises.readdir('/mkdir-real')).sort(), ['direct', 'nested']);
+		assert((await fs.promises.stat('/mkdir-real/nested/deep')).isDirectory());
+
+		await assert.rejects(fs.promises.mkdir('/mkdir-flink/x', { recursive: true }), { code: 'ENOTDIR' });
+
+		// Node reports the link itself here, unlike `mkdirSync` which reports the requested path with ENOENT
+		await assert.rejects(fs.promises.mkdir('/mkdir-dangling/x', { recursive: true }), { code: 'ENOTDIR', path: '/mkdir-dangling' });
+		assert(!(await fs.promises.exists('/mkdir-missing')));
+	});
+
+	test('mkdirSync does not follow a symlink at the final component', config('sync'), () => {
+		fs.mkdirSync('/mkdirS-real');
+		fs.symlinkSync('/mkdirS-real', '/mkdirS-link');
+		fs.writeFileSync('/mkdirS-file', 'contents');
+		fs.symlinkSync('/mkdirS-file', '/mkdirS-flink');
+		fs.symlinkSync('/mkdirS-missing', '/mkdirS-dangling');
+
+		assert.throws(() => fs.mkdirSync('/mkdirS-link'), { code: 'EEXIST' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-dangling'), { code: 'EEXIST' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-flink', { recursive: true }), { code: 'EEXIST' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-dangling', { recursive: true }), { code: 'ENOENT' });
+
+		assert.equal(fs.mkdirSync('/mkdirS-link', { recursive: true }), undefined);
+		assert(fs.lstatSync('/mkdirS-link').isSymbolicLink());
+		assert(!fs.existsSync('/mkdirS-missing'));
+	});
+
+	test('mkdirSync follows symlinks for intermediate components', config('sync'), () => {
+		assert.equal(fs.mkdirSync('/mkdirS-link/direct'), undefined);
+		assert.equal(fs.mkdirSync('/mkdirS-link/nested/deep', { recursive: true }), '/mkdirS-link/nested');
+
+		assert.deepEqual(fs.readdirSync('/mkdirS-real').sort(), ['direct', 'nested']);
+		assert(fs.statSync('/mkdirS-real/nested/deep').isDirectory());
+
+		assert.throws(() => fs.mkdirSync('/mkdirS-flink/x', { recursive: true }), { code: 'ENOTDIR' });
+		assert.throws(() => fs.mkdirSync('/mkdirS-dangling/x', { recursive: true }), { code: 'ENOENT', path: '/mkdirS-dangling/x' });
+		assert(!fs.existsSync('/mkdirS-missing'));
+	});
+
+	test('writeFile and appendFile follow symlinks', config('async'), async () => {
+		await fs.promises.mkdir('/wf-real');
+		await fs.promises.symlink('/wf-real', '/wf-link');
+		await fs.promises.writeFile('/wf-real/f.txt', 'original');
+		await fs.promises.symlink('/wf-real/f.txt', '/wf-flink');
+		await fs.promises.symlink('/wf-missing.txt', '/wf-dangling');
+
+		await fs.promises.writeFile('/wf-link/new.txt', 'hi');
+		assert.equal(await fs.promises.readFile('/wf-real/new.txt', 'utf8'), 'hi');
+
+		// A link to a file is written through, not replaced
+		await fs.promises.writeFile('/wf-flink', 'replaced');
+		await fs.promises.appendFile('/wf-flink', '+');
+		assert.equal(await fs.promises.readFile('/wf-real/f.txt', 'utf8'), 'replaced+');
+		assert((await fs.promises.lstat('/wf-flink')).isSymbolicLink());
+
+		// Writing through a dangling link creates its target
+		await fs.promises.writeFile('/wf-dangling', 'made');
+		assert.equal(await fs.promises.readFile('/wf-missing.txt', 'utf8'), 'made');
+		assert((await fs.promises.lstat('/wf-dangling')).isSymbolicLink());
+	});
+
+	test('writeFileSync and appendFileSync follow symlinks', config('sync'), () => {
+		fs.mkdirSync('/wfS-real');
+		fs.symlinkSync('/wfS-real', '/wfS-link');
+		fs.writeFileSync('/wfS-real/f.txt', 'original');
+		fs.symlinkSync('/wfS-real/f.txt', '/wfS-flink');
+		fs.symlinkSync('/wfS-missing.txt', '/wfS-dangling');
+
+		fs.writeFileSync('/wfS-link/new.txt', 'hi');
+		assert.equal(fs.readFileSync('/wfS-real/new.txt', 'utf8'), 'hi');
+
+		fs.writeFileSync('/wfS-flink', 'replaced');
+		fs.appendFileSync('/wfS-flink', '+');
+		assert.equal(fs.readFileSync('/wfS-real/f.txt', 'utf8'), 'replaced+');
+		assert(fs.lstatSync('/wfS-flink').isSymbolicLink());
+
+		fs.writeFileSync('/wfS-dangling', 'made');
+		assert.equal(fs.readFileSync('/wfS-missing.txt', 'utf8'), 'made');
+		assert(fs.lstatSync('/wfS-dangling').isSymbolicLink());
+	});
+
+	test('cp preserves a symlink by default #304', async () => {
+		await fs.promises.mkdir('/cp-src');
+		await fs.promises.writeFile('/cp-src/real.txt', 'contents');
+		await fs.promises.symlink('real.txt', '/cp-src/link.txt');
+
+		await fs.promises.cp('/cp-src', '/cp-dst', { recursive: true });
+
+		const stats = await fs.promises.lstat('/cp-dst/link.txt');
+		assert(stats.isSymbolicLink());
+
+		// A relative target is resolved against the link's directory, so the copy points at the original file
+		assert.equal(await fs.promises.readlink('/cp-dst/link.txt'), '/cp-src/real.txt');
+	});
+
+	test('cp with verbatimSymlinks keeps the target unresolved', async () => {
+		await fs.promises.cp('/cp-src', '/cp-verbatim', { recursive: true, verbatimSymlinks: true });
+
+		assert((await fs.promises.lstat('/cp-verbatim/link.txt')).isSymbolicLink());
+		assert.equal(await fs.promises.readlink('/cp-verbatim/link.txt'), 'real.txt');
+	});
+
+	test('cp with dereference copies the symlink target contents #304', async () => {
+		await fs.promises.cp('/cp-src', '/cp-deref', { recursive: true, dereference: true });
+
+		const stats = await fs.promises.lstat('/cp-deref/link.txt');
+		assert(!stats.isSymbolicLink());
+		assert.equal(await fs.promises.readFile('/cp-deref/link.txt', 'utf8'), 'contents');
+	});
+
+	test('cpSync preserves a symlink #304', () => {
+		fs.writeFileSync('/cp-sync-target.txt', 'contents');
+		fs.symlinkSync('cp-sync-target.txt', '/cp-sync-link');
+
+		fs.cpSync('/cp-sync-link', '/cp-sync-link-copy');
+
+		const stats = fs.lstatSync('/cp-sync-link-copy');
+		assert(stats.isSymbolicLink());
+		assert.equal(fs.readlinkSync('/cp-sync-link-copy'), '/cp-sync-target.txt');
+
+		fs.cpSync('/cp-sync-link', '/cp-sync-link-verbatim', { verbatimSymlinks: true });
+		assert.equal(fs.readlinkSync('/cp-sync-link-verbatim'), 'cp-sync-target.txt');
+	});
 });

package/tests/native/setup.ts

@@ -47,6 +47,7 @@ function toNative(path: PathLike): string {
 
 /** Translate a native path back into a test path */
 function fromNative(path: string): string {
+	if (!isAbsolute(path)) return path;
 	return resolve('/', relative(root, path));
 }