@zenfs/core 2.6.0 → 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;
 }
 /**
@@ -127,11 +128,15 @@ export declare class CopyOnWriteFS extends FileSystem {
      * Helper function:
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
      * - Calls f to perform operation on writable.
+     *
+     * `keep` is the size the file is about to be truncated to, when the caller knows it.
+     * Bytes past it are discarded by the operation that follows, so they are not worth copying up.
      */
     private copyForWriteSync;
     private copyForWrite;
     /**
      * Copy from readable to writable storage.
+     * Only `[0, keep)` is copied; the caller is responsible for setting the final size.
      * PRECONDITION: File does not exist on writable storage.
      */
     private copyToWritableSync;

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) {
@@ -202,28 +211,34 @@ export class CopyOnWriteFS extends FileSystem {
         }
     }
     async touch(path, metadata) {
-        await this.copyForWrite(path);
+        await this.copyForWrite(path, metadata.size);
         await this.writable.touch(path, metadata);
     }
     touchSync(path, metadata) {
-        this.copyForWriteSync(path);
+        this.copyForWriteSync(path, metadata.size);
         this.writable.touchSync(path, metadata);
     }
     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);
@@ -360,32 +399,36 @@ export class CopyOnWriteFS extends FileSystem {
      * Helper function:
      * - Ensures p is on writable before proceeding. Throws an error if it doesn't exist.
      * - Calls f to perform operation on writable.
+     *
+     * `keep` is the size the file is about to be truncated to, when the caller knows it.
+     * Bytes past it are discarded by the operation that follows, so they are not worth copying up.
      */
-    copyForWriteSync(path) {
+    copyForWriteSync(path, keep) {
         if (!this.existsSync(path))
             throw withErrno('ENOENT');
         if (!this.writable.existsSync(dirname(path))) {
             this.createParentDirectoriesSync(path);
         }
         if (!this.writable.existsSync(path)) {
-            this.copyToWritableSync(path);
+            this.copyToWritableSync(path, keep);
         }
     }
-    async copyForWrite(path) {
+    async copyForWrite(path, keep) {
         if (!(await this.exists(path)))
             throw withErrno('ENOENT');
         if (!(await this.writable.exists(dirname(path)))) {
             await this.createParentDirectories(path);
         }
         if (!(await this.writable.exists(path))) {
-            return this.copyToWritable(path);
+            return this.copyToWritable(path, keep);
         }
     }
     /**
      * Copy from readable to writable storage.
+     * Only `[0, keep)` is copied; the caller is responsible for setting the final size.
      * PRECONDITION: File does not exist on writable storage.
      */
-    copyToWritableSync(path) {
+    copyToWritableSync(path, keep) {
         const stats = this.readable.statSync(path);
         if (isDirectory(stats)) {
             this.writable.mkdirSync(path, stats);
@@ -394,13 +437,16 @@ export class CopyOnWriteFS extends FileSystem {
             }
             return;
         }
-        const data = new Uint8Array(stats.size);
-        this.readable.readSync(path, data, 0, data.byteLength);
+        const size = Math.min(stats.size, keep ?? stats.size);
+        const data = new Uint8Array(size);
+        if (size)
+            this.readable.readSync(path, data, 0, size);
         this.writable.createFileSync(path, stats);
         this.writable.touchSync(path, stats);
-        this.writable.writeSync(path, data, 0);
+        if (size)
+            this.writable.writeSync(path, data, 0);
     }
-    async copyToWritable(path) {
+    async copyToWritable(path, keep) {
         const stats = await this.readable.stat(path);
         if (isDirectory(stats)) {
             await this.writable.mkdir(path, stats);
@@ -409,11 +455,14 @@ export class CopyOnWriteFS extends FileSystem {
             }
             return;
         }
-        const data = new Uint8Array(stats.size);
-        await this.readable.read(path, data, 0, stats.size);
+        const size = Math.min(stats.size, keep ?? stats.size);
+        const data = new Uint8Array(size);
+        if (size)
+            await this.readable.read(path, data, 0, size);
         await this.writable.createFile(path, stats);
         await this.writable.touch(path, stats);
-        await this.writable.write(path, data, 0);
+        if (size)
+            await this.writable.write(path, data, 0);
     }
 }
 const _CopyOnWrite = {

package/dist/backends/fetch.d.ts

@@ -39,6 +39,10 @@ export declare class FetchFS extends IndexFS {
      * @internal @hidden
      */
     _asyncDone: Promise<unknown>;
+    /**
+     * Queue an async operation started from a sync method.
+     * Failures aren't rethrown to prevent further async ops from failing
+     */
     protected _async(p: Promise<unknown>): void;
     constructor(index: Index, baseUrl: string, requestInit?: RequestInit, remoteWrite?: boolean | undefined);
     protected remove(path: string): Promise<void>;

package/dist/backends/fetch.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 import { withErrno } from 'kerium';
-import { err, warn } from 'kerium/log';
+import { debug, err, warn } from 'kerium/log';
 import { decodeUTF8 } from 'utilium';
 import * as requests from 'utilium/requests';
 import { Index } from '../internal/file_index.js';
@@ -35,8 +35,12 @@ export class FetchFS extends IndexFS {
      * @internal @hidden
      */
     _asyncDone = Promise.resolve();
+    /**
+     * Queue an async operation started from a sync method.
+     * Failures aren't rethrown to prevent further async ops from failing
+     */
     _async(p) {
-        this._asyncDone = this._asyncDone.then(() => p);
+        this._asyncDone = this._asyncDone.then(() => p).catch(e => debug('Async operation failed: ' + (e.message ?? e)));
     }
     constructor(index, baseUrl, requestInit = {}, remoteWrite) {
         super(0x206e6673, 'nfs', index);
@@ -74,7 +78,7 @@ export class FetchFS extends IndexFS {
         if (!data)
             throw withErrno('ENODATA');
         if (missing.length) {
-            this._async(requests.get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }));
+            this._async(requests.get(this.baseUrl + path, { start: offset, end, size: inode.size, warn }, this.requestInit));
             throw withErrno('EAGAIN');
         }
         buffer.set(data);

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/file.js

@@ -178,7 +178,7 @@ let Handle = (() => {
                     throw UV('EBADF', 'sync', this.path);
                 if (!this.dirty)
                     return;
-                const _ = __addDisposableResource(env_1, this.vnode.lockSync('ro'), false);
+                const _ = __addDisposableResource(env_1, this.vnode.lockSync('rw'), false);
                 this.vnode.syncSync();
             }
             catch (e_1) {
@@ -199,7 +199,7 @@ let Handle = (() => {
             if (this.closed)
                 throw UV('EBADF', 'close', this.path);
             this.syncSync();
-            this.disposeSync();
+            this.disposeSync(true);
         }
         /**
          * Cleans up. This will *not* sync the file data to the FS
@@ -385,7 +385,7 @@ let Handle = (() => {
                     throw UV('EBADF', 'sync', this.path);
                 if (!this.dirty)
                     return;
-                const _ = __addDisposableResource(env_8, await this.vnode.lock('ro'), false);
+                const _ = __addDisposableResource(env_8, await this.vnode.lock('rw'), false);
                 await this.vnode.sync();
             }
             catch (e_8) {
@@ -406,7 +406,7 @@ let Handle = (() => {
             if (this.closed)
                 throw UV('EBADF', 'close', this.path);
             await this.sync();
-            this.dispose();
+            this.dispose(true);
         }
         /**
          * Cleans up. This will *not* sync the file data to the FS
@@ -653,7 +653,7 @@ let Handle = (() => {
                 async close() {
                     const env_17 = { stack: [], error: void 0, hasError: false };
                     try {
-                        const _ = __addDisposableResource(env_17, await vnode.lock('ro'), false);
+                        const _ = __addDisposableResource(env_17, await vnode.lock('rw'), false);
                         await vnode.sync();
                     }
                     catch (e_17) {

package/dist/vfs/shared.js

@@ -52,17 +52,18 @@ export function umount(mountPoint) {
     }
     const _done = () => {
         caches.delete(fs.uuid);
-        mounts.delete(mountPoint);
-        notice('Unmounted ' + mountPoint);
+        info('Synced all changes to ' + mountPoint);
     };
     try {
         caches.get(fs.uuid)?.syncSync();
         _done();
     }
     catch {
-        warn(`Could not flush to ${mountPoint} synchronously. Unmount is being deferred.`);
+        warn(`Could not flush to ${mountPoint} synchronously.`);
         void caches.get(fs.uuid)?.sync().then(_done);
     }
+    mounts.delete(mountPoint);
+    notice('Unmounted ' + mountPoint);
 }
 /**
  * Gets the internal `FileSystem` for the path, then returns it along with the path relative to the FS' root

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/dist/vfs/vcache.js

@@ -139,7 +139,7 @@ export class VCache {
             try {
                 if (!node.dirty)
                     continue;
-                const _ = __addDisposableResource(env_1, await node.lock('ro'), false);
+                const _ = __addDisposableResource(env_1, await node.lock('rw'), false);
                 await node.sync();
                 if (!node.refs)
                     this.evict(node);
@@ -160,7 +160,7 @@ export class VCache {
             try {
                 if (!node.dirty)
                     continue;
-                const _ = __addDisposableResource(env_2, node.lockSync('ro'), false);
+                const _ = __addDisposableResource(env_2, node.lockSync('rw'), false);
                 node.syncSync();
                 if (!node.refs)
                     this.evict(node);

package/dist/vfs/vnode.d.ts

@@ -19,6 +19,8 @@ export declare class VNode extends RwLockable {
     readonly data: Resource<number>;
     /** Ranges of `data` that have been written but not yet synced to the backend */
     protected dirtyRanges: Range[];
+    /** The smallest size this vnode has been truncated to since the last sync, if it has been truncated */
+    protected truncatedTo?: number;
     /** Whether `inode` has changes that have not been synced to the backend */
     metadataDirty: boolean;
     /** The number of active references: open handles and in-progress VFS operations */
@@ -60,6 +62,10 @@ export declare class VNode extends RwLockable {
      * Note an extending truncate creates a hole, which reads as zeroes.
      */
     truncate(length: number): void;
+    /**
+     * Whether the backend has to be told about a truncation before the dirty data is written.
+     */
+    protected get needsPreTruncate(): boolean;
     /** Write all unsynced data to the backend, then metadata */
     sync(): Promise<void>;
     syncSync(): void;

package/dist/vfs/vnode.js

@@ -19,6 +19,8 @@ export class VNode extends RwLockable {
     data;
     /** Ranges of `data` that have been written but not yet synced to the backend */
     dirtyRanges = [];
+    /** The smallest size this vnode has been truncated to since the last sync, if it has been truncated */
+    truncatedTo;
     /** Whether `inode` has changes that have not been synced to the backend */
     metadataDirty = false;
     /** The number of active references: open handles and in-progress VFS operations */
@@ -151,6 +153,7 @@ export class VNode extends RwLockable {
      * Note an extending truncate creates a hole, which reads as zeroes.
      */
     truncate(length) {
+        this.truncatedTo = Math.min(this.truncatedTo ?? length, length);
         this.data.size = length;
         this.dirtyRanges = this.dirtyRanges
             .filter(range => range.start < length)
@@ -160,8 +163,17 @@ export class VNode extends RwLockable {
         this.inode.ctimeMs = Date.now();
         this.metadataDirty = true;
     }
+    /**
+     * Whether the backend has to be told about a truncation before the dirty data is written.
+     */
+    get needsPreTruncate() {
+        return !this.bypassCache && this.truncatedTo !== undefined && this.truncatedTo < this.inode.size && !this.fs.attributes.has('no_write');
+    }
     /** Write all unsynced data to the backend, then metadata */
     async sync() {
+        if (this.needsPreTruncate)
+            await this.fs.touch(this.path, { size: this.truncatedTo });
+        this.truncatedTo = undefined;
         for (const range of this.dirtyRanges) {
             for (let pos = range.start; pos < range.end;) {
                 const region = this.data.regionAt(pos);
@@ -180,6 +192,9 @@ export class VNode extends RwLockable {
         this.metadataDirty = false;
     }
     syncSync() {
+        if (this.needsPreTruncate)
+            this.fs.touchSync(this.path, { size: this.truncatedTo });
+        this.truncatedTo = undefined;
         for (const range of this.dirtyRanges) {
             for (let pos = range.start; pos < range.end;) {
                 const region = this.data.regionAt(pos);

package/package.json

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

package/scripts/make-index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { readdirSync, statSync, writeFileSync } from 'node:fs';
-import { matchesGlob, relative, join, resolve } from 'node:path/posix';
+import { lstatSync, readdirSync, writeFileSync, constants as c } from 'node:fs';
+import { join, matchesGlob, relative, resolve } from 'node:path/posix';
 import { parseArgs, styleText } from 'node:util';
 
 const { values: options, positionals } = parseArgs({
@@ -47,6 +47,34 @@ const resolvedRoot = root || '.';
 
 const entries = new Map();
 
+/** @type {Record<string, import('node:util').InspectColor>} */
+const typeMap = {
+	file: 'green',
+	' dir': 'blue',
+	' sym': 'cyan',
+	' dev': 'yellow',
+	sock: 'magenta',
+	fifo: 'blue',
+};
+
+function getTypeText(/** @type {{ mode: number }} */ stats) {
+	switch (stats.mode & c.S_IFMT) {
+		case c.S_IFBLK:
+		case c.S_IFCHR:
+			return ' dev';
+		case c.S_IFIFO:
+			return 'fifo';
+		case c.S_IFSOCK:
+			return 'sock';
+		case c.S_IFREG:
+			return 'file';
+		case c.S_IFDIR:
+			return ' dir';
+		default:
+			throw `Unknown file type: 0o${(stats.mode & c.S_IFMT).toString(8)}`;
+	}
+}
+
 /**
  * @param {string} path
  */
@@ -57,22 +85,15 @@ function computeEntries(path) {
 			return;
 		}
 
-		const stats = statSync(path);
+		const stats = lstatSync(path);
 
-		if (stats.isFile()) {
-			entries.set('/' + relative(resolvedRoot, path), stats);
-			if (options.verbose) {
-				console.log(`${styleText('green', 'file')} ${path}`);
-			}
-			return;
-		}
+		const type = getTypeText(stats);
 
-		for (const file of readdirSync(path)) {
-			computeEntries(join(path, file));
-		}
 		entries.set('/' + relative(resolvedRoot, path), stats);
-		if (options.verbose) {
-			console.log(`${styleText('greenBright', ' dir')} ${path}`);
+		if (options.verbose) console.log(`${styleText(typeMap[type] || 'white', type)} ${path}`);
+
+		if (stats.isDirectory()) {
+			for (const file of readdirSync(path)) computeEntries(join(path, file));
 		}
 	} catch (/** @type {any} */ e) {
 		if (!options.quiet) {

package/tests/backend/fetch.test.ts

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
-import { Fetch, configureSingle, fs, mounts, type FetchFS } from '@zenfs/core';
+import { CopyOnWrite, Fetch, InMemory, configureSingle, fs, mounts, resolveMountConfig, type FetchFS } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { join } from 'node:path';
 import { after, suite, test } from 'node:test';
@@ -47,6 +47,29 @@ suite('Fetch with `disableAsyncCache`', () => {
 	});
 });
 
+suite('CopyOnWrite over uncached Fetch #301', () => {
+	test('Overwriting a base-layer file does not need a synchronous copy-up read', async () => {
+		const readable = await resolveMountConfig({ backend: Fetch, disableAsyncCache: true, baseUrl, index: baseUrl + indexPath });
+
+		fs.mount('/cow', await resolveMountConfig({ backend: CopyOnWrite, readable, writable: InMemory.create({}) }));
+
+		// `w+` truncates first, so none of the base file survives and nothing has to be read from it
+		fs.writeFileSync('/cow/49chars.txt', 'replaced');
+
+		assert.equal(fs.readFileSync('/cow/49chars.txt', 'utf8'), 'replaced');
+		assert.equal(fs.statSync('/cow/49chars.txt').size, 8);
+	});
+
+	test('Partially overwriting an uncached base-layer file still throws', () => {
+		const fd = fs.openSync('/cow/a.js', 'r+');
+		fs.writeSync(fd, 'x', 0);
+
+		// The bytes the write leaves alone have to be copied up, which `Fetch` can not do synchronously.
+		// Writes go through the vnode cache, so this surfaces when the handle is flushed rather than at `write`.
+		assert.throws(() => fs.fsyncSync(fd), { code: 'EAGAIN' });
+	});
+});
+
 after(async () => {
 	await (mounts.get('/') as FetchFS)._asyncDone;
 	await server.terminate();

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/common.ts

@@ -21,8 +21,6 @@ const setup = await import(setupPath).catch(error => {
 // Satisfies is used to make sure that ZenFS is fully type compatible with Node.js
 export const fs = (setup.fs || defaultFS) as typeof defaultFS satisfies NodeFS;
 
-export const Stats = (setup.Stats || defaultFS.Stats) as typeof defaultFS.Stats;
-
 /**
  * A feature or function a backend may not support.
  * Tests that need one are skipped when the backend under test does not have it.

package/tests/fs/concurrency.test.ts

@@ -49,4 +49,65 @@ suite('Concurrency', config('write', 'async'), () => {
 		await a.close();
 		await b.close();
 	});
+
+	test('reads concurrent with an overwrite of the same file do not fail #303', async () => {
+		await fs.promises.writeFile('/issue-303.txt', 'original contents');
+
+		/* Every handle for a file shares one vnode, so closing any of these flushes whatever is dirty.
+		Syncing took a shared lock, letting several of these run at once and corrupt each other. */
+		for (let round = 0; round < 20; round++) {
+			const contents = `rewritten contents for round ${round}`;
+
+			const results = await Promise.allSettled([
+				...Array.from({ length: 4 }, () => fs.promises.readFile('/issue-303.txt', 'utf8')),
+				fs.promises.writeFile('/issue-303.txt', contents),
+				...Array.from({ length: 4 }, () => fs.promises.readFile('/issue-303.txt', 'utf8')),
+			]);
+
+			const rejected = results.filter(r => r.status === 'rejected');
+			assert.deepEqual(
+				rejected.map(r => r.reason.code ?? r.reason.message),
+				[]
+			);
+
+			assert.equal(await fs.promises.readFile('/issue-303.txt', 'utf8'), contents);
+		}
+	});
+
+	test('closing a handle does not fail because another handle has unsynced writes #303', async () => {
+		await fs.promises.writeFile('/issue-303-close.txt', 'original');
+
+		const reader = await fs.promises.open('/issue-303-close.txt', 'r');
+		const writer = await fs.promises.open('/issue-303-close.txt', 'r+');
+
+		// The reader wrote nothing, so its close must not report the writer's dirty data as EBUSY
+		const [closed] = await Promise.allSettled([reader.close(), writer.write(new TextEncoder().encode('DIRTY'), 0, 5, 0)]);
+		assert.equal(closed.status, 'fulfilled');
+
+		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));
 }