@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@openclaw/fs-safe/dist/native-rename-outcome.js

@@ -1,8 +1,13 @@
 export const NATIVE_RENAME_SOURCE_IDENTITY_MISMATCH = "FS_SAFE_INTERNAL_RENAME_SOURCE_IDENTITY_MISMATCH";
 export function classifyNativeRenameFailure(error) {
-    const code = error?.code ?? "";
+    try {
+        if (error?.code === NATIVE_RENAME_SOURCE_IDENTITY_MISMATCH) {
+            return "uncommitted";
+        }
+    }
+    catch {
+        // Unreadable diagnostics cannot prove that the rename was uncommitted.
+    }
     // Ordinary errno can follow a committed remote rename whose reply was lost.
-    return code === NATIVE_RENAME_SOURCE_IDENTITY_MISMATCH
-        ? "uncommitted"
-        : "indeterminate";
+    return "indeterminate";
 }

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

@@ -57,14 +57,14 @@ import { randomUUID } from "node:crypto";
 import fs, {} from "node:fs";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
-import { assertSynchronousCallbackResult, MutationAuthorityError } from "./mutation-authority.js";
+import { assertSynchronousCallbackResult, isMutationAuthorityError } from "./mutation-authority.js";
 import { captureNativeFdClose } from "./native-binding.js";
 import { writePinnedInput } from "./pinned-write-input.js";
 import { assertNativeCopyCompleted, createNativeCopyFile } from "./copy-file-input.js";
 import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
 import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
 import { classifyNativeRenameFailure } from "./native-rename-outcome.js";
