@openclaw/openshell-sandbox 2026.9.5 → 2026.9.7

package/node_modules/@openclaw/fs-safe/dist/private-temp-workspace.js

@@ -9,12 +9,11 @@ import { inspectDirectoryIdentitySync } from "./directory-guard.js";
 import { throwFsSafeReadError } from "./root-errors.js";
 import { matchRootFileOpenFailure, openRootFileSync, } from "./root-file.js";
 import { registerTempPathForExit, } from "./temp-cleanup.js";
-import { TempWorkspaceCleanupCapability, TempWorkspaceCleanupOwner, } from "./temp-workspace-owner.js";
+import { TempWorkspaceCleanupCapability, TempWorkspaceCleanupOwner, throwTempWorkspaceCreationFailure, } from "./temp-workspace-owner.js";
 import { assertNoWindowsPathAlias, hasWindowsPathAlias, } from "./windows-path-alias.js";
 import { TempWorkspaceRetainedChild } from "./temp-workspace-descriptor.js";
-import { admitRetainedTempWorkspaceChild, admitRetainedTempWorkspaceChildSync, validateInitialTempWorkspaceChild, } from "./temp-workspace-child-admission.js";
+import { validateInitialTempWorkspaceChild, validateTempWorkspaceDirMode } from "./temp-workspace-child-admission.js";
 import { admitTempWorkspaceRoot, admitTempWorkspaceRootSync, } from "./temp-workspace-admission.js";
-import { validateTempWorkspaceDirMode } from "./temp-workspace-permissions.js";
 function resolveTempWorkspaceCleanupSafety(value) {
     if (value === undefined || value === "compatible")
         return "compatible";
@@ -107,30 +106,53 @@ function throwTempWorkspaceOpenFailure(failure) {
         },
     });
 }
