@solaqua/gji 0.12.0 → 0.12.2

package/dist/dir-clone.d.ts

@@ -8,12 +8,11 @@ export interface CloneRequestOptions {
 }
 export interface CloneDirOptions extends CloneRequestOptions {
     platform?: NodeJS.Platform;
-    runCommand?: (command: string, args: string[]) => Promise<void>;
+    runLinuxCommand?: (command: string, args: string[]) => Promise<void>;
     copyDirectory?: (source: string, destination: string) => Promise<void>;
     copyFile?: (source: string, destination: string) => Promise<void>;
 }
 export type CloneDirectory = (source: string, destination: string, options?: CloneRequestOptions) => Promise<CloneDirResult>;
-export declare function waitForCloneLock(destination: string, timeoutMs?: number): Promise<boolean>;
 export declare function cloneDir(source: string, destination: string, options?: CloneDirOptions): Promise<CloneDirResult>;
 export declare class CloneDestinationExistsError extends Error {
     readonly code = "GJI_CLONE_DESTINATION_EXISTS";

package/dist/dir-clone.js

@@ -2,54 +2,18 @@ import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { chmod, cp, lstat, mkdir, mkdtemp, opendir, readdir, readFile, readlink, realpath, rename, rm, rmdir, symlink, unlink, utimes, writeFile, } from "node:fs/promises";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
 import { promisify } from "node:util";
 import { isAlreadyExistsError, isNotFoundError } from "./fs-utils.js";
 import { inspectDestination, openDestinationDirectory, } from "./safe-destination.js";
 const execFileAsync = promisify(execFile);
-const CLONE_LOCK_TTL_MS = 24 * 60 * 60 * 1000;
+const CLONE_LOCK_TTL_MS = 5 * 60 * 1000;
+const CLONE_GUARD_TTL_MS = 30 * 1000;
 const CLONE_LOCK_SUFFIX = ".gji-clone-lock";
 const SIZE_ESTIMATE_MAX_ENTRIES = 1_000_000;
 const SIZE_ESTIMATE_MAX_MS = 5_000;
-export async function waitForCloneLock(destination, timeoutMs = 5_000) {
-    const lockPath = `${destination}${CLONE_LOCK_SUFFIX}`;
-    const deadline = Date.now() + timeoutMs;
-    while (await cloneLockExists(lockPath)) {
-        if (await cloneLockIsStale(lockPath))
-            return true;
-        if (Date.now() >= deadline)
-            return false;
-        await new Promise((resolve) => setTimeout(resolve, 25));
-    }
-    return true;
-}
-async function cloneLockIsStale(lockPath) {
-    try {
-        const freshnessPath = await lockFreshnessPath(lockPath);
-        const stats = await lstat(freshnessPath);
-        return Date.now() - stats.mtimeMs >= CLONE_LOCK_TTL_MS;
-    }
-    catch (error) {
-        if (isNotFoundError(error))
-            return false;
-        return false;
-    }
-}
-async function cloneLockExists(lockPath) {
-    try {
-        return await destinationExists(lockPath);
-    }
-    catch (error) {
-        if ("code" in error &&
-            error.code === "ENOTDIR") {
-            return false;
-        }
-        throw error;
-    }
-}
 export async function cloneDir(source, destination, options = {}) {
     const platform = options.platform ?? process.platform;
-    const strategy = cloneStrategy(platform);
     if (!isClonePlatformSupported(platform)) {
         throw new CloneUnsupportedError(`platform ${platform} has no CoW strategy`);
     }
@@ -58,8 +22,12 @@ export async function cloneDir(source, destination, options = {}) {
     if (!sourceStats.isDirectory()) {
         throw new Error("source is not a directory");
     }
-    if (await destinationExists(destination)) {
-        throw new CloneDestinationExistsError(destination);
+    const destinationPath = await resolveProspectivePath(destination);
+    const destinationDistance = relative(sourcePath, destinationPath);
+    if (destinationDistance === "" ||
+        (destinationDistance !== ".." &&
+            !destinationDistance.startsWith(`..${sep}`))) {
+        throw new Error("clone destination must not be inside its source");
     }
     const startedAt = Date.now();
     const parent = dirname(destination);
@@ -77,78 +45,87 @@ export async function cloneDir(source, destination, options = {}) {
         }
         const operationParent = safeParent?.path ?? parent;
         const operationDestination = join(operationParent, basename(destination));
-        if (await destinationExists(operationDestination)) {
-            throw new CloneDestinationExistsError(destination);
-        }
-        const lockPath = `${destination}${CLONE_LOCK_SUFFIX}`;
-        const lockToken = await acquireCloneLock(lockPath, destination);
-        const stopLockHeartbeat = startLockHeartbeat(lockPath, lockToken);
+        const cloneLock = await acquireCloneLock(`${operationDestination}${CLONE_LOCK_SUFFIX}`, destination);
+        const stopLockHeartbeat = startLockHeartbeat(cloneLock);
         let temporaryRoot;
-        let reservationPath;
-        const reservationEntries = [];
+        let reservation;
+        const publishedEntries = [];
         try {
-            reservationPath = await reserveDestination(operationDestination);
+            if (await destinationExists(operationDestination)) {
+                throw new CloneDestinationExistsError(destination);
+            }
+            reservation = await reserveDestination(operationDestination);
             temporaryRoot = await mkdtemp(join(operationParent, `.${basename(destination)}.gji-clone-`));
             const temporaryDestination = join(temporaryRoot, basename(destination));
-            const copyDirectory = options.copyDirectory ??
-                (platformIsDarwin(platform)
-                    ? runNativeCloneDirectory
-                    : async (source, target) => {
-                        if (!strategy) {
-                            throw new CloneUnsupportedError(`platform ${platform} has no CoW strategy`);
-                        }
-                        const runCommand = options.runCommand ?? runCloneCommand;
-                        await runCommand("cp", strategy(source, target));
-                    });
             try {
-                await copyDirectory(sourcePath, temporaryDestination);
+                await (options.copyDirectory ??
+                    ((sourcePath, targetPath) => copyDirectoryWithCow(sourcePath, targetPath, platform, options.runLinuxCommand)))(sourcePath, temporaryDestination);
             }
             catch (error) {
+                if (error instanceof CloneUnsupportedError)
+                    throw error;
                 if (isUnsupportedCloneError(error)) {
                     throw new CloneUnsupportedError(toErrorMessage(error));
                 }
                 throw error;
             }
-            await publishCloneContents(temporaryDestination, operationDestination, reservationPath, (entry) => reservationEntries.push(entry), options.copyFile ?? runForcedCloneFileCopy);
-            reservationPath = undefined;
+            await publishCloneContents(temporaryDestination, operationDestination, reservation.path, (entry) => publishedEntries.push(entry), options.copyFile ?? runForcedCloneFileCopy);
+            reservation = undefined;
         }
         finally {
             stopLockHeartbeat();
-            if (reservationPath) {
-                await cleanupReservedDestination(operationDestination, reservationPath, reservationEntries);
-            }
-            try {
-                if (temporaryRoot) {
-                    await rm(temporaryRoot, { force: true, recursive: true });
-                }
-            }
-            catch {
-                // Cleanup is best effort and must not mask the clone result.
+            if (reservation) {
+                await cleanupReservedDestination(operationDestination, reservation, publishedEntries);
             }
-            try {
-                await releaseCloneLock(lockPath, lockToken);
-            }
-            catch {
-                // A stale lock is reclaimed on a later attempt.
+            if (temporaryRoot) {
+                await rm(temporaryRoot, { force: true, recursive: true }).catch(() => undefined);
             }
+            await releaseCloneLock(cloneLock).catch(() => undefined);
         }
-        const bytes = options.measureBytes === false
-            ? undefined
-            : await estimateCloneBytes(sourcePath);
-        return { bytes, ms: Date.now() - startedAt };
+        return cloneResult(sourcePath, startedAt, options.measureBytes);
     }
     finally {
         await safeParent?.close().catch(() => undefined);
     }
 }
-async function runNativeCloneDirectory(source, destination) {
-    await cp(source, destination, {
-        errorOnExist: true,
-        force: false,
-        mode: constants.COPYFILE_FICLONE_FORCE,
-        preserveTimestamps: true,
-        recursive: true,
-    });
+async function copyDirectoryWithCow(source, destination, platform, runLinuxCommand) {
+    if (platform === "darwin") {
+        await cp(source, destination, {
+            errorOnExist: true,
+            force: false,
+            mode: constants.COPYFILE_FICLONE_FORCE,
+            preserveTimestamps: true,
+            recursive: true,
+        });
+        return;
+    }
+    const strategy = cloneStrategy(platform);
+    if (!strategy) {
+        throw new CloneUnsupportedError(`platform ${platform} has no CoW strategy`);
+    }
+    await (runLinuxCommand ?? runCloneCommand)("cp", strategy(source, destination));
+}
+async function resolveProspectivePath(path) {
+    let current = resolve(path);
+    const missing = [];
+    while (true) {
+        try {
+            return join(await realpath(current), ...missing);
+        }
+        catch (error) {
+            if (!isNotFoundError(error))
+                throw error;
+            const parent = dirname(current);
+            if (parent === current)
+                throw error;
+            missing.unshift(basename(current));
+            current = parent;
+        }
+    }
+}
+async function cloneResult(source, startedAt, measureBytes) {
+    const bytes = measureBytes === false ? undefined : await estimateCloneBytes(source);
+    return { bytes, ms: Date.now() - startedAt };
 }
 export class CloneDestinationExistsError extends Error {
     code = "GJI_CLONE_DESTINATION_EXISTS";
@@ -175,7 +152,7 @@ export function isCloneDestinationExistsError(error) {
     return error instanceof CloneDestinationExistsError;
 }
 export function isCloneUnsupportedError(error) {
-    return (error instanceof CloneUnsupportedError || isUnsupportedCloneError(error));
+    return error instanceof CloneUnsupportedError;
 }
 export function isCloneInProgressError(error) {
     return error instanceof CloneInProgressError;
@@ -247,35 +224,31 @@ async function runCloneCommand(command, args) {
     }
 }
 async function acquireCloneLock(lockPath, destination) {
+    const releaseGuard = await acquireCloneLockGuard(lockPath, destination);
+    try {
+        return await acquireCloneLockWithGuard(lockPath, destination);
+    }
+    finally {
+        await releaseGuard();
+    }
+}
+async function acquireCloneLockWithGuard(lockPath, destination) {
     const lockToken = randomUUID();
     for (let attempt = 0; attempt < 3; attempt += 1) {
+        const published = await publishCloneLock(lockPath, lockToken);
+        if (published)
+            return published;
+        let staleLock;
         try {
-            await mkdir(lockPath);
-            try {
-                await writeFile(join(lockPath, ownerFileName(lockToken)), `${lockToken}\n`, {
-                    flag: "wx",
-                });
-            }
-            catch (error) {
-                await rm(lockPath, { force: true, recursive: true });
-                throw error;
-            }
-            return lockToken;
-        }
-        catch (error) {
-            if (!isAlreadyExistsError(error))
-                throw error;
-        }
-        let lockStats;
-        try {
-            lockStats = await lstat(await lockFreshnessPath(lockPath));
+            staleLock = await inspectCloneLock(lockPath);
         }
         catch (error) {
             if (isNotFoundError(error))
                 continue;
             throw error;
         }
-        if (Date.now() - lockStats.mtimeMs < CLONE_LOCK_TTL_MS) {
+        if (staleLock.kind === "invalid" ||
+            Date.now() - staleLock.mtimeMs < CLONE_LOCK_TTL_MS) {
             throw new CloneInProgressError(destination);
         }
         const stalePath = `${lockPath}.stale-${randomUUID()}`;
@@ -288,27 +261,22 @@ async function acquireCloneLock(lockPath, destination) {
             throw error;
         }
         try {
-            await mkdir(lockPath);
-            try {
-                await writeFile(join(lockPath, ownerFileName(lockToken)), `${lockToken}\n`, {
-                    flag: "wx",
-                });
-            }
-            catch (error) {
-                await rm(lockPath, { force: true, recursive: true });
-                throw error;
+            const replacement = await publishCloneLock(lockPath, lockToken);
+            if (!replacement) {
+                await cleanupStaleCloneLock(stalePath, staleLock);
+                continue;
             }
             try {
-                await rm(stalePath, { force: true, recursive: true });
+                await cleanupStaleCloneLock(stalePath, staleLock);
             }
             catch (cleanupError) {
-                await releaseCloneLock(lockPath, lockToken).catch(() => undefined);
+                await releaseCloneLockWithGuard(replacement).catch(() => undefined);
                 throw cleanupError;
             }
-            return lockToken;
+            return replacement;
         }
         catch (error) {
-            await rm(stalePath, { force: true, recursive: true }).catch(() => undefined);
+            await cleanupStaleCloneLock(stalePath, staleLock).catch(() => undefined);
             if (isAlreadyExistsError(error))
                 continue;
             throw error;
@@ -316,18 +284,172 @@ async function acquireCloneLock(lockPath, destination) {
     }
     throw new CloneInProgressError(destination);
 }
-async function lockFreshnessPath(lockPath) {
+async function acquireCloneLockGuard(lockPath, destination) {
+    const guardPath = `${lockPath}.guard`;
+    const deadline = Date.now() + 5_000;
+    while (true) {
+        try {
+            await mkdir(guardPath, { mode: 0o700 });
+            const markerName = `${process.pid}-${randomUUID()}`;
+            const markerPath = join(guardPath, markerName);
+            try {
+                await writeFile(markerPath, `${markerName}\n`, {
+                    flag: "wx",
+                    mode: 0o600,
+                });
+            }
+            catch (error) {
+                await rmdir(guardPath).catch(() => undefined);
+                throw error;
+            }
+            return async () => {
+                await unlink(markerPath).catch((error) => {
+                    if (!isNotFoundError(error))
+                        throw error;
+                });
+                await rmdir(guardPath).catch((error) => {
+                    if (!isNotFoundError(error))
+                        throw error;
+                });
+            };
+        }
+        catch (error) {
+            if (!isAlreadyExistsError(error))
+                throw error;
+            if (await reclaimAbandonedCloneGuard(guardPath))
+                continue;
+            if (Date.now() >= deadline) {
+                throw new CloneInProgressError(destination);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+    }
+}
+async function reclaimAbandonedCloneGuard(guardPath) {
+    let expectedMarker;
+    try {
+        const entries = await readdir(guardPath);
+        if (entries.length > 1)
+            return false;
+        expectedMarker = entries[0];
+        const freshnessPath = expectedMarker
+            ? join(guardPath, expectedMarker)
+            : guardPath;
+        const stats = await lstat(freshnessPath);
+        if (Date.now() - stats.mtimeMs < CLONE_GUARD_TTL_MS)
+            return false;
+        if (expectedMarker) {
+            const ownerPid = Number(expectedMarker.split("-", 1)[0]);
+            if (!Number.isSafeInteger(ownerPid) || ownerPid <= 0)
+                return false;
+            if (processIsAlive(ownerPid))
+                return false;
+        }
+    }
+    catch (error) {
+        return isNotFoundError(error);
+    }
+    const stalePath = `${guardPath}.stale-${randomUUID()}`;
+    try {
+        await rename(guardPath, stalePath);
+    }
+    catch (error) {
+        if (isNotFoundError(error))
+            return true;
+        throw error;
+    }
+    const movedEntries = await readdir(stalePath).catch(() => []);
+    if (movedEntries.length !== (expectedMarker ? 1 : 0) ||
+        (expectedMarker && movedEntries[0] !== expectedMarker)) {
+        await rename(stalePath, guardPath).catch(() => undefined);
+        return false;
+    }
+    if (expectedMarker)
+        await unlink(join(stalePath, expectedMarker));
+    await rmdir(stalePath);
+    return true;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+async function publishCloneLock(lockPath, lockToken) {
+    try {
+        await mkdir(lockPath, { mode: 0o700 });
+    }
+    catch (error) {
+        if (isAlreadyExistsError(error))
+            return undefined;
+        throw error;
+    }
+    const markerPath = join(lockPath, lockToken);
+    try {
+        await writeFile(markerPath, `${lockToken}\n`, { flag: "wx", mode: 0o600 });
+        return {
+            lockPath,
+            markerName: lockToken,
+            markerPath,
+            token: lockToken,
+        };
+    }
+    catch (error) {
+        await rmdir(lockPath).catch(() => undefined);
+        throw error;
+    }
+}
+async function inspectCloneLock(lockPath) {
     try {
+        const stats = await lstat(lockPath);
+        if (!stats.isDirectory() || stats.isSymbolicLink()) {
+            return { kind: "invalid", mtimeMs: stats.mtimeMs };
+        }
         const entries = await readdir(lockPath);
-        const owner = entries.find((entry) => entry.startsWith("owner-"));
-        return owner ? join(lockPath, owner) : lockPath;
+        if (entries.length === 0)
+            return { kind: "empty", mtimeMs: stats.mtimeMs };
+        if (entries.length !== 1) {
+            return { kind: "invalid", mtimeMs: stats.mtimeMs };
+        }
+        const markerName = entries[0];
+        const token = markerName?.startsWith("owner-")
+            ? markerName.slice("owner-".length)
+            : markerName;
+        if (!token || !/^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu.test(token)) {
+            return { kind: "invalid", mtimeMs: stats.mtimeMs };
+        }
+        const markerPath = join(lockPath, markerName);
+        const markerStats = await lstat(markerPath);
+        if (!markerStats.isFile() || markerStats.isSymbolicLink()) {
+            return { kind: "invalid", mtimeMs: markerStats.mtimeMs };
+        }
+        if ((await readFile(markerPath, "utf8")).trim() !== token) {
+            return { kind: "invalid", mtimeMs: markerStats.mtimeMs };
+        }
+        return {
+            kind: "owned",
+            lockPath,
+            markerName: markerName,
+            markerPath,
+            mtimeMs: markerStats.mtimeMs,
+            token,
+        };
     }
     catch (error) {
         if (isNotFoundError(error))
             throw error;
-        return lockPath;
+        return { kind: "invalid", mtimeMs: Date.now() };
     }
 }
+async function cleanupStaleCloneLock(lockPath, inspection) {
+    if (inspection.kind === "owned") {
+        await unlink(join(lockPath, inspection.markerName));
+    }
+    await rmdir(lockPath);
+}
 async function publishCloneContents(temporaryDestination, destination, reservationPath, onEntryPublished, copyFileEntry) {
     const reservationName = basename(reservationPath);
     const destinationEntries = await readdir(destination);
@@ -337,7 +459,7 @@ async function publishCloneContents(temporaryDestination, destination, reservati
     }
     const temporaryEntries = await readdir(temporaryDestination);
     for (const entry of temporaryEntries) {
-        await publishCloneEntry(join(temporaryDestination, entry), join(destination, entry), () => onEntryPublished(entry), copyFileEntry);
+        await publishCloneEntry(join(temporaryDestination, entry), join(destination, entry), (entry) => onEntryPublished(entry), copyFileEntry);
     }
     await unlink(reservationPath);
 }
@@ -353,7 +475,7 @@ async function publishCloneEntry(source, destination, onCreated, copyFileEntry)
             }
             throw error;
         }
-        onCreated();
+        onCreated(await inspectOwnedCloneEntry(destination, "directory"));
         for (const entry of await readdir(source)) {
             await publishCloneEntry(join(source, entry), join(destination, entry), () => undefined, copyFileEntry);
         }
@@ -370,7 +492,7 @@ async function publishCloneEntry(source, destination, onCreated, copyFileEntry)
             }
             throw error;
         }
-        onCreated();
+        onCreated(await inspectOwnedCloneEntry(destination, "symlink"));
         return;
     }
     if (!sourceStats.isFile()) {
@@ -388,7 +510,7 @@ async function publishCloneEntry(source, destination, onCreated, copyFileEntry)
         }
         throw error;
     }
-    onCreated();
+    onCreated(await inspectOwnedCloneEntry(destination, "file"));
     await copyCloneMetadata(sourceStats, destination);
 }
 async function runForcedCloneFileCopy(source, destination) {
@@ -418,26 +540,35 @@ async function reserveDestination(destination) {
         await writeFile(reservationPath, "gji clone reservation\n", {
             flag: "wx",
         });
-        return reservationPath;
+        return await inspectOwnedCloneEntry(reservationPath, "file");
     }
     catch (error) {
         await rmdir(destination).catch(() => undefined);
         throw error;
     }
 }
-async function cleanupReservedDestination(destination, reservationPath, reservationEntries) {
+async function cleanupReservedDestination(destination, reservation, publishedEntries) {
+    for (const entry of [...publishedEntries, reservation].reverse()) {
+        await removeOwnedCloneEntry(entry);
+    }
+    await rmdir(destination).catch(() => undefined);
+}
+async function inspectOwnedCloneEntry(path, kind) {
+    const stats = await lstat(path, { bigint: true });
+    return { dev: stats.dev, ino: stats.ino, kind, path };
+}
+async function removeOwnedCloneEntry(entry) {
     try {
-        const entries = await readdir(destination);
-        const ownedEntries = new Set([
-            basename(reservationPath),
-            ...reservationEntries,
-        ]);
-        if (entries.every((entry) => ownedEntries.has(entry))) {
-            await rm(destination, { force: true, recursive: true });
-        }
+        const current = await lstat(entry.path, { bigint: true });
+        if (current.dev !== entry.dev || current.ino !== entry.ino)
+            return;
+        if (entry.kind === "directory")
+            await rmdir(entry.path);
+        else
+            await unlink(entry.path);
     }
     catch {
-        // Preserve a destination that was changed by another process.
+        // Missing, replaced, or non-empty entries are no longer exclusively ours.
     }
 }
 async function destinationExists(path) {
@@ -451,37 +582,50 @@ async function destinationExists(path) {
         throw error;
     }
 }
-function startLockHeartbeat(lockPath, lockToken) {
+function startLockHeartbeat(lock) {
     const timer = setInterval(() => {
-        void refreshCloneLock(lockPath, lockToken);
+        void refreshCloneLock(lock);
     }, CLONE_LOCK_TTL_MS / 3);
     timer.unref?.();
     return () => clearInterval(timer);
 }
-async function refreshCloneLock(lockPath, lockToken) {
+async function refreshCloneLock(lock) {
     try {
-        const ownerPath = join(lockPath, ownerFileName(lockToken));
-        await readFile(ownerPath, "utf8");
         const now = new Date();
-        await utimes(ownerPath, now, now);
+        await utimes(lock.markerPath, now, now);
     }
     catch {
-        // Lock refresh is advisory; the owner check prevents touching a replacement lock.
+        // A missing marker means this owner was already fenced out as stale.
+    }
+}
+async function releaseCloneLock(lock) {
+    const releaseGuard = await acquireCloneLockGuard(lock.lockPath, lock.lockPath);
+    try {
+        await releaseCloneLockWithGuard(lock);
+    }
+    finally {
+        await releaseGuard();
     }
 }
-async function releaseCloneLock(lockPath, lockToken) {
+async function releaseCloneLockWithGuard(lock) {
     try {
-        const ownerPath = join(lockPath, ownerFileName(lockToken));
-        await unlink(ownerPath);
-        await rmdir(lockPath);
+        await unlink(join(lock.lockPath, lock.token));
     }
     catch (error) {
-        if (!isNotFoundError(error) && !isDirectoryNotEmptyError(error))
+        if (!isNotFoundError(error))
             throw error;
     }
-}
-function ownerFileName(lockToken) {
-    return `owner-${lockToken}`;
+    try {
+        await rmdir(lock.lockPath);
+    }
+    catch (error) {
+        const code = "code" in error
+            ? error.code
+            : undefined;
+        if (!isNotFoundError(error) && code !== "ENOTEMPTY" && code !== "EEXIST") {
+            throw error;
+        }
+    }
 }
 function isUnsupportedCloneError(error) {
     if (!(error instanceof Error))
@@ -490,16 +634,8 @@ function isUnsupportedCloneError(error) {
     if (["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EXDEV"].includes(code ?? "")) {
         return true;
     }
-    return /clonefile|reflink|unsupported|operation not supported|not supported|invalid cross-device|cross-device/iu.test(error.message);
-}
-function isDirectoryNotEmptyError(error) {
-    return (error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOTEMPTY");
+    return /reflink|unsupported|operation not supported|not supported|invalid cross-device|cross-device/iu.test(error.message);
 }
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function platformIsDarwin(platform) {
-    return platform === "darwin";
-}