@openclaw/fs-safe 0.16.0 → 0.18.0

package/dist/regular-file.js

@@ -5,10 +5,10 @@ import { readFileDescriptorBoundedSync, readFileHandleBounded } from "./bounded-
 import { normalizeMaxBytes } from "./byte-budget.js";
 import { assertNoUnsafeDeviceReadPath } from "./device-path.js";
 import { FsSafeError } from "./errors.js";
-import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { isNotFoundPathError } from "./path.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
-import { assertNoSymlinkParents, assertNoSymlinkParentsSync } from "./symlink-parents.js";
+import { assertNoSymlinkParentsSync } from "./symlink-parents.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
 import { isNonRegularWriteOpenError, isNonRegularWriteOpenErrorSync, resolveNonblockingWriteFlag, } from "./write-open-flags.js";
 import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
@@ -50,18 +50,7 @@ export function statRegularFileSync(filePath) {
     return { missing: false, stat };
 }
 export async function readRegularFile(params) {
-    const maxBytes = normalizeMaxBytes(params.maxBytes);
-    const filePath = params.filePath;
-    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
-    assertNoUnsafeDeviceReadPath(filePath);
-    const before = await inspectFileIdentity(async () => {
-        const stat = fsSync.lstatSync(filePath, { bigint: true });
-        assertRegularReadStat(stat, filePath, true);
-        return stat;
-    }).catch((error) => throwReadPreviewError(error, filePath));
-    if (maxBytes !== undefined && before.size > maxBytes) {
-        throw regularFileTooLargeError(filePath, maxBytes);
-    }
+    const { filePath, maxBytes, before } = prepareRegularRead(params);
     let handle;
     try {
         handle = await fs.open(filePath, resolveReadOpenFlags());
@@ -73,28 +62,7 @@ export async function readRegularFile(params) {
         throw err;
     }
     try {
-        const stat = fsSync.fstatSync(handle.fd);
-        const identity = await inspectFileIdentity(async () => {
-            const exact = fsSync.fstatSync(handle.fd, { bigint: true });
-            assertRegularReadStat(exact, filePath);
-            return exact;
-        }, before);
-        try {
-            await inspectFileIdentity(async () => {
-                const current = fsSync.lstatSync(filePath, { bigint: true });
-                assertRegularReadStat(current, filePath);
-                return current;
-            }, identity);
-        }
-        catch (err) {
-            if (isNotFoundPathError(err)) {
-                throw new FsSafeError("path-mismatch", `File changed during read: ${filePath}`);
-            }
-            throw err;
-        }
-        if (maxBytes !== undefined && stat.size > maxBytes) {
-            throw regularFileTooLargeError(filePath, maxBytes);
-        }
+        const stat = inspectOpenedRegularRead(handle.fd, filePath, before, maxBytes);
         // With a byte cap, avoid readFile(): a raced file growth would allocate
         // the oversized content before the post-read check could reject it.
         let buffer;
@@ -127,47 +95,7 @@ function assertRegularReadStat(stat, filePath, preview = false) {
         throw new Error(preview ? "path must be a regular file" : `File is not a regular file: ${filePath}`);
     }
 }
-function readOpenedRegularFileSync(params) {
-    const stat = fsSync.fstatSync(params.fd);
-    const identity = inspectFileIdentitySync(() => {
-        const exact = fsSync.fstatSync(params.fd, { bigint: true });
-        assertRegularReadStat(exact, params.filePath);
-        return exact;
-    }, params.preOpenStat);
-    try {
-        inspectFileIdentitySync(() => {
-            const current = fsSync.lstatSync(params.filePath, { bigint: true });
-            assertRegularReadStat(current, params.filePath);
-            return current;
-        }, identity);
-    }
-    catch (error) {
-        if (isNotFoundPathError(error)) {
-            throw new FsSafeError("path-mismatch", `File changed during read: ${params.filePath}`);
-        }
-        throw error;
-    }
-    if (params.maxBytes !== undefined && stat.size > params.maxBytes) {
-        throw regularFileTooLargeError(params.filePath, params.maxBytes);
-    }
-    // Keep capped sync reads incremental for the same reason as async reads:
-    // readFileSync(fd) would buffer a raced oversized file before throwing.
-    let buffer;
-    try {
-        buffer =
-            params.maxBytes === undefined
-                ? fsSync.readFileSync(params.fd)
-                : readFileDescriptorBoundedSync(params.fd, params.maxBytes);
-    }
-    catch (error) {
-        if (params.maxBytes !== undefined) {
-            translateBoundedReadOverflow(error, params.filePath, params.maxBytes);
-        }
-        throw error;
-    }
-    return { buffer, stat };
-}
-export function readRegularFileSync(params) {
+function prepareRegularRead(params) {
     const maxBytes = normalizeMaxBytes(params.maxBytes);
     const filePath = params.filePath;
     assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
@@ -186,6 +114,35 @@ export function readRegularFileSync(params) {
     if (maxBytes !== undefined && before.size > maxBytes) {
         throw regularFileTooLargeError(filePath, maxBytes);
     }
+    return { filePath, maxBytes, before };
+}
+function inspectOpenedRegularRead(fd, filePath, preOpenStat, maxBytes) {
+    const stat = fsSync.fstatSync(fd);
+    const identity = inspectFileIdentitySync(() => {
+        const exact = fsSync.fstatSync(fd, { bigint: true });
+        assertRegularReadStat(exact, filePath);
+        return exact;
+    }, preOpenStat);
+    try {
+        inspectFileIdentitySync(() => {
+            const current = fsSync.lstatSync(filePath, { bigint: true });
+            assertRegularReadStat(current, filePath);
+            return current;
+        }, identity);
+    }
+    catch (error) {
+        if (isNotFoundPathError(error)) {
+            throw new FsSafeError("path-mismatch", `File changed during read: ${filePath}`);
+        }
+        throw error;
+    }
+    if (maxBytes !== undefined && stat.size > maxBytes) {
+        throw regularFileTooLargeError(filePath, maxBytes);
+    }
+    return stat;
+}
+export function readRegularFileSync(params) {
+    const { filePath, maxBytes, before } = prepareRegularRead(params);
     let fd;
     try {
         fd = fsSync.openSync(filePath, resolveReadOpenFlags());
@@ -197,12 +154,21 @@ export function readRegularFileSync(params) {
         throw error;
     }
     try {
-        return readOpenedRegularFileSync({
-            fd,
-            filePath,
-            preOpenStat: before,
-            maxBytes,
-        });
+        const stat = inspectOpenedRegularRead(fd, filePath, before, maxBytes);
+        // Keep capped reads incremental so raced growth cannot allocate unbounded content.
+        let buffer;
+        try {
+            buffer = maxBytes === undefined
+                ? fsSync.readFileSync(fd)
+                : readFileDescriptorBoundedSync(fd, maxBytes);
+        }
+        catch (error) {
+            if (maxBytes !== undefined) {
+                translateBoundedReadOverflow(error, filePath, maxBytes);
+            }
+            throw error;
+        }
+        return { buffer, stat };
     }
     finally {
         fsSync.closeSync(fd);
@@ -223,12 +189,27 @@ function throwAppendIdentityError(error, filePath) {
     }
     throw error;
 }
-export async function appendRegularFile(options) {
+function captureAppendOptions(options) {
     const filePath = options.filePath;
     assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
-    if (options.rejectSymlinkParents === true) {
+    return {
+        filePath, content: options.content, encoding: options.encoding ?? "utf8",
+        mode: options.mode ?? 0o600, maxFileBytes: options.maxFileBytes,
+        rejectSymlinkParents: options.rejectSymlinkParents,
+    };
+}
+function inspectAppendPath(filePath) {
+    const stat = fsSync.lstatSync(filePath, { bigint: true });
+    if (stat.isSymbolicLink())
+        throw new Error(`Refusing to append through symlink: ${filePath}`);
+    if (!stat.isFile())
+        throw new Error(`Refusing to append to non-file: ${filePath}`);
+    return stat;
+}
+function prepareRegularAppend(filePath, rejectSymlinkParents) {
+    if (rejectSymlinkParents === true) {
         const resolvedDir = resolvePathPreservingWindowsRoot(path.dirname(filePath));
-        await assertNoSymlinkParents({
+        assertNoSymlinkParentsSync({
             rootDir: path.parse(resolvedDir).root,
             targetPath: resolvedDir,
             allowMissing: false,
@@ -237,35 +218,45 @@ export async function appendRegularFile(options) {
             messagePrefix: "Refusing to append under",
         });
     }
-    let preOpenStat;
     try {
-        preOpenStat = await inspectFileIdentity(async () => {
-            const stat = fsSync.lstatSync(filePath, { bigint: true });
-            if (stat.isSymbolicLink()) {
-                throw new Error(`Refusing to append through symlink: ${filePath}`);
-            }
-            if (!stat.isFile()) {
-                throw new Error(`Refusing to append to non-file: ${filePath}`);
-            }
-            return stat;
-        });
+        return inspectFileIdentitySync(() => inspectAppendPath(filePath));
     }
     catch (error) {
         if (!isNotFoundPathError(error))
             throw error;
     }
-    const contentBytes = Buffer.isBuffer(options.content)
-        ? options.content.byteLength
-        : Buffer.byteLength(options.content, options.encoding ?? "utf8");
-    if (options.maxFileBytes !== undefined &&
-        Number(preOpenStat?.size ?? 0n) + contentBytes > options.maxFileBytes) {
+}
+function inspectOpenedRegularAppend(fd, filePath, preOpenStat) {
+    try {
+        const identity = inspectFileIdentitySync(() => {
+            const stat = fsSync.fstatSync(fd, { bigint: true });
+            assertRegularAppendStat(stat, filePath);
+            return stat;
+        }, preOpenStat);
+        inspectFileIdentitySync(() => {
+            const current = fsSync.lstatSync(filePath, { bigint: true });
+            assertRegularAppendStat(current, filePath);
+            return current;
+        }, identity);
+        return identity;
+    }
+    catch (error) {
+        throwAppendIdentityError(error, filePath);
+    }
+}
+export async function appendRegularFile(options) {
+    const { filePath, content, encoding, mode, maxFileBytes, rejectSymlinkParents } = captureAppendOptions(options);
+    const preOpenStat = prepareRegularAppend(filePath, rejectSymlinkParents);
+    const contentBytes = Buffer.isBuffer(content) ? content.byteLength : Buffer.byteLength(content, encoding);
+    if (maxFileBytes !== undefined &&
+        Number(preOpenStat?.size ?? 0n) + contentBytes > maxFileBytes) {
         return;
     }
     await getFsSafeTestHooks()?.beforeRegularFileAppendOpen?.(filePath);
     const flags = resolveRegularFileAppendFlags();
     let handle;
     try {
-        handle = await fs.open(filePath, flags, options.mode ?? 0o600);
+        handle = await fs.open(filePath, flags, mode);
     }
     catch (error) {
         if (await isNonRegularWriteOpenError(error, filePath, flags)) {
@@ -274,30 +265,14 @@ export async function appendRegularFile(options) {
         throw error;
     }
     try {
-        let identity;
-        try {
-            identity = await inspectFileIdentity(async () => {
-                const stat = fsSync.fstatSync(handle.fd, { bigint: true });
-                assertRegularAppendStat(stat, filePath);
-                return stat;
-            }, preOpenStat);
-            await inspectFileIdentity(async () => {
-                const current = fsSync.lstatSync(filePath, { bigint: true });
-                assertRegularAppendStat(current, filePath);
-                return current;
-            }, identity);
-        }
-        catch (error) {
-            throwAppendIdentityError(error, filePath);
-        }
-        if (options.maxFileBytes !== undefined &&
-            Number(identity.size) + contentBytes > options.maxFileBytes) {
+        const identity = inspectOpenedRegularAppend(handle.fd, filePath, preOpenStat);
+        if (maxFileBytes !== undefined &&
+            Number(identity.size) + contentBytes > maxFileBytes) {
             return;
         }
-        const mode = options.mode ?? 0o600;
         // Tighten before writing; restore explicit special bits only after content is complete.
         await handle.chmod(mode);
-        await handle.appendFile(options.content, options.encoding ?? "utf8");
+        await handle.appendFile(content, encoding);
         if (mode & 0o7000)
             await handle.chmod(mode);
     }
@@ -306,48 +281,18 @@ export async function appendRegularFile(options) {
     }
 }
 export function appendRegularFileSync(options) {
-    const filePath = options.filePath;
-    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
-    if (options.rejectSymlinkParents === true) {
-        const resolvedDir = resolvePathPreservingWindowsRoot(path.dirname(filePath));
-        assertNoSymlinkParentsSync({
-            rootDir: path.parse(resolvedDir).root,
-            targetPath: resolvedDir,
-            allowMissing: false,
-            allowRootChildSymlink: true,
-            requireDirectories: true,
-            messagePrefix: "Refusing to append under",
-        });
-    }
-    let preOpenStat;
-    try {
-        preOpenStat = inspectFileIdentitySync(() => {
-            const stat = fsSync.lstatSync(filePath, { bigint: true });
-            if (stat.isSymbolicLink()) {
-                throw new Error(`Refusing to append through symlink: ${filePath}`);
-            }
-            if (!stat.isFile()) {
-                throw new Error(`Refusing to append to non-file: ${filePath}`);
-            }
-            return stat;
-        });
-    }
-    catch (error) {
-        if (!isNotFoundPathError(error))
-            throw error;
-    }
-    const contentBuffer = typeof options.content === "string"
-        ? Buffer.from(options.content, options.encoding ?? "utf8")
-        : Buffer.from(options.content);
-    if (options.maxFileBytes !== undefined &&
-        Number(preOpenStat?.size ?? 0n) + contentBuffer.byteLength > options.maxFileBytes) {
+    const { filePath, content, encoding, mode, maxFileBytes, rejectSymlinkParents } = captureAppendOptions(options);
+    const preOpenStat = prepareRegularAppend(filePath, rejectSymlinkParents);
+    const contentBuffer = typeof content === "string" ? Buffer.from(content, encoding) : Buffer.from(content);
+    if (maxFileBytes !== undefined &&
+        Number(preOpenStat?.size ?? 0n) + contentBuffer.byteLength > maxFileBytes) {
         return;
     }
     getFsSafeTestHooks()?.beforeRegularFileAppendOpenSync?.(filePath);
     const flags = resolveRegularFileAppendFlags();
     let fd;
     try {
-        fd = fsSync.openSync(filePath, flags, options.mode ?? 0o600);
+        fd = fsSync.openSync(filePath, flags, mode);
     }
     catch (error) {
         if (isNonRegularWriteOpenErrorSync(error, filePath, flags)) {
@@ -356,27 +301,11 @@ export function appendRegularFileSync(options) {
         throw error;
     }
     try {
-        let identity;
-        try {
-            identity = inspectFileIdentitySync(() => {
-                const stat = fsSync.fstatSync(fd, { bigint: true });
-                assertRegularAppendStat(stat, filePath);
-                return stat;
-            }, preOpenStat);
-            inspectFileIdentitySync(() => {
-                const current = fsSync.lstatSync(filePath, { bigint: true });
-                assertRegularAppendStat(current, filePath);
-                return current;
-            }, identity);
-        }
-        catch (error) {
-            throwAppendIdentityError(error, filePath);
-        }
-        if (options.maxFileBytes !== undefined &&
-            Number(identity.size) + contentBuffer.byteLength > options.maxFileBytes) {
+        const identity = inspectOpenedRegularAppend(fd, filePath, preOpenStat);
+        if (maxFileBytes !== undefined &&
+            Number(identity.size) + contentBuffer.byteLength > maxFileBytes) {
             return;
         }
-        const mode = options.mode ?? 0o600;
         fsSync.fchmodSync(fd, mode);
         fsSync.appendFileSync(fd, contentBuffer);
         if (mode & 0o7000)

package/dist/replace-directory.d.ts

@@ -4,4 +4,3 @@ export type ReplaceDirectoryAtomicOptions = {
     backupPrefix?: string;
 };
 export declare function replaceDirectoryAtomic(options: ReplaceDirectoryAtomicOptions): Promise<void>;
-//# sourceMappingURL=replace-directory.d.ts.map

package/dist/replace-file-copy-fallback.d.ts

@@ -36,4 +36,3 @@ export declare function copyFallbackReplaceSync(params: {
     sync: boolean;
 }): void;
 export {};
-//# sourceMappingURL=replace-file-copy-fallback.d.ts.map

package/dist/replace-file-copy-fallback.js

@@ -2,9 +2,10 @@ import syncFs, {} from "node:fs";
 import fs, {} from "node:fs/promises";
 import { readBoundedAsync, readBoundedSync } from "./bounded-read.js";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
+import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
 import { readOwnedCopySource, readOwnedCopySourceSync } from "./replace-file-copy-source.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { hasErrorCode } from "./file-cleanup.js";
 const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in syncFs.constants;
 const NOFOLLOW = SUPPORTS_NOFOLLOW ? syncFs.constants.O_NOFOLLOW : 0;
 const OPEN_READ_FLAGS = resolveReadOpenFlags();
@@ -19,39 +20,37 @@ function closeSyncAfterAdmissionFailure(fsModule, fd, error) {
     }
     throw error;
 }
-function notFound(error) {
-    return error.code === "ENOENT";
-}
-function assertPinnedDestination(pathname, opened, dest, hardlinks, admission) {
+function admitDestinationKind(pathname, opened, dest, admission) {
     if (admission === "hardlinks") {
-        if (pathname.isSymbolicLink() || !pathname.isFile() || !sameFileIdentity(pathname, opened)) {
+        if (pathname.isSymbolicLink() || !pathname.isFile()) {
             throw new FsSafeError("path-mismatch", `Atomic replace destination changed while opening: ${dest}`);
         }
-        if (opened.nlink > 1) {
-            throw new FsSafeError("hardlink", `Hardlinked atomic replace destination not allowed: ${dest}`);
-        }
-        return;
     }
-    if (pathname.isSymbolicLink()) {
+    else if (pathname.isSymbolicLink()) {
         throw new FsSafeError("symlink", `Refusing copy fallback through symlink destination: ${dest}`);
     }
-    if (!pathname.isFile() || !opened.isFile()) {
+    else if (!pathname.isFile() || !opened.isFile()) {
         throw new FsSafeError("not-file", `Copy fallback destination must be a regular file: ${dest}`);
     }
-    if (!sameFileIdentity(pathname, opened)) {
-        throw new FsSafeError("path-mismatch", `Copy fallback destination changed while opening: ${dest}`);
-    }
-    if (hardlinks === "reject" && opened.nlink > 1) {
-        throw new FsSafeError("hardlink", `Hardlinked copy fallback destination not allowed: ${dest}`);
+    return pathname;
+}
+function assertDestinationLinks(opened, dest, admission, hardlinks) {
+    if ((admission === "hardlinks" || hardlinks === "reject") && opened.nlink > 1n) {
+        throw new FsSafeError("hardlink", `Hardlinked ${admission === "hardlinks" ? "atomic replace" : "copy fallback"} destination not allowed: ${dest}`);
     }
 }
+function inspectPinnedDestinationSync(fsModule, fd, dest, admission, hardlinks) {
+    const opened = inspectFileIdentitySync(() => fsModule.fstatSync(fd, { bigint: true }));
+    inspectFileIdentitySync(() => admitDestinationKind(fsModule.lstatSync(dest, { bigint: true }), opened, dest, admission), opened);
+    assertDestinationLinks(opened, dest, admission, hardlinks);
+}
 async function openPinnedDestination(fsModule, dest, admission, hardlinks) {
     let preview;
     try {
         preview = fsModule === fs ? syncFs.lstatSync(dest) : await fsModule.lstat(dest);
     }
     catch (error) {
-        if (notFound(error))
+        if (hasErrorCode(error, "ENOENT"))
             return null;
         throw error;
     }
@@ -64,13 +63,22 @@ async function openPinnedDestination(fsModule, dest, admission, hardlinks) {
     }
     const handle = await fsModule.open(dest, admission === "restore" ? OPEN_READ_WRITE_FLAGS : OPEN_READ_FLAGS);
     try {
-        const opened = fsModule === fs ? syncFs.fstatSync(handle.fd) : await handle.stat();
-        const current = fsModule === fs ? syncFs.lstatSync(dest) : await fsModule.lstat(dest);
-        assertPinnedDestination(current, opened, dest, hardlinks, admission);
+        if (fsModule === fs)
+            inspectPinnedDestinationSync(syncFs, handle.fd, dest, admission, hardlinks);
+        else {
+            const opened = await inspectFileIdentity(() => handle.stat({ bigint: true }));
+            await inspectFileIdentity(async () => admitDestinationKind(await fsModule.lstat(dest, { bigint: true }), opened, dest, admission), opened);
+            assertDestinationLinks(opened, dest, admission, hardlinks);
+        }
         return handle;
     }
     catch (error) {
-        await handle.close().catch(() => undefined);
+        try {
+            await handle.close();
+        }
+        catch {
+            // Preserve the already-selected admission failure.
+        }
         throw error;
     }
 }
@@ -80,7 +88,7 @@ function openPinnedDestinationSync(fsModule, dest, admission, hardlinks) {
         preview = fsModule.lstatSync(dest);
     }
     catch (error) {
-        if (notFound(error))
+        if (hasErrorCode(error, "ENOENT"))
             return null;
         throw error;
     }
@@ -91,8 +99,7 @@ function openPinnedDestinationSync(fsModule, dest, admission, hardlinks) {
     }
     const fd = fsModule.openSync(dest, admission === "restore" ? OPEN_READ_WRITE_FLAGS : OPEN_READ_FLAGS);
     try {
-        const opened = fsModule.fstatSync(fd);
-        assertPinnedDestination(fsModule.lstatSync(dest), opened, dest, hardlinks, admission);
+        inspectPinnedDestinationSync(fsModule, fd, dest, admission, hardlinks);
         return fd;
     }
     catch (error) {
@@ -103,8 +110,14 @@ export async function assertDestinationHardlinkPolicy(fsModule, dest, policy) {
     if (policy !== "reject")
         return;
     const handle = await openPinnedDestination(fsModule, dest, "hardlinks");
-    if (handle)
-        await handle.close().catch(() => undefined);
+    if (!handle)
+        return;
+    try {
+        await handle.close();
+    }
+    catch {
+        // The asynchronous admission pin has best-effort close semantics.
+    }
 }
 export function assertDestinationHardlinkPolicySync(fsModule, dest, policy) {
     if (policy !== "reject")
@@ -239,7 +252,7 @@ export async function copyFallbackReplace(params) {
                     ? syncFs.lstatSync(params.dest) : await params.fsModule.lstat(params.dest);
             }
             catch (error) {
-                if (!notFound(error))
+                if (!hasErrorCode(error, "ENOENT"))
                     throw error;
             }
             if (destStat?.isSymbolicLink()) {
@@ -294,7 +307,7 @@ export function copyFallbackReplaceSync(params) {
                 destStat = params.fsModule.lstatSync(params.dest);
             }
             catch (error) {
-                if (!notFound(error))
+                if (!hasErrorCode(error, "ENOENT"))
                     throw error;
             }
             if (destStat?.isSymbolicLink()) {

package/dist/replace-file-copy-source.d.ts

@@ -18,4 +18,3 @@ export declare function readOwnedCopySourceSync(params: {
     mode: number;
 };
 export {};
-//# sourceMappingURL=replace-file-copy-source.d.ts.map

package/dist/replace-file-copy-source.js

@@ -3,8 +3,8 @@ import fs, {} from "node:fs/promises";
 import { readBoundedSync } from "./bounded-read.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
 import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
+import { hasErrorCode } from "./file-cleanup.js";
 const OPEN_READ_FLAGS = resolveReadOpenFlags();
 function assertSourcePreview(source, src) {
     if (source.isSymbolicLink()) {
@@ -18,10 +18,10 @@ function assertSourcePreview(source, src) {
     }
 }
 function assertOpenedSource(opened, current, src) {
-    if (!opened.isFile() || current.isSymbolicLink() || !sameFileIdentity(opened, current)) {
+    if (!opened.isFile() || current.isSymbolicLink()) {
         throw new FsSafeError("path-mismatch", `Copy fallback source changed while opening: ${src}`);
     }
-    if (opened.nlink !== 1) {
+    if (opened.nlink !== 1n) {
         throw new FsSafeError("hardlink", `Hardlinked copy fallback source not allowed: ${src}`);
     }
 }
@@ -35,7 +35,7 @@ async function openSource(fsModule, src) {
         return await fsModule.open(src, OPEN_READ_FLAGS);
     }
     catch (error) {
-        if (error.code === "ELOOP") {
+        if (hasErrorCode(error, "ELOOP")) {
             throw sourceSymlinkError(src, error);
         }
         throw error;
@@ -46,7 +46,7 @@ function openSourceSync(fsModule, src) {
         return fsModule.openSync(src, OPEN_READ_FLAGS);
     }
     catch (error) {
-        if (error.code === "ELOOP") {
+        if (hasErrorCode(error, "ELOOP")) {
             throw sourceSymlinkError(src, error);
         }
         throw error;
@@ -65,34 +65,30 @@ export async function readOwnedCopySource(params) {
         ? syncFs.lstatSync(params.src) : await params.fsModule.lstat(params.src), params.src);
     const handle = await openSource(params.fsModule, params.src);
     try {
-        if (params.expectedIdentity) {
-            const exact = await inspectFileIdentity(() => params.fsModule === fs
-                ? syncFs.fstatSync(handle.fd, { bigint: true }) : handle.stat({ bigint: true }), params.expectedIdentity);
-            await inspectFileIdentity(() => params.fsModule === fs
-                ? syncFs.lstatSync(params.src, { bigint: true }) : params.fsModule.lstat(params.src, { bigint: true }), exact);
-        }
-        const opened = params.fsModule === fs ? syncFs.fstatSync(handle.fd) : await handle.stat();
-        const current = params.fsModule === fs
-            ? syncFs.lstatSync(params.src) : await params.fsModule.lstat(params.src);
+        const opened = await inspectFileIdentity(() => params.fsModule === fs
+            ? syncFs.fstatSync(handle.fd, { bigint: true }) : handle.stat({ bigint: true }), params.expectedIdentity);
+        const current = await inspectFileIdentity(() => params.fsModule === fs
+            ? syncFs.lstatSync(params.src, { bigint: true }) : params.fsModule.lstat(params.src, { bigint: true }), opened);
         assertOpenedSource(opened, current, params.src);
-        return { replacement: await handle.readFile(), mode: opened.mode };
+        return { replacement: await handle.readFile(), mode: Number(opened.mode) };
     }
     finally {
-        await handle.close().catch(() => undefined);
+        try {
+            await handle.close();
+        }
+        catch {
+            // Best-effort close includes synchronous adapter throws.
+        }
     }
 }
 export function readOwnedCopySourceSync(params) {
     assertSourcePreview(params.fsModule.lstatSync(params.src), params.src);
     const fd = openSourceSync(params.fsModule, params.src);
     try {
-        if (params.expectedIdentity) {
-            const exact = inspectFileIdentitySync(() => params.fsModule.fstatSync(fd, { bigint: true }), params.expectedIdentity);
-            inspectFileIdentitySync(() => params.fsModule.lstatSync(params.src, { bigint: true }), exact);
-        }
-        const opened = params.fsModule.fstatSync(fd);
-        const current = params.fsModule.lstatSync(params.src);
+        const opened = inspectFileIdentitySync(() => params.fsModule.fstatSync(fd, { bigint: true }), params.expectedIdentity);
+        const current = inspectFileIdentitySync(() => params.fsModule.lstatSync(params.src, { bigint: true }), opened);
         assertOpenedSource(opened, current, params.src);
-        return { replacement: readAllSync(params.fsModule, fd, opened.size), mode: opened.mode };
+        return { replacement: readAllSync(params.fsModule, fd, Number(opened.size)), mode: Number(opened.mode) };
     }
     finally {
         try {

package/dist/replace-file-descriptor.d.ts

@@ -48,4 +48,3 @@ export declare function writeTempFileSync(params: {
     identity: BigIntStats;
 };
 export {};
-//# sourceMappingURL=replace-file-descriptor.d.ts.map