-async function createTempWorkspace(options, scopedPrefix = false) {
+function tempWorkspaceSettings(options) {
     const rootDir = options.rootDir;
     assertNoWindowsPathAlias(rootDir, "filesystem", "temp workspace root uses a Windows filesystem namespace alias");
     const dirMode = options.dirMode ?? 0o700;
     validateTempWorkspaceDirMode(dirMode);
     const mode = options.mode ?? 0o600;
     const cleanupSafety = resolveTempWorkspaceCleanupSafety(options.cleanupSafety);
-    const admission = await admitTempWorkspaceRoot(rootDir);
-    const root = admission.dir;
+    return { rootDir, dirMode, mode, cleanupSafety };
+}
+function tempWorkspaceChildPrefix(root, options, scopedPrefix) {
     assertNoWindowsPathAlias(root, "filesystem", "temp workspace root uses a Windows filesystem namespace alias");
-    // Capture and sanitize caller-controlled prefix data before retaining descriptors.
-    const rawPrefix = options.prefix;
-    const workspacePrefix = scopedPrefix
-        ? `${sanitizeTempPrefix(rawPrefix)}${randomUUID()}-`
-        : rawPrefix;
+    // Capture and sanitize caller-controlled data before retaining descriptors.
+    const prefix = options.prefix;
+    const workspacePrefix = scopedPrefix ? `${sanitizeTempPrefix(prefix)}${randomUUID()}-` : prefix;
     const childPrefix = path.join(root, sanitizeTempPrefix(workspacePrefix));
     assertNoWindowsPathAlias(childPrefix, "filesystem", "temp workspace path uses a Windows filesystem namespace alias");
+    return childPrefix;
+}
+function registerTempWorkspace(dir, retainedChild, capability, admission, dirMode) {
+    let owner;
+    let stat;
+    let unregisterTempDir;
+    try {
+        const retainChildDescriptor = capability.admitChildDescriptor(retainedChild.ensureReadable());
+        // Final adoption orders ancestry and cleanup-parent authority before the
+        // original child's descriptor and named security-state checks.
+        if (capability.parent)
+            capability.assertAncestryCurrent();
+        else
+            admission.assertAncestry();
+        stat = retainedChild.finalizeAdmission(admission.ownerUid, dirMode);
+        owner = new TempWorkspaceCleanupOwner(retainedChild, capability, retainChildDescriptor);
+        unregisterTempDir = registerTempPathForExit(dir, { cleanupSync: () => owner.cleanupSync() });
+    }
+    catch (error) {
+        throwTempWorkspaceCreationFailure(error, retainedChild, capability, owner);
+    }
+    return { owner: owner, unregisterTempDir, identity: { dev: Number(stat.dev), ino: Number(stat.ino) } };
+}
+async function createTempWorkspace(options, scopedPrefix = false) {
+    const { rootDir, dirMode, mode, cleanupSafety } = tempWorkspaceSettings(options);
+    const admission = await admitTempWorkspaceRoot(rootDir);
+    const root = admission.dir;
+    const childPrefix = tempWorkspaceChildPrefix(root, options, scopedPrefix);
     const capability = new TempWorkspaceCleanupCapability(root, cleanupSafety, admission, dirMode);
     let dir;
-    let stat;
     let retainedChild;
-    let retainChildDescriptor = false;
-    let cleanupOwner;
-    let unregisterTempDir;
     try {
         // Native capability discovery is complete before this synchronous
         // boundary. The existing canonical-root route now captures the complete
@@ -143,60 +165,19 @@ async function createTempWorkspace(options, scopedPrefix = false) {
             capability.assertCurrent();
         else
             admission.assertCurrent();
-        stat = inspectDirectoryIdentitySync(dir);
+        const stat = inspectDirectoryIdentitySync(dir);
         const needsModeInitialization = validateInitialTempWorkspaceChild(stat, admission.ownerUid, dirMode);
         // Retain while the child still has its private creation mode so an
         // explicit dirMode such as 0 cannot make identity descriptor acquisition fail.
         retainedChild = TempWorkspaceRetainedChild.retain(dir, stat);
-        const modeInitialization = admitRetainedTempWorkspaceChild(retainedChild, needsModeInitialization, admission, dirMode);
-        if (modeInitialization)
-            await modeInitialization;
-        retainChildDescriptor = capability.admitChildDescriptor(retainedChild.ensureReadable());
-        // Final adoption order is deliberate: complete ancestry, retained cleanup
-        // parent, then descriptor and named checks of the original child identity.
-        if (capability.parent)
-            capability.assertAncestryCurrent();
-        else
-            admission.assertAncestry();
-        stat = retainedChild.finalizeAdmission(admission.ownerUid, dirMode);
-        cleanupOwner = new TempWorkspaceCleanupOwner(retainedChild, capability, retainChildDescriptor);
-        retainedChild = undefined;
-        unregisterTempDir = registerTempPathForExit(dir, {
-            cleanupSync: () => cleanupOwner.cleanupSync(),
-        });
+        if (needsModeInitialization) {
+            await retainedChild.initializeMode(dirMode, admission.ownerUid, admission.assertCurrent);
+        }
     }
     catch (error) {
-        try {
-            if (cleanupOwner)
-                cleanupOwner.cleanupSync();
-            else {
-                const closeErrors = [];
-                try {
-                    retainedChild?.close();
-                }
-                catch (closeError) {
-                    closeErrors.push(closeError);
-                }
-                try {
-                    capability.close();
-                }
-                catch (closeError) {
-                    closeErrors.push(closeError);
-                }
-                if (closeErrors.length === 1)
-                    throw closeErrors[0];
-                if (closeErrors.length > 1) {
-                    throw new AggregateError(closeErrors, "temp workspace admission descriptor close failed");
-                }
-            }
-        }
-        catch (cleanupError) {
-            throw new AggregateError([error, cleanupError], "temp workspace creation and cleanup both failed");
-        }
-        throw error;
+        throwTempWorkspaceCreationFailure(error, retainedChild, capability);
     }
-    const owner = cleanupOwner;
-    const identity = { dev: Number(stat.dev), ino: Number(stat.ino) };
+    const { owner, identity, unregisterTempDir } = registerTempWorkspace(dir, retainedChild, capability, admission, dirMode);
     // Once registered, even a store-construction failure remains exit-cleanable.
     const store = fileStore({ rootDir: dir, private: true, dirMode, mode });
     return {
@@ -250,30 +231,13 @@ export async function withTempWorkspace(options, run) {
     }
 }
 function createTempWorkspaceSync(options, scopedPrefix = false) {
-    const rootDir = options.rootDir;
-    assertNoWindowsPathAlias(rootDir, "filesystem", "temp workspace root uses a Windows filesystem namespace alias");
-    const dirMode = options.dirMode ?? 0o700;
-    validateTempWorkspaceDirMode(dirMode);
-    const mode = options.mode ?? 0o600;
-    const cleanupSafety = resolveTempWorkspaceCleanupSafety(options.cleanupSafety);
+    const { rootDir, dirMode, mode, cleanupSafety } = tempWorkspaceSettings(options);
     const admission = admitTempWorkspaceRootSync(rootDir);
     const root = admission.dir;
-    assertNoWindowsPathAlias(root, "filesystem", "temp workspace root uses a Windows filesystem namespace alias");
-    // Capture and sanitize caller-controlled prefix data before retaining descriptors.
-    const rawPrefix = options.prefix;
-    const workspacePrefix = scopedPrefix
-        ? `${sanitizeTempPrefix(rawPrefix)}${randomUUID()}-`
-        : rawPrefix;
-    const childPrefix = path.join(root, sanitizeTempPrefix(workspacePrefix));
-    assertNoWindowsPathAlias(childPrefix, "filesystem", "temp workspace path uses a Windows filesystem namespace alias");
+    const childPrefix = tempWorkspaceChildPrefix(root, options, scopedPrefix);
     const capability = new TempWorkspaceCleanupCapability(root, cleanupSafety, admission, dirMode);
     let dir;
-    let stat;
     let retainedChild;
-    let retainChildDescriptor = false;
-    let needsModeInitialization;
-    let cleanupOwner;
-    let unregisterTempDir;
     try {
         const directRequestedMode = canCreateTempWorkspaceWithRequestedMode(dirMode);
         if (directRequestedMode) {
@@ -288,64 +252,28 @@ function createTempWorkspaceSync(options, scopedPrefix = false) {
             capability.assertCurrent();
         else
             admission.assertCurrent();
+        let stat;
         if (directRequestedMode) {
             const created = TempWorkspaceRetainedChild.retainCreated(dir);
             retainedChild = created.retained;
             stat = created.stat;
-            needsModeInitialization = validateInitialTempWorkspaceChild(stat, admission.ownerUid, dirMode);
         }
         else {
             stat = inspectDirectoryIdentitySync(dir);
-            needsModeInitialization = validateInitialTempWorkspaceChild(stat, admission.ownerUid, dirMode);
-            retainedChild = TempWorkspaceRetainedChild.retain(dir, stat);
         }
-        admitRetainedTempWorkspaceChildSync(retainedChild, needsModeInitialization, admission, dirMode);
-        retainChildDescriptor = capability.admitChildDescriptor(retainedChild.ensureReadable());
-        // Match async adoption: complete ancestry and retained cleanup authority
-        // precede descriptor and named child security-state checks.
-        if (capability.parent)
-            capability.assertAncestryCurrent();
-        else
-            admission.assertAncestry();
-        stat = retainedChild.finalizeAdmission(admission.ownerUid, dirMode);
-        cleanupOwner = new TempWorkspaceCleanupOwner(retainedChild, capability, retainChildDescriptor);
-        retainedChild = undefined;
-        unregisterTempDir = registerTempPathForExit(dir, {
-            cleanupSync: () => cleanupOwner.cleanupSync(),
-        });
-    }
-    catch (error) {
-        try {
-            if (cleanupOwner)
-                cleanupOwner.cleanupSync();
-            else {
-                const closeErrors = [];
-                try {
-                    retainedChild?.close();
-                }
-                catch (closeError) {
-                    closeErrors.push(closeError);
-                }
-                try {
-                    capability.close();
-                }
-                catch (closeError) {
-                    closeErrors.push(closeError);
-                }
-                if (closeErrors.length === 1)
-                    throw closeErrors[0];
-                if (closeErrors.length > 1) {
-                    throw new AggregateError(closeErrors, "temp workspace admission descriptor close failed");
-                }
-            }
+        const needsModeInitialization = validateInitialTempWorkspaceChild(stat, admission.ownerUid, dirMode);
+        retainedChild ??= TempWorkspaceRetainedChild.retain(dir, stat);
+        if (needsModeInitialization) {
+            retainedChild.initializeModeSync(dirMode, admission.ownerUid, admission.assertCurrent);
         }
-        catch (cleanupError) {
-            throw new AggregateError([error, cleanupError], "temp workspace creation and cleanup both failed");
+        else {
+            retainedChild.discardInitialReceipt();
         }
-        throw error;
     }
-    const owner = cleanupOwner;
-    const identity = { dev: Number(stat.dev), ino: Number(stat.ino) };
+    catch (error) {
+        throwTempWorkspaceCreationFailure(error, retainedChild, capability);
+    }
+    const { owner, identity, unregisterTempDir } = registerTempWorkspace(dir, retainedChild, capability, admission, dirMode);
     // Once registered, even a store-construction failure remains exit-cleanable.
     const store = fileStoreSync({ rootDir: dir, private: true, dirMode, mode });
     return {

package/node_modules/@openclaw/fs-safe/dist/publish-copy-stage.d.ts

@@ -1,6 +1,6 @@
 import { type BigIntStats } from "node:fs";
-import type { AnyAsyncDirectoryGuard } from "./directory-guard.js";
-import type { PublishedWriteIdentity } from "./pinned-write.js";
+import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import type { PublishedWriteIdentity } from "./pinned-write-types.js";
 export declare function publishCopyStage(params: {
     temporaryPath: string;
     targetPath: string;
@@ -8,6 +8,6 @@ export declare function publishCopyStage(params: {
     identity: BigIntStats;
     parentGuard: AnyAsyncDirectoryGuard;
     assertBeforeMutation?: () => void;
+    onPublicationAttempt?: () => void;
     onPublished?: (identity: PublishedWriteIdentity) => void;
 }): void;
-//# sourceMappingURL=publish-copy-stage.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/publish-copy-stage.js

@@ -1,19 +1,32 @@
 import fs, {} from "node:fs";
 import path from "node:path";
+import { assertSyncDirectoryGuard } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentityForCleanup } from "./file-identity.js";
 // Node has no portable no-replace rename. Link only our completed private stage,
 // then unlink it in the same JS turn so local readers never observe two names.
 export function publishCopyStage(params) {
     const { identity, temporaryPath, targetPath } = params;
-    const staged = fs.lstatSync(temporaryPath, { bigint: true });
-    const opened = fs.fstatSync(params.fd, { bigint: true });
-    if (!staged.isFile() || staged.isSymbolicLink() || staged.nlink !== 1n ||
-        !sameFileIdentityForCleanup(staged, identity) ||
-        !sameFileIdentityForCleanup(opened, identity)) {
-        throw new FsSafeError("path-mismatch", "exclusive copy stage changed before publication");
-    }
+    const assertCurrent = () => {
+        assertSyncDirectoryGuard(params.parentGuard);
+        const staged = fs.lstatSync(temporaryPath, { bigint: true });
+        const opened = fs.fstatSync(params.fd, { bigint: true });
+        if (!staged.isFile() || staged.isSymbolicLink() || staged.nlink !== 1n ||
+            !sameFileIdentityForCleanup(staged, identity) ||
+            !sameFileIdentityForCleanup(opened, identity)) {
+            throw new FsSafeError("path-mismatch", "exclusive copy stage changed before publication");
+        }
+    };
+    assertCurrent();
     params.assertBeforeMutation?.();
+    // Caller authority checks can synchronously replace a parent or staged entry.
+    if (params.assertBeforeMutation)
+        assertCurrent();
+    // An observed collision needs no dispatch; errno after a link attempt remains ambiguous.
+    if (fs.lstatSync(targetPath, { throwIfNoEntry: false })) {
+        throw new FsSafeError("already-exists", "destination already exists");
+    }
+    params.onPublicationAttempt?.();
     fs.linkSync(temporaryPath, targetPath);
     let observerRejected = false;
     let observerError;

package/node_modules/@openclaw/fs-safe/dist/publish-file-failure.d.ts

@@ -25,4 +25,3 @@ export type PublishFailureState = {
 export declare function rememberCreatedTarget(state: PublishFailureState, identity: FileIdentityStat, phase: PublishFileExclusiveFailurePhase): void;
 export declare function publicationFailure(error: unknown, state: PublishFailureState, cleanup: PublishFileExclusiveCleanup): FsSafeError;
 export declare function directorySyncFailure(error: unknown): PublishFileExclusiveDirectorySyncFailure;
-//# sourceMappingURL=publish-file-failure.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/publish-file.d.ts

@@ -1,8 +1,7 @@
-import { type Stats } from "node:fs";
+import { type BigIntStats, type Stats } from "node:fs";
 import { type DirectoryReceipt, type DirectorySyncOutcome } from "./directory-durability.js";
 import { type FileIdentityStat } from "./file-identity.js";
 import { type PublishFileExclusiveSyncFailurePolicy } from "./publish-file-failure.js";
-export type { PublishFileExclusiveCleanup, PublishFileExclusiveDirectorySyncFailure, PublishFileExclusiveFailureDetails, PublishFileExclusiveFailurePhase, PublishFileExclusiveSyncFailurePolicy, } from "./publish-file-failure.js";
 export type PublishFileExclusiveStrategy = "link-or-copy" | "link-required" | "rename-noreplace";
 export type PublishFileExclusiveResult = {
     method: "hardlink" | "exclusive-copy" | "rename-noreplace";
@@ -16,6 +15,5 @@ export declare function publishFileExclusive(params: {
     expectedSourceIdentity?: FileIdentityStat;
     strategy: PublishFileExclusiveStrategy;
     onSyncFailure?: PublishFileExclusiveSyncFailurePolicy;
-    parentReceipt?: DirectoryReceipt;
+    parentReceipt?: DirectoryReceipt<Stats | BigIntStats>;
 }): Promise<PublishFileExclusiveResult>;
-//# sourceMappingURL=publish-file.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/publish-file.js

@@ -4,6 +4,7 @@ import fs, {} from "node:fs/promises";
 import path from "node:path";
 import { pinDirectory, } from "./directory-durability.js";
 import { FsSafeError } from "./errors.js";
+import { ownDirectoryReceipt } from "./directory-receipt.js";
 import { hashFileHandle } from "./file-hash.js";
 import { sameFileIdentity, sameFileIdentityForCleanup, } from "./file-identity.js";
 import { syncFileBestEffortSync } from "./file-sync.js";
@@ -11,9 +12,10 @@ import { getNativeBinding, requireNativeBinding } from "./native.js";
 import { captureNativeFdClose } from "./native-binding.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { directorySyncFailure, publicationFailure, rememberCreatedTarget, } from "./publish-file-failure.js";
-import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
+import { admitStandalonePublicationPath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { hasErrorCode } from "./file-cleanup.js";
+import { writeAllToFile } from "./write-file-handle.js";
 const HARDLINK_FALLBACK_CODES = new Set(["EPERM", "EXDEV", "ENOTSUP", "EOPNOTSUPP", "ENOSYS"]);
 const NATIVE_COPY_FALLBACK_CODES = new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV"]);
 export function isHardlinkFallbackError(error) {
@@ -40,7 +42,7 @@ async function openNativeParent(filePath) {
         throw error;
     }
 }
-async function assertPinnedSourceCurrent(params) {
+function assertPinnedSourceCurrent(params) {
     // Windows file indexes can exceed Number.MAX_SAFE_INTEGER, so publication
     // fences must compare bigint stats instead of rounded numeric identities.
     const opened = fsSync.fstatSync(params.handle.fd, { bigint: true });
@@ -53,6 +55,23 @@ async function assertPinnedSourceCurrent(params) {
         throw new FsSafeError("path-mismatch", "publication source changed during operation");
     }
 }
+function assertPublishedTargetCurrent(targetPath, identity, message) {
+    const current = fsSync.lstatSync(targetPath, { bigint: true });
+    if (current.isSymbolicLink() || !current.isFile() || !sameFileIdentity(current, identity)) {
+        throw new FsSafeError("path-mismatch", message);
+    }
+}
+function assertRenamedSourceAbsent(sourcePath) {
+    try {
+        fsSync.lstatSync(sourcePath);
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT"))
+            return;
+        throw error;
+    }
+    throw new FsSafeError("path-mismatch", "no-replace publication source still exists");
+}
 async function copyPinnedSource(params) {
     if (params.native && params.targetNativeParent) {
         const closeFd = captureNativeFdClose(params.native);
@@ -130,15 +149,9 @@ async function copyPinnedSource(params) {
             if (bytesRead === 0) {
                 break;
             }
-            hash.update(buffer.subarray(0, bytesRead));
-            let written = 0;
-            while (written < bytesRead) {
-                const result = await target.write(buffer, written, bytesRead - written, position + written);
-                if (result.bytesWritten <= 0) {
-                    throw new FsSafeError("helper-failed", "exclusive publication copy made no progress");
-                }
-                written += result.bytesWritten;
-            }
+            const chunk = buffer.subarray(0, bytesRead);
+            hash.update(chunk);
+            await writeAllToFile(target, chunk, { position });
             position += bytesRead;
         }
         await target.sync();
@@ -183,8 +196,7 @@ export async function publishFileExclusive(params) {
     const targetPathInput = admitStandalonePublicationPath(params.targetPath, "publication target uses a Windows filesystem namespace alias");
     const parentReceiptInput = params.parentReceipt;
     const parentReceipt = parentReceiptInput
-        ? { path: parentReceiptInput.path, realPath: parentReceiptInput.realPath,
-            identity: parentReceiptInput.identity }
+        ? ownDirectoryReceipt(parentReceiptInput)
         : undefined;
     if (parentReceipt) {
         assertNoWindowsPathAlias(parentReceipt.path, "filesystem", "publication parent uses a Windows filesystem namespace alias");
@@ -208,6 +220,7 @@ export async function publishFileExclusive(params) {
     let parent;
     let sourceNativeParent;
     let targetNativeParent;
+    let copiedTarget;
     const strategy = params.strategy;
     const failure = {
         phase: strategy === "rename-noreplace" ? "rename-create" : "hardlink-create",
@@ -232,8 +245,20 @@ export async function publishFileExclusive(params) {
                     : sourceIdentity))) {
             throw new FsSafeError("path-mismatch", "publication source identity did not match");
         }
+        const assertSourceCurrent = () => assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
+        const finishPublication = async (method, handle, identity) => {
+            const verifyPhase = failure.phase;
+            const directorySync = await syncPublishedParent({ parent: parent, failure, method, targetPath });
+            failure.phase = verifyPhase;
+            if (method === "rename-noreplace")
+                assertRenamedSourceAbsent(sourcePath);
+            else
+                assertSourceCurrent();
+            assertPublishedTargetCurrent(targetPath, identity, "publication target changed during directory sync");
+            return { method, identity: fsSync.fstatSync(handle.fd), directorySync };
+        };
         await parent.assertCurrent();
-        await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
+        assertSourceCurrent();
         const native = strategy === "rename-noreplace"
             ? requireNativeBinding()
             : getNativeBinding();
@@ -248,33 +273,10 @@ export async function publishFileExclusive(params) {
             // A failed post-rename fence must not delete the only remaining name.
             failure.preserveTarget = true;
             await getFsSafeTestHooks()?.afterPublishTargetCreated?.("rename-noreplace", targetPath, sourceExactIdentity);
-            const targetExactIdentity = fsSync.lstatSync(targetPath, { bigint: true });
-            if (targetExactIdentity.isSymbolicLink() ||
-                !targetExactIdentity.isFile() ||
-                !sameFileIdentity(targetExactIdentity, sourceExactIdentity)) {
-                throw new FsSafeError("path-mismatch", "no-replace publication target changed");
-            }
-            try {
-                fsSync.lstatSync(sourcePath);
-                throw new FsSafeError("path-mismatch", "no-replace publication source still exists");
-            }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    throw error;
-                }
-            }
+            assertPublishedTargetCurrent(targetPath, sourceExactIdentity, "no-replace publication target changed");
+            assertRenamedSourceAbsent(sourcePath);
             syncFileBestEffortSync(sourceNativeParent.handle.fd);
-            const targetIdentity = fsSync.lstatSync(targetPath);
-            return {
-                method: "rename-noreplace",
-                identity: targetIdentity,
-                directorySync: await syncPublishedParent({
-                    parent,
-                    failure,
-                    method: "rename-noreplace",
-                    targetPath,
-                }),
-            };
+            return await finishPublication("rename-noreplace", source, sourceExactIdentity);
         }
         try {
             if (native) {
@@ -285,24 +287,9 @@ export async function publishFileExclusive(params) {
             }
             rememberCreatedTarget(failure, sourceExactIdentity, "hardlink-verify");
             await getFsSafeTestHooks()?.afterPublishTargetCreated?.("hardlink", targetPath, sourceExactIdentity);
-            const targetExactIdentity = fsSync.lstatSync(targetPath, { bigint: true });
-            if (targetExactIdentity.isSymbolicLink() ||
-                !targetExactIdentity.isFile() ||
-                !sameFileIdentity(targetExactIdentity, sourceExactIdentity)) {
-                throw new FsSafeError("path-mismatch", "hardlink publication target changed");
-            }
-            await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
-            const targetIdentity = fsSync.lstatSync(targetPath);
-            return {
-                method: "hardlink",
-                identity: targetIdentity,
-                directorySync: await syncPublishedParent({
-                    parent,
-                    failure,
-                    method: "hardlink",
-                    targetPath,
-                }),
-            };
+            assertPublishedTargetCurrent(targetPath, sourceExactIdentity, "hardlink publication target changed");
+            assertSourceCurrent();
+            return await finishPublication("hardlink", source, sourceExactIdentity);
         }
         catch (error) {
             if (failure.targetCreated ||
@@ -312,48 +299,19 @@ export async function publishFileExclusive(params) {
             }
         }
         failure.phase = "copy-create";
-        let target;
-        let targetIdentity;
-        try {
-            const copied = await copyPinnedSource({
-                source,
-                targetPath,
-                native,
-                targetNativeParent,
-                failure,
-            });
-            target = copied.handle;
-            targetIdentity = fsSync.fstatSync(target.fd);
-            const targetPathStat = fsSync.lstatSync(targetPath);
-            const targetPathExactStat = fsSync.lstatSync(targetPath, { bigint: true });
-            const copiedBack = await hashFileHandle(target, native);
-            const sourceAfter = await hashFileHandle(source, native);
-            if (targetPathStat.isSymbolicLink() ||
-                targetPathExactStat.isSymbolicLink() ||
-                !sameFileIdentity(targetPathExactStat, copied.exactIdentity) ||
-                copiedBack.bytes !== copied.bytes ||
-                copiedBack.digest !== copied.digest ||
-                sourceAfter.bytes !== copied.bytes ||
-                sourceAfter.digest !== copied.digest) {
-                throw new FsSafeError("path-mismatch", "exclusive publication copy failed content fencing");
-            }
-            await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
-            const directorySync = await syncPublishedParent({
-                parent,
-                failure,
-                method: "exclusive-copy",
-                targetPath,
-            });
-            return { method: "exclusive-copy", identity: targetPathStat, directorySync };
-        }
-        catch (error) {
-            await target?.close().catch(() => undefined);
-            target = undefined;
-            throw error;
-        }
-        finally {
-            await target?.close().catch(() => undefined);
+        const copied = await copyPinnedSource({ source, targetPath, native, targetNativeParent, failure });
+        copiedTarget = copied.handle;
+        const copiedBack = await hashFileHandle(copiedTarget, native);
+        const sourceAfter = await hashFileHandle(source, native);
+        assertPublishedTargetCurrent(targetPath, copied.exactIdentity, "exclusive publication copy failed content fencing");
+        if (copiedBack.bytes !== copied.bytes ||
+            copiedBack.digest !== copied.digest ||
+            sourceAfter.bytes !== copied.bytes ||
+            sourceAfter.digest !== copied.digest) {
+            throw new FsSafeError("path-mismatch", "exclusive publication copy failed content fencing");
         }
+        assertSourceCurrent();
+        return await finishPublication("exclusive-copy", copiedTarget, copied.exactIdentity);
     }
     catch (error) {
         if (!failure.targetCreated)
@@ -365,6 +323,7 @@ export async function publishFileExclusive(params) {
         throw publicationFailure(error, failure, cleanup);
     }
     finally {
+        await copiedTarget?.close().catch(() => undefined);
         await sourceNativeParent?.handle.close().catch(() => undefined);
         await targetNativeParent?.handle.close().catch(() => undefined);
         await source.close().catch(() => undefined);

package/node_modules/@openclaw/fs-safe/dist/read-open-flags.d.ts

@@ -5,4 +5,3 @@ export declare function resolveReadOpenFlags(options?: {
     followSymlinks?: boolean;
 }): number;
 export {};
-//# sourceMappingURL=read-open-flags.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/read-opened-file.d.ts

@@ -7,15 +7,11 @@ export type ReadResult = {
     realPath: string;
     stat: Stats;
 };
-type OpenedFile = {
+type OpenedFile = Omit<ReadResult & {
     handle: FileHandle;
-    containment: ContainmentGuarantee;
-    realPath: string;
-    stat: Stats;
-};
+}, "buffer">;
 export declare function readOpenedFileSafely(params: {
     opened: OpenedFile;
     maxBytes?: number;
 }): Promise<ReadResult>;
 export {};
-//# sourceMappingURL=read-opened-file.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/realpath.d.ts

@@ -1,4 +1,3 @@
 export declare const realpathSync: ((input: string) => string) & {
     native: (input: string) => string;
 };
-//# sourceMappingURL=realpath.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/recursive-mkdir-path.d.ts

@@ -1,3 +1,2 @@
 /** Bun's Windows recursive mkdir cannot inspect existing relative dot components. */
 export declare function recursiveMkdirPath(directory: string): string;
-//# sourceMappingURL=recursive-mkdir-path.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/regular-file.d.ts

@@ -35,4 +35,3 @@ export declare function readRegularFileSync(params: {
 export declare function appendRegularFile(options: AppendRegularFileOptions): Promise<void>;
 export declare function appendRegularFileSync(options: AppendRegularFileOptions): void;
 export {};
-//# sourceMappingURL=regular-file.d.ts.map