-import { createStagedFileReceipt, stagedFileFailure as failure } from "./staged-file-settlement.js";
+import { createStagedFileReceipt, stagedFailure } from "./staged-file-settlement.js";
 export function assertNativeStaging(binding) {
     if ([
         binding.closeOwnedFd,
@@ -152,7 +152,7 @@ class NativeStagedFile {
             }
             catch (error) {
                 if (params.overwrite === false && params.input.kind !== "file" && params.input.stageBeforePublish === true) {
-                    throw failure(error, { phase: "publish", publication: published });
+                    throw stagedFailure("file", error, { phase: "publish", publication: published });
                 }
                 throw error;
             }
@@ -175,7 +175,7 @@ class NativeStagedFile {
         return this.#receipt;
     }
     #open() {
-        if (this.#state.status === "closed") {
+        if (this.#state.status !== "open") {
             throw new FsSafeError("helper-failed", "staged file is closed");
         }
         return this.#state;
@@ -238,7 +238,7 @@ class NativeStagedFile {
                 assertDarwinCreationAcl(this.#owner.parentFd, "file");
             // Native copying populates its new file before returning its descriptor.
             const copied = input.kind === "file" && !this.#verifyMode
-                ? await createNativeCopyFile(this.#owner.binding, input, this.#owner.parentFd, this.#owner.name, maxBytes, false)
+                ? await createNativeCopyFile(this.#owner.binding, input, this.#owner.parentFd, this.#owner.name, maxBytes)
                 : undefined;
             state.fileFd = copied?.fd;
             if (state.fileFd === undefined) {
@@ -282,10 +282,10 @@ class NativeStagedFile {
         catch (error) {
             const { receipt: cleanup, error: cleanupError } = this.#finalize();
             if (cleanupError) {
-                throw failure(new AggregateError([error, cleanupError], "preparation and cleanup failed"), { phase: "prepare", publication: cleanup.publication, cleanup });
+                throw stagedFailure("file", new AggregateError([error, cleanupError], "preparation and cleanup failed"), { phase: "prepare", publication: cleanup.publication, cleanup });
             }
             if (cleanup.status === "preserved") {
-                throw failure(error, { phase: "prepare", publication: cleanup.publication, cleanup });
+                throw stagedFailure("file", error, { phase: "prepare", publication: cleanup.publication, cleanup });
             }
             throw error;
         }
@@ -319,22 +319,24 @@ class NativeStagedFile {
                 }
             }
             catch (error) {
+                // Record before inspecting metadata, whose getters can reenter cleanup.
+                state.publication = Object.freeze({ status: "indeterminate", basename, overwrite });
                 // Only explicit pre-dispatch provenance can rule out a committed rename.
-                if (classifyNativeRenameFailure(error) === "indeterminate") {
-                    state.publication = Object.freeze({ status: "indeterminate", basename, overwrite });
+                if (classifyNativeRenameFailure(error) === "uncommitted") {
+                    state.publication = NOT_PUBLISHED;
                 }
                 throw error;
             }
             return this.#completePublication(basename, overwrite, onPublished);
         }
         catch (error) {
-            if (error instanceof MutationAuthorityError)
+            if (isMutationAuthorityError(error))
                 throw error;
             // Closure rejects further use, not the recorded outcome of an earlier publication.
             const publication = this.#state.status === "closed"
                 ? this.#state.receipt.publication
                 : this.#state.publication;
-            throw failure(error, { phase: "publish", publication });
+            throw stagedFailure("file", error, { phase: "publish", publication });
         }
     }
     #completePublication(basename, overwrite, onPublished) {
@@ -367,7 +369,9 @@ class NativeStagedFile {
         if (this.#state.status === "closed") {
             return this.#state;
         }
-        const state = this.#state;
+        const state = this.#open();
+        // Consume descriptor authority before native calls or diagnostic getters can reenter.
+        state.status = "closing";
         let outcome = "not-needed";
         const errors = [];
         if (state.publication.status === "indeterminate") {
@@ -404,7 +408,7 @@ class NativeStagedFile {
             status: outcome,
             resources,
         });
-        const error = errors.length ? failure(errors.length === 1 ? errors[0] : new AggregateError(errors, "staged cleanup failed"), { phase: "cleanup", publication: state.publication, cleanup: receipt }) : undefined;
+        const error = errors.length ? stagedFailure("file", errors.length === 1 ? errors[0] : new AggregateError(errors, "staged cleanup failed"), { phase: "cleanup", publication: state.publication, cleanup: receipt }) : undefined;
         this.#state = { status: "closed", receipt, error };
         return this.#state;
     }

package/node_modules/@openclaw/fs-safe/dist/native-staged-symlink.js

@@ -5,7 +5,7 @@ import { captureNativeFdClose } from "./native-binding.js";
 import { requireNativeBinding } from "./native.js";
 import { classifyNativeRenameFailure } from "./native-rename-outcome.js";
 import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
-import { createStagedFileReceipt } from "./staged-file-settlement.js";
+import { createStagedFileReceipt, stagedFailure } from "./staged-file-settlement.js";
 const NOT_PUBLISHED = Object.freeze({ status: "not-published" });
 function basename(name) {
     if (typeof name !== "string" || !name || name === "." || name === ".." ||
@@ -13,17 +13,6 @@ function basename(name) {
         throw new FsSafeError("invalid-path", "staged symlinks require a direct-child basename");
     }
 }
-function failure(error, details) {
-    let code = "helper-failed";
-    try {
-        code = error instanceof FsSafeError ? error.code
-            : error?.code === "EEXIST" ? "already-exists" : "helper-failed";
-    }
-    catch {
-        // Uninspectable error metadata must not interrupt terminal settlement.
-    }
-    return new FsSafeError(code, `staged symlink ${details.phase} failed`, { cause: error, details });
-}
 function assertAuthority(assertion) {
     assertSynchronousCallbackResult(assertion(), "assertBeforeMutation");
 }
@@ -101,14 +90,7 @@ class NativeStagedSymlink {
                 this.#binding.publishStagedSymlink(this.#parentFd, this.#receipt.temporaryBasename, this.#linkFd, name);
             }
             catch (error) {
-                let outcome = "indeterminate";
-                try {
-                    outcome = classifyNativeRenameFailure(error);
-                }
-                catch {
-                    // Unreadable diagnostics cannot prove that the rename was uncommitted.
-                }
-                if (outcome === "indeterminate") {
+                if (classifyNativeRenameFailure(error) === "indeterminate") {
                     this.#publication = Object.freeze({ status: "indeterminate", basename: name, overwrite: false });
                 }
                 throw error;
@@ -123,7 +105,7 @@ class NativeStagedSymlink {
             return published;
         }
         catch (error) {
-            throw failure(error, { phase: "publish", publication: this.#publication });
+            throw stagedFailure("symlink", error, { phase: "publish", publication: this.#publication });
         }
         finally {
             this.#busy = false;
@@ -181,7 +163,7 @@ class NativeStagedSymlink {
             return receipt;
         }
         catch (error) {
-            const wrapped = failure(error, { phase: "remove-published", publication: this.#publication });
+            const wrapped = stagedFailure("symlink", error, { phase: "remove-published", publication: this.#publication });
             // A failed unlink is not safe to retry automatically.
             this.#removal = { error: wrapped };
             throw wrapped;
@@ -225,7 +207,7 @@ class NativeStagedSymlink {
             temporaryBasename: this.#receipt.temporaryBasename,
             publication: this.#publication, status, resources,
         });
-        const error = errors.length ? failure(errors.length === 1 ? errors[0] : new AggregateError(errors, "symlink settlement failed"), { phase: "cleanup", publication: this.#publication, cleanup: receipt }) : undefined;
+        const error = errors.length ? stagedFailure("symlink", errors.length === 1 ? errors[0] : new AggregateError(errors, "symlink settlement failed"), { phase: "cleanup", publication: this.#publication, cleanup: receipt }) : undefined;
         this.#closed = { receipt, error };
         this.#busy = false;
         if (error)
@@ -298,6 +280,6 @@ export async function retainSymlinkInDirectory(options) {
             }
         }
         // Until admission succeeds, the caller retains every namespace cleanup duty.
-        throw failure(errors.length === 1 ? error : new AggregateError(errors, "symlink admission and close failed"), { phase: "prepare", publication: NOT_PUBLISHED });
+        throw stagedFailure("symlink", errors.length === 1 ? error : new AggregateError(errors, "symlink admission and close failed"), { phase: "prepare", publication: NOT_PUBLISHED });
     }
 }

package/node_modules/@openclaw/fs-safe/dist/native.js

@@ -1,9 +1,13 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { closeSync, openSync, readSync, readdirSync, } from "node:fs";
 import { createRequire } from "node:module";
 import { FsSafeError } from "./errors.js";
 import { captureNativeFdClose } from "./native-binding.js";
 import { getFsSafeNativeConfig } from "./native-config.js";
 const require = createRequire(import.meta.url);
+// Native registration creates process-lifetime housekeeping. Use the import
+// context rather than retaining the first operation's AsyncLocalStorage stores.
+const runNativeInitialization = AsyncLocalStorage.snapshot();
 let binding;
 let loadError;
 let attempted = false;
@@ -145,7 +149,7 @@ function loadBundledBinding() {
     if (!target) {
         throw new Error(`Unsupported OS or architecture: ${process.platform}-${process.arch}`);
     }
-    const loaded = require(nativePackageForTarget(target));
+    const loaded = runNativeInitialization(() => require(nativePackageForTarget(target)));
     captureNativeFdClose(loaded);
     return loaded;
 }

package/node_modules/@openclaw/fs-safe/dist/path-case.js

@@ -5,8 +5,9 @@ import { assertDirectoryIdentitySync, inspectDirectoryIdentitySync } from "./dir
 import { sameFileIdentityForCleanup } from "./file-identity.js";
 import { isNotFoundPathError } from "./path.js";
 import { realpathSync } from "./realpath.js";
-import { writeTempFileSync } from "./replace-file-descriptor.js";
-import { SyncAtomicTempOwner } from "./replace-file-temp-owner.js";
+import { writeTempFile } from "./replace-file-descriptor.js";
+import { AtomicIo, runSync } from "./atomic-io.js";
+import { AtomicTempOwner } from "./replace-file-temp-owner.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 function swapAsciiCase(value) {
     return value.replace(/[A-Za-z]/g, character => {
@@ -54,25 +55,25 @@ function probeEntry(directory, name, names) {
 }
 function probeTemporaryEntry(directory) {
     const name = `.fs-safe-case-probe-${randomUUID()}`;
-    const owner = new SyncAtomicTempOwner(path.join(directory, name));
+    const io = AtomicIo.sync(fs);
+    const owner = new AtomicTempOwner(path.join(directory, name), io);
     try {
         owner.start();
-        owner.adopt(writeTempFileSync({
-            fsModule: fs,
+        owner.adopt(runSync(writeTempFile(io, {
             tempPath: owner.pathname,
             content: "",
             mode: 0o600,
             sync: false,
             onIdentity: owner.onIdentity,
-        }));
-        owner.assertCurrent(fs);
+        })));
+        runSync(owner.assertCurrent());
         const observed = probeEntry(directory, name, new Set(fs.readdirSync(directory)));
-        owner.assertCurrent(fs);
+        runSync(owner.assertCurrent());
         return observed;
     }
     finally {
         // Failed cleanup invalidates the observation; the existing owner retains its exit retry.
-        owner.finish({ fsModule: fs, throwOnCleanupError: true });
+        runSync(owner.finish({ throwOnCleanupError: true }));
     }
 }
 function probeDirectory(directory, allowTemporaryProbe, preferredName) {

package/node_modules/@openclaw/fs-safe/dist/path-scope-lexical.js

@@ -1,10 +1,13 @@
 import path from "node:path";
 import { isPathInside, isPathRelativeEscape } from "./path.js";
-import { hasWindowsPathAlias, resolvePathFromBasePreservingWindowsRoot } from "./windows-path-alias.js";
+import { hasWindowsPathAlias, isForeignWindowsShareOrDevicePath, resolvePathFromBasePreservingWindowsRoot, } from "./windows-path-alias.js";
 function pathStaysWithinRoot(rootDir, candidatePath) {
     if (process.platform !== "win32") {
         return candidatePath !== rootDir && isPathInside(rootDir, candidatePath);
     }
+    // path.relative folds Unicode case, so it alone could admit another host.
+    if (isForeignWindowsShareOrDevicePath(candidatePath, [rootDir]))
+        return false;
     const relative = path.relative(rootDir, candidatePath);
     return Boolean(relative) && !isPathRelativeEscape(relative);
 }

package/node_modules/@openclaw/fs-safe/dist/path-segment-route.d.ts

@@ -1,3 +1,4 @@
+export declare function sameAbsolutePath(left: string, right: string): boolean;
 export type PathSegmentRoute = Readonly<{
     joined: string;
     offsets: readonly number[];

package/node_modules/@openclaw/fs-safe/dist/path-segment-route.js

@@ -1,4 +1,7 @@
 import path from "node:path";
+export function sameAbsolutePath(left, right) {
+    return path.relative(path.resolve(left), path.resolve(right)) === "";
+}
 export function createPathSegmentRoute(segments) {
     const offsets = new Array(segments.length + 1);
     let cursor = 0;

package/node_modules/@openclaw/fs-safe/dist/path.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { realpathSync } from "./realpath.js";
 import { isDriveRelativePath } from "./safe-path-segment.js";
-import { assertNoWindowsPathAlias, hasWindowsPathAlias, pathForWindowsFilesystem, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
+import { assertNoWindowsPathAlias, hasWindowsPathAlias, isForeignWindowsShareOrDevicePath, pathForWindowsFilesystem, resolvePathFromBasePreservingWindowsRoot, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 export { assertNoUnsafeDeviceReadPath, isUnsafeDeviceReadPath, matchUnsafeDeviceReadPath, } from "./device-path.js";
 const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
 const SYMLINK_OPEN_CODES = new Set(["ELOOP", "EINVAL", "ENOTSUP"]);
@@ -47,6 +47,9 @@ export function isSymlinkOpenError(value) {
 }
 export function isPathInside(root, target) {
     if (process.platform === "win32") {
+        // Comparison folds Unicode case, so it alone could admit another host.
+        if (isForeignWindowsShareOrDevicePath(target, [root]))
+            return false;
         const rootForCompare = resolveWindowsPathForComparison(root);
         const targetForCompare = resolveWindowsPathForComparison(target);
         // Resolved drive paths already have canonical separators and case. A full

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

@@ -36,7 +36,6 @@ export declare function inspectWindowsAcl(targetPath: string, opts?: {
     env?: NodeJS.ProcessEnv;
     exec?: PermissionExec;
     currentUserSid?: string;
-    principalSids?: Record<string, string>;
     principalTranslationFailed?: boolean;
 }): Promise<WindowsAclSummary>;
 export declare function formatWindowsAclSummary(summary: WindowsAclSummary): string;

package/node_modules/@openclaw/fs-safe/dist/pinned-mutation-admission.js

@@ -3,6 +3,7 @@ import { assertMutationNotDenied } from "./deny-mutations.js";
 import { createMutationDenyMatcher } from "./deny-mutation-match.js";
 import { FsSafeError } from "./errors.js";
 import { isPathInside } from "./path.js";
+import { sameAbsolutePath } from "./path-segment-route.js";
 import { admitPathInsideRoot } from "./root-boundary.js";
 import { ordinarySharedAbsoluteInsideRoot, simpleSharedRoute, } from "./pinned-mutation-shared-route.js";
 import { resolvePathViaExistingAncestor } from "./root-path-existing.js";
@@ -22,9 +23,6 @@ async function canonicalMutationEntryPath(targetPath) {
     const canonicalParent = await resolvePathViaExistingAncestor(path.dirname(targetPath));
     return path.join(canonicalParent, path.basename(targetPath));
 }
-function sameAbsolutePath(left, right) {
-    return path.relative(path.resolve(left), path.resolve(right)) === "";
-}
 function simplePinnedRoute(rootReal, originalPath) {
     // These routes can depend on raw traversal, platform aliases, home expansion,
     // or live native canonicalization. They retain full admission at every step.

package/node_modules/@openclaw/fs-safe/dist/pinned-write-staged.js

@@ -1,4 +1,5 @@
 import { randomUUID } from "node:crypto";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import fsSync, {} from "node:fs";
 import fs, {} from "node:fs/promises";
 import path from "node:path";
@@ -41,6 +42,7 @@ export async function runPinnedStagedWrite(params, parentPath, parentGuard) {
     let failure;
     try {
         params.assertBeforeMutation?.();
+        assertExclusiveCreateLeaf(tempPath);
         handle = params.private
             ? await createFileHandle(tempPath, {
                 private: true, mode: 0o600, assertBeforeMutation: params.assertBeforeMutation,

package/node_modules/@openclaw/fs-safe/dist/pinned-write.js

@@ -1,11 +1,12 @@
 import { syncFileBestEffort } from "./file-sync.js";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { createFileHandle } from "./create.js";
 import { creationAdmissionFromParent } from "./creation-boundary.js";
 import { normalizeMaxBytes } from "./byte-budget.js";
-import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, createNearestExistingDirectoryGuard, inspectDirectoryIdentity } from "./directory-guard.js";
+import { assertAsyncDirectoryGuard, createAsyncDirectoryGuard, inspectDirectoryIdentity } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { syncDirectoryBestEffort } from "./directory-durability.js";
 import { sha256Hex } from "./file-identity.js";
@@ -173,18 +174,17 @@ async function runPinnedWriteFallback(params) {
             phase: "parent",
         }));
     }
-    if (params.mkdir && !parentGuard) {
-        // mkdirPathComponentsWithGuards may resolve the final component through
-        // an in-root symlink (e.g. a skill-bank layout). Use its returned real
-        // path for the subsequent guard and target path so we don't re-check the
-        // original, possibly-symlinked, lexical path and reject it outright.
+    if (!parentGuard) {
+        // Guard the returned real parent; the lexical path may contain an allowed symlink.
         const mkdirParams = {
             rootReal: params.rootPath,
             targetPath: parentPath,
             rootIdentity: params.rootIdentity,
+            createMissing: params.mkdir,
             assertBeforeMutation: params.assertBeforeMutation,
             beforeComponent: async (componentPath) => {
-                await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", componentPath);
+                if (params.mkdir)
+                    await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("mkdir", componentPath);
             },
         };
         parentPath = await mkdirPathComponentsWithGuards(mutationAdmission ? {
@@ -215,9 +215,7 @@ async function runPinnedWriteFallback(params) {
             },
         } : mkdirParams);
     }
-    parentGuard ??= params.mkdir
-        ? await createAsyncDirectoryGuard(parentPath, { bigint: true })
-        : await createNearestExistingDirectoryGuard(params.rootPath, parentPath, { bigint: true });
+    parentGuard ??= await createAsyncDirectoryGuard(parentPath, { bigint: true });
     const targetPath = path.join(parentPath, params.basename);
     if (mutationAdmission && !parentAdmitted) {
         await mutationAdmission.authorize(Object.freeze({
@@ -239,6 +237,7 @@ async function runPinnedWriteFallback(params) {
                     private: true, mode: 0o600, assertBeforeMutation,
                 }, creationAdmissionFromParent(parentGuard));
             }
+            assertExclusiveCreateLeaf(targetPath);
             return await fs.open(targetPath, fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL, verifyPosixMode ? 0o600 : params.mode);
         }, {
             onPostGuardFailure: async (openedHandle) => {

package/node_modules/@openclaw/fs-safe/dist/private-producer-handoff.js

@@ -4,6 +4,7 @@ import { FsSafeError } from "./errors.js";
 import { sameFileIdentityForCleanup } from "./file-identity.js";
 import { assertSynchronousCallbackResult } from "./mutation-authority.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { errorCauseOptions } from "./root-errors.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { registerTempPathForExit, } from "./temp-cleanup.js";
 function pathMismatch(message) {
@@ -36,18 +37,14 @@ export function assertParents(params) {
 export function normalizeLinkError(error) {
     const code = error?.code;
     if (code === "EEXIST") {
-        return new FsSafeError("already-exists", "isolated producer sibling already exists", {
-            cause: error instanceof Error ? error : undefined,
-        });
+        return new FsSafeError("already-exists", "isolated producer sibling already exists", errorCauseOptions(error));
     }
     if (code === "EXDEV" ||
         code === "ENOSYS" ||
         code === "ENOTSUP" ||
         code === "EOPNOTSUPP" ||
         code === "EPERM") {
-        return new FsSafeError("helper-unavailable", "atomic isolated producer handoff is unavailable", {
-            cause: error instanceof Error ? error : undefined,
-        });
+        return new FsSafeError("helper-unavailable", "atomic isolated producer handoff is unavailable", errorCauseOptions(error));
     }
     return error;
 }

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

@@ -3,8 +3,8 @@ 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.
+// Node has no portable no-replace rename. Publish the completed stage by link,
+// then remove its verified temporary name without yielding.
 export function publishCopyStage(params) {
     const { identity, temporaryPath, targetPath } = params;
     const assertCurrent = () => {

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

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import fsSync, {} from "node:fs";
 import fs, {} from "node:fs/promises";
 import path from "node:path";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { pinDirectory, } from "./directory-durability.js";
 import { FsSafeError } from "./errors.js";
 import { ownDirectoryReceipt } from "./directory-receipt.js";
@@ -21,7 +22,6 @@ const NATIVE_COPY_FALLBACK_CODES = new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPN
 export function isHardlinkFallbackError(error) {
     return HARDLINK_FALLBACK_CODES.has(error?.code ?? "");
 }
-function sourceOpenFlags() { return resolveReadOpenFlags(); }
 function directoryOpenFlags() {
     return (fsSync.constants.O_RDONLY |
         (typeof fsSync.constants.O_DIRECTORY === "number" ? fsSync.constants.O_DIRECTORY : 0));
@@ -105,7 +105,7 @@ async function copyPinnedSource(params) {
                 createdIdentity = fsSync.fstatSync(nativeFd, { bigint: true });
                 await getFsSafeTestHooks()?.afterPublishTargetCreated?.("exclusive-copy", params.targetPath, createdIdentity);
                 const identity = fsSync.lstatSync(params.targetPath, { bigint: true });
-                target = await fs.open(params.targetPath, sourceOpenFlags());
+                target = await fs.open(params.targetPath, resolveReadOpenFlags());
                 const opened = fsSync.fstatSync(target.fd, { bigint: true });
                 if (identity.isSymbolicLink() ||
                     !identity.isFile() ||
@@ -134,6 +134,7 @@ async function copyPinnedSource(params) {
             }
         }
     }
+    assertExclusiveCreateLeaf(params.targetPath);
     const target = await fs.open(params.targetPath, "wx+", 0o600);
     try {
         const createdIdentity = fsSync.fstatSync(target.fd, { bigint: true });
@@ -216,7 +217,7 @@ export async function publishFileExclusive(params) {
     if (sourcePathStat.isSymbolicLink() || !sourcePathStat.isFile()) {
         throw new FsSafeError("not-file", "publication source must be a regular file");
     }
-    const source = await fs.open(sourcePath, sourceOpenFlags());
+    const source = await fs.open(sourcePath, resolveReadOpenFlags());
     let parent;
     let sourceNativeParent;
     let targetNativeParent;

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

@@ -1,4 +1,3 @@
-import type syncFs from "node:fs";
-import type { FileHandle } from "node:fs/promises";
-export declare function writeAtomicDestination(handle: FileHandle, data: Buffer, beforeWrite?: () => Promise<void>, assertBeforeMutation?: () => void, onWriting?: () => void): Promise<void>;
-export declare function writeAtomicDestinationSync(fsModule: Pick<typeof syncFs, "ftruncateSync" | "writeSync">, fd: number, data: Buffer, beforeWrite?: () => void, onWriting?: () => void): void;
+import type { AtomicFile, Procedure } from "./atomic-io.js";
+import type { AtomicDestination } from "./replace-file-destination.js";
+export declare function writeAtomicDestination(file: AtomicFile, data: Buffer, destination?: AtomicDestination, restore?: boolean): Procedure<void>;

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

@@ -1,36 +1,22 @@
-export async function writeAtomicDestination(handle, data, beforeWrite, assertBeforeMutation, onWriting) {
-    if (beforeWrite)
-        await beforeWrite();
-    assertBeforeMutation?.();
-    await handle.truncate(0);
-    onWriting?.();
+export function* writeAtomicDestination(file, data, destination, restore = false) {
+    if (destination)
+        yield* destination.beforeWrite(restore);
+    yield* file.truncate(0);
+    destination?.writing();
     let written = 0;
     while (written < data.length) {
-        if (beforeWrite)
-            await beforeWrite();
-        assertBeforeMutation?.();
-        const result = await handle.write(data, written, data.length - written, written);
-        if (result.bytesWritten === 0)
-            throw new Error("Copy fallback write made no progress");
-        written += result.bytesWritten;
+        if (destination)
+            yield* destination.beforeWrite(restore);
+        let result = file.write(data, written, data.length - written, written);
+        if (file.io.asynchronous) {
+            const completed = (yield result);
+            if (completed.bytesWritten === 0)
+                throw new Error("Copy fallback write made no progress");
+            result = completed.bytesWritten;
+        }
+        written += result;
     }
-    if (beforeWrite)
-        await beforeWrite();
-    assertBeforeMutation?.();
-    await handle.truncate(data.length);
-}
-export function writeAtomicDestinationSync(fsModule, fd, data, beforeWrite, onWriting) {
-    beforeWrite?.();
-    fsModule.ftruncateSync(fd, 0);
-    onWriting?.();
-    let written = 0;
-    while (written < data.length) {
-        beforeWrite?.();
-        const bytesWritten = fsModule.writeSync(fd, data, written, data.length - written, written);
-        if (bytesWritten === 0)
-            throw new Error("Copy fallback write made no progress");
-        written += bytesWritten;
-    }
-    beforeWrite?.();
-    fsModule.ftruncateSync(fd, data.length);
+    if (destination)
+        yield* destination.beforeWrite(restore);
+    yield* file.truncate(data.length);
 }

package/node_modules/@openclaw/fs-safe/dist/replace-file-copy-fallback.d.ts

@@ -1,4 +1,5 @@
-import syncFs, { type BigIntStats } from "node:fs";
+import { type BigIntStats } from "node:fs";
+import { type AtomicIo, type Procedure } from "./atomic-io.js";
 import { AtomicMutation } from "./replace-file-mutation.js";
 export type ReplaceFileDestinationHardlinkPolicy = "reject";
 export type ReplaceFileCopyFallbackRestorePolicy = "restore-original" | "none";
@@ -6,16 +7,8 @@ export type ReplaceFileAtomicRestoreCleanup = "restored" | "restore-failed";
 export type ReplaceFileAtomicRestoreFailureDetails = {
     cleanup: ReplaceFileAtomicRestoreCleanup;
 };
-type AsyncFallbackFs = {
-    lstat: typeof import("node:fs/promises").lstat;
-    open: typeof import("node:fs/promises").open;
-    rm: typeof import("node:fs/promises").rm;
-};
-type SyncFallbackFs = Pick<typeof syncFs, "closeSync" | "fstatSync" | "fsyncSync" | "ftruncateSync" | "lstatSync" | "openSync" | "readSync" | "rmSync" | "writeSync">;
-export declare function assertDestinationHardlinkPolicy(fsModule: AsyncFallbackFs, dest: string, policy?: ReplaceFileDestinationHardlinkPolicy): Promise<void>;
-export declare function assertDestinationHardlinkPolicySync(fsModule: SyncFallbackFs, dest: string, policy?: ReplaceFileDestinationHardlinkPolicy): void;
-export declare function copyFallbackReplace(params: {
-    fsModule: AsyncFallbackFs;
+export declare function assertDestinationHardlinkPolicy(io: AtomicIo, dest: string, policy?: ReplaceFileDestinationHardlinkPolicy): Procedure<void>;
+export declare function copyFallbackReplace(io: AtomicIo, params: {
     src: string;
     dest: string;
     destinationHardlinks?: ReplaceFileDestinationHardlinkPolicy;
@@ -24,9 +17,4 @@ export declare function copyFallbackReplace(params: {
     expectedSourceIdentity?: BigIntStats;
     sync: boolean;
     mutation?: AtomicMutation;
-}): Promise<void>;
-export declare function copyFallbackReplaceSync(params: Omit<Parameters<typeof copyFallbackReplace>[0], "fsModule"> & {
-    fsModule: SyncFallbackFs;
-    fchmodSync?: (fd: number, mode: number) => void;
-}): void;
-export {};
+}): Procedure<void>;