@openclaw/matrix 2026.10.1-beta.2 → 2026.10.1

package/node_modules/@openclaw/fs-safe/CHANGELOG.md

@@ -2,6 +2,62 @@
 
 ## Unreleased
 
+## 0.24.2 - 2026-10-07
+
+### Fixes
+
+- **Linux exclusive publication:** `publishFileExclusive` with `rename-noreplace` uses the identity-checked link/unlink move fallback in native `auto` when `RENAME_NOREPLACE` is unsupported, consumes the source on success, and reports `fallback: "link-unlink"` plus precise partial-failure receipts; native `require` stays fail-closed. Link/unlink is not crash-atomic. ([#843](https://github.com/openclaw/fs-safe/pull/843), [openclaw#166246](https://github.com/openclaw/openclaw/issues/166246)) Thanks @MertBasar0.
+- **Native clone descriptors:** native file copies return read-write descriptors, so Linux clones can be read immediately and macOS clones can be written while preserving read-only source modes. ([#844](https://github.com/openclaw/fs-safe/pull/844))
+
+## 0.24.1 - 2026-10-06
+
+### Features
+
+- **Pinned source copies:** `copyRootFileSync` accepts `expectedSourceIdentity` to reject a replaced source before destination creation and returns the verified `sourceIdentity` for every copy method. This refines the `copyRootFileSync` API introduced in 0.24.0. ([#841](https://github.com/openclaw/fs-safe/pull/841))
+
+## 0.24.0 - 2026-10-06
+
+### Highlights
+
+- **No-replace moves on more Linux filesystems:** when filesystems reject `renameat2` with `RENAME_NOREPLACE`, including reported QNAP ZFS shares and some overlay mounts, `auto` falls back safely: directories use plain rename that can at most replace an empty directory, and files use identity-checked link/unlink that cannot overwrite a target. Native `require` fails closed. ([#838](https://github.com/openclaw/fs-safe/pull/838), fixes [openclaw#165617](https://github.com/openclaw/openclaw/issues/165617)) Thanks @StarGazer1995, original reporter @bbs2i58, and @MertBasar0.
+- **Synchronous guarded copies:** new `copyRootFileSync` on `advanced` supports APFS cloning, reflinks, `copy_file_range`, and guarded byte fallback, returning an owned destination descriptor for synchronous capture hashes. ([#839](https://github.com/openclaw/fs-safe/pull/839))
+- **Public capability classification:** new `isNoReplaceUnsupported(error)` identifies unavailable no-replace rename support without matching internal native error codes. ([#838](https://github.com/openclaw/fs-safe/pull/838))
+
+### Features
+
+- **Synchronous root-to-root copy:** `copyRootFileSync` exclusively creates an absent destination under its admitted root, bounds the copy with `maxBytes`, verifies source and destination identities, and returns a disposable descriptor with copy-method and byte-count receipts. ([#839](https://github.com/openclaw/fs-safe/pull/839))
+- **No-replace error classifier:** export `isNoReplaceUnsupported(error)` from the root package and `errors` subpath for stable `helper-unavailable` capability diagnostics. ([#838](https://github.com/openclaw/fs-safe/pull/838))
+
+### Fixes
+
+- **Linux no-replace moves:** `Root.move()` uses retained-parent file link/unlink or directory rename when `RENAME_NOREPLACE` is unsupported in `auto`, rejects file collisions, and preserves publication/source-removal details after partial failures. ([#838](https://github.com/openclaw/fs-safe/pull/838)) Thanks @StarGazer1995, @bbs2i58, and @MertBasar0.
+
+### Performance
+
+- **Synchronous copy acceleration:** reuse the native bounded copy engine for APFS clones, Linux reflinks, and `copy_file_range` before byte copying when `copyRootFileSync` is called with `clone: "auto"`. ([#839](https://github.com/openclaw/fs-safe/pull/839))
+
+### Compatibility
+
+- **Move fallback limits:** native `require` keeps refusing unsupported no-replace moves. In `auto`, the directory fallback can replace a concurrently created empty directory; nonempty directories and non-directory competitors reject. File fallback requires hard-link support and fails closed if links are denied or unsupported. ([#838](https://github.com/openclaw/fs-safe/pull/838))
+- **Synchronous copy contract:** `copyRootFileSync` defaults to `clone: "never"`, requires existing parents and an absent destination, and performs direct exclusive creation. Use a private capture directory; it does not promise atomic publication, crash durability, or a coherent snapshot of concurrent in-place edits. ([#839](https://github.com/openclaw/fs-safe/pull/839))
+
+## 0.23.1 - 2026-10-04
+
+### Highlights
+
+- **gVisor and 9p file creation:** `create()` and other no-replace publication fall back in `auto` mode on filesystems that reject `renameat2` with `RENAME_NOREPLACE`; `require` mode fails closed. ([#834](https://github.com/openclaw/fs-safe/pull/834), fixes [#828](https://github.com/openclaw/fs-safe/issues/828)) Thanks @vishnukool.
+- **Container copy compatibility:** seccomp or LSM policies denying `FICLONE` no longer break `clone: "auto"` copies, for both single files and `copyTree`. ([#829](https://github.com/openclaw/fs-safe/pull/829), [#835](https://github.com/openclaw/fs-safe/pull/835)) Thanks @Mohl, with co-author credit to @foxsky.
+- **macOS watching:** a FIFO at a watched name no longer freezes watching across the process. ([#830](https://github.com/openclaw/fs-safe/pull/830)) Thanks @SebTardif.
+
+### Fixes
+
+- **gVisor file creation:** fall back safely when the filesystem rejects native no-replace publication, clean unpublished stages, and report the missing capability in native-required mode. ([#834](https://github.com/openclaw/fs-safe/pull/834)) Thanks @vishnukool.
+- **ZIP collision checks:** reject directory and file names that differ only by case, Unicode normalization, or a trailing separator before extraction or bounded reads. ([#832](https://github.com/openclaw/fs-safe/pull/832)) Thanks @SebTardif.
+- **macOS entry watch:** prevent a FIFO at a watched name from blocking every watcher in the process. ([#830](https://github.com/openclaw/fs-safe/pull/830)) Thanks @SebTardif.
+- **Disk-full diagnostics:** preserve disk-full (`ENOSPC`) diagnostics and cleanup receipts through combined write and disposal failures instead of reporting a misleading file-type error. ([#833](https://github.com/openclaw/fs-safe/pull/833)) Thanks @steipete.
+- **Linux clone fallback:** copies with `clone: "auto"` fall back to guarded byte copying when container seccomp or LSM policy denies `FICLONE`; `clone: "always"` reports `unsupported-platform` and removes its stage. ([#829](https://github.com/openclaw/fs-safe/pull/829)) Thanks @Mohl, with co-author credit to @foxsky.
+- **Linux tree clone fallback:** `copyTree` with `clone: "auto"` copies bytes when XFS/ZFS file reflinks are unavailable or denied by container policy; `"always"` reports `unsupported-platform` after partial-tree cleanup. ([#835](https://github.com/openclaw/fs-safe/pull/835)) Thanks @steipete.
+
 ## 0.23.0 - 2026-10-02
 
 ### Highlights

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

@@ -1,3 +1,4 @@
+export { copyRootFileSync, type CopyRootFileSyncOptions, type CopiedRootFileSync } from "./copy-root-file-sync.js";
 export { createAsyncLock } from "./async-lock.js";
 export { createDirectory, createDirectorySync, createFileSync, type CreateDirectoryOptions, type CreateFileOptions, type OwnedFileDescriptorSync, } from "./create.js";
 export { copyFileHandle, copyFileDescriptorSync, type CopyFileHandleOptions } from "./file-handle-transfer.js";

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

@@ -1,3 +1,4 @@
+export { copyRootFileSync } from "./copy-root-file-sync.js";
 // Advanced composition surface. These exports are less stable than the focused
 // public subpaths; prefer root/json/store/temp/archive unless you are building a
 // higher-level primitive.

package/node_modules/@openclaw/fs-safe/dist/archive-entry.js

@@ -63,13 +63,17 @@ export function stripArchivePath(entryPath, stripComponents) {
 export function createArchiveOutputPathTracker() {
     const seen = new Set();
     return (entryPath, originalPath) => {
-        const normalized = path.posix.normalize(normalizeArchiveEntryPath(entryPath));
+        // Extraction passes stripArchivePath output. Native manifests and physical
+        // admission pass raw names, and path.posix.normalize keeps a directory's
+        // trailing slash, so "A/" and "a" would not share a key.
+        const canonical = stripArchivePath(entryPath, 0)
+            ?? path.posix.normalize(normalizeArchiveEntryPath(entryPath));
         // Archive policy must not depend on the destination volume's case or
         // Unicode-normalization behavior. Otherwise the JavaScript and native
         // writers can disagree about which of two colliding entries wins.
-        const collisionKey = lowerCaseNfc(normalized);
+        const collisionKey = lowerCaseNfc(canonical);
         if (seen.has(collisionKey)) {
-            throw new ArchiveSecurityError("entry-path", `archive entries collide at output path ${formatErrorDetail(normalized)}: ${formatErrorDetail(originalPath)}`);
+            throw new ArchiveSecurityError("entry-path", `archive entries collide at output path ${formatErrorDetail(canonical)}: ${formatErrorDetail(originalPath)}`);
         }
         seen.add(collisionKey);
     };

package/node_modules/@openclaw/fs-safe/dist/copy-root-file-sync.d.ts

@@ -0,0 +1,35 @@
+import { type CopyCloneMode } from "./copy-policy.js";
+import { type OwnedFileDescriptorSync } from "./create-owned-file.js";
+type CopyPath = {
+    rootPath: string;
+    absolutePath: string;
+};
+export type CopyRootFileSyncOptions = {
+    source: CopyPath;
+    destination: CopyPath;
+    expectedSourceIdentity?: {
+        dev: bigint;
+        ino: bigint;
+    };
+    clone?: CopyCloneMode;
+    maxBytes?: number;
+    mode?: number;
+    preserveSourceMode?: boolean;
+    sourceHardlinks?: "reject" | "allow";
+};
+export type CopiedRootFileSync = OwnedFileDescriptorSync & Readonly<{
+    path: string;
+    bytes: number;
+    method: "clone" | "copy-file-range" | "copy";
+    identity: Readonly<{
+        dev: bigint;
+        ino: bigint;
+    }>;
+    sourceIdentity: Readonly<{
+        dev: bigint;
+        ino: bigint;
+    }>;
+}>;
+/** Exclusively copies an admitted source and transfers the owned destination fd. */
+export declare function copyRootFileSync(options: CopyRootFileSyncOptions): CopiedRootFileSync;
+export {};

package/node_modules/@openclaw/fs-safe/dist/copy-root-file-sync.js

@@ -0,0 +1,218 @@
+import fs, {} from "node:fs";
+import path from "node:path";
+import { normalizeMaxBytes } from "./byte-budget.js";
+import { resolveCopyCloneMode } from "./copy-policy.js";
+import { createFileWithAdmissionSync } from "./create.js";
+import { ownFileDescriptorSync } from "./create-owned-file.js";
+import { creationAdmissionFromParent, removeRecordedCreationFileSync } from "./creation-boundary.js";
+import { assertSyncDirectoryGuard, captureDirectoryGuard } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
+import { copyFileDescriptorSync } from "./file-handle-transfer.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { getNativeBinding } from "./native.js";
+import { realpathSync } from "./realpath.js";
+import { openRootFileSync } from "./root-file.js";
+import { resolveRootPathSync, ROOT_PATH_ALIAS_POLICIES } from "./root-path.js";
+import { inspectOpenedPathIdentitySync } from "./root-read-admission.js";
+import { openStagedDirectory } from "./staged-directory.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+function copyError(error) {
+    if (error instanceof FsSafeError)
+        return error;
+    const code = error?.code;
+    return new FsSafeError(code === "EEXIST" ? "already-exists" : code === "ENOENT" ? "not-found" :
+        code === "too-large" ? "too-large" :
+            ["ENOTSUP", "EOPNOTSUPP", "ENOSYS", "EXDEV", "EINVAL"].includes(code ?? "")
+                ? "unsupported-platform" : "helper-failed", "guarded synchronous file copy failed", { cause: error });
+}
+function admitCopyPath(input, create = false) {
+    if (!path.isAbsolute(input.rootPath) || !path.isAbsolute(input.absolutePath)) {
+        throw new FsSafeError("invalid-path", "copy roots and paths must be absolute");
+    }
+    const root = captureDirectoryGuard(realpathSync(input.rootPath), "native", { bigint: true });
+    const resolve = () => {
+        const parent = create ? resolveRootPathSync({
+            ...input, absolutePath: path.dirname(input.absolutePath), boundaryLabel: "copy parent",
+            rejectSymlinks: true, rejectFinalSymlink: true,
+        }) : undefined;
+        const selected = resolveRootPathSync({
+            ...input, boundaryLabel: "copy", rejectSymlinks: !create, rejectFinalSymlink: !create,
+            policy: create ? ROOT_PATH_ALIAS_POLICIES.unlinkTarget : undefined,
+        });
+        if (parent && path.dirname(selected.canonicalPath) !== parent.canonicalPath) {
+            throw new FsSafeError("path-mismatch", "copy destination parent changed");
+        }
+        return selected;
+    };
+    const selected = resolve();
+    const parent = captureDirectoryGuard(path.dirname(selected.canonicalPath), "native", { bigint: true });
+    const assertCurrent = () => {
+        assertSyncDirectoryGuard(root);
+        assertSyncDirectoryGuard(parent);
+        const current = resolve();
+        if (current.rootCanonicalPath !== root.realPath || current.canonicalPath !== selected.canonicalPath) {
+            throw new FsSafeError("path-mismatch", "copy path changed during operation");
+        }
+        assertSyncDirectoryGuard(root);
+        assertSyncDirectoryGuard(parent);
+    };
+    assertCurrent();
+    return { path: selected.canonicalPath, parent, assertCurrent };
+}
+/** Exclusively copies an admitted source and transfers the owned destination fd. */
+export function copyRootFileSync(options) {
+    // Snapshot caller options before the first filesystem observation.
+    const sourceInput = options.source;
+    const sourcePath = { rootPath: sourceInput.rootPath, absolutePath: sourceInput.absolutePath };
+    const targetInput = options.destination;
+    const targetPath = { rootPath: targetInput.rootPath, absolutePath: targetInput.absolutePath };
+    const expectedInput = options.expectedSourceIdentity;
+    const expectedSourceIdentity = expectedInput === undefined ? undefined : { dev: expectedInput.dev, ino: expectedInput.ino };
+    const clone = resolveCopyCloneMode(options.clone, "never");
+    const maxBytes = normalizeMaxBytes(options.maxBytes);
+    const mode = options.mode;
+    const preserveSourceMode = options.preserveSourceMode;
+    const sourceHardlinks = options.sourceHardlinks ?? "reject";
+    if (mode !== undefined && (!Number.isInteger(mode) || mode < 0 || mode > 0o777)) {
+        throw new FsSafeError("invalid-path", "copy mode must be an integer from 0 to 0o777");
+    }
+    if (sourceHardlinks !== "allow" && sourceHardlinks !== "reject") {
+        throw new FsSafeError("invalid-path", "invalid copy source hardlink policy");
+    }
+    let sourceOwner;
+    let targetOwner;
+    let parentOwner;
+    let parentOpen = false;
+    let target;
+    let identity;
+    const native = getNativeBinding();
+    const nativeCopy = process.platform !== "win32" && native?.copyFileExclusiveSync && native.removeStagedFile
+        ? native.copyFileExclusiveSync.bind(native) : undefined;
+    let nativeTarget = false;
+    try {
+        const source = admitCopyPath(sourcePath);
+        target = admitCopyPath(targetPath, true);
+        // Preserve exclusive-create collision semantics for dangling Windows leaves.
+        assertExclusiveCreateLeaf(targetPath.absolutePath);
+        if (fs.lstatSync(target.path, { throwIfNoEntry: false })) {
+            throw new FsSafeError("already-exists", "copy destination already exists");
+        }
+        const opened = openRootFileSync({
+            ...sourcePath, boundaryLabel: "copy source", maxBytes,
+            rejectHardlinks: sourceHardlinks !== "allow",
+        });
+        if (!opened.ok)
+            throw opened.error ?? new FsSafeError("helper-failed", "copy source admission failed");
+        sourceOwner = ownFileDescriptorSync(opened.fd);
+        const sourceIdentity = inspectFileIdentitySync(() => fs.fstatSync(opened.fd, { bigint: true }), expectedSourceIdentity);
+        const verifySource = () => {
+            source.assertCurrent();
+            for (const inspect of [
+                () => fs.fstatSync(opened.fd, { bigint: true }),
+                () => inspectOpenedPathIdentitySync(source.path, undefined),
+            ]) {
+                const current = inspectFileIdentitySync(inspect, sourceIdentity);
+                if (!current.isFile())
+                    throw new FsSafeError("not-file", "copy source must be a regular file");
+                if (sourceHardlinks !== "allow" && current.nlink > 1n) {
+                    throw new FsSafeError("hardlink", "copy source must not be hardlinked");
+                }
+            }
+        };
+        const selectedMode = mode ?? (preserveSourceMode ? Number(sourceIdentity.mode & 511n) : 0o600 & ~process.umask());
+        let method = "copy";
+        let copied;
+        verifySource();
+        target.assertCurrent();
+        if (nativeCopy) {
+            const closeNative = captureNativeFdClose(native);
+            const parent = openStagedDirectory(target.parent.realPath);
+            parentOwner = ownFileDescriptorSync(parent.fd);
+            parentOpen = true;
+            inspectFileIdentitySync(() => fs.fstatSync(parent.fd, { bigint: true }), { dev: BigInt(target.parent.stat.dev), ino: BigInt(target.parent.stat.ino) });
+            target.assertCurrent();
+            copied = nativeCopy(opened.fd, parent.fd, path.basename(target.path), clone, maxBytes !== undefined && Number.isFinite(maxBytes) ? maxBytes : undefined);
+            targetOwner = ownFileDescriptorSync(copied.fd, closeNative);
+            nativeTarget = true;
+        }
+        else {
+            if (clone === "always")
+                throw new FsSafeError("unsupported-platform", "synchronous native file cloning is unavailable");
+            targetOwner = createFileWithAdmissionSync(target.path, { mode: 0o600, assertBeforeMutation: target.assertCurrent }, creationAdmissionFromParent(target.parent));
+        }
+        identity = inspectFileIdentitySync(() => fs.fstatSync(targetOwner.fd, { bigint: true }));
+        const verifyTarget = () => {
+            target.assertCurrent();
+            const current = inspectFileIdentitySync(() => fs.fstatSync(targetOwner.fd, { bigint: true }), identity);
+            const named = inspectFileIdentitySync(() => inspectOpenedPathIdentitySync(target.path, undefined), identity);
+            if (!current.isFile() || current.nlink !== 1n || !named.isFile() || named.nlink !== 1n) {
+                throw new FsSafeError("path-mismatch", "copy destination changed");
+            }
+            return current;
+        };
+        verifyTarget();
+        if (copied?.errorCode) {
+            throw copyError(Object.assign(new Error(copied.errorMessage), { code: copied.errorCode }));
+        }
+        if (copied) {
+            if (!["clone", "copy-file-range", "copy"].includes(copied.method)) {
+                throw new FsSafeError("helper-failed", "native copy returned an unknown method");
+            }
+            method = copied.method;
+        }
+        else {
+            copyFileDescriptorSync(opened.fd, targetOwner.fd, { maxBytes });
+        }
+        verifySource();
+        const completed = verifyTarget();
+        if (maxBytes !== undefined && Number.isFinite(maxBytes) && completed.size > BigInt(maxBytes)) {
+            throw new FsSafeError("too-large", "copy exceeds maxBytes");
+        }
+        fs.fchmodSync(targetOwner.fd, selectedMode);
+        verifySource();
+        verifyTarget();
+        sourceOwner.close();
+        parentOpen = false;
+        parentOwner?.close();
+        return Object.freeze({
+            ...targetOwner, path: target.path, bytes: Number(completed.size), method,
+            identity: Object.freeze({ dev: identity.dev, ino: identity.ino }),
+            sourceIdentity: Object.freeze({ dev: sourceIdentity.dev, ino: sourceIdentity.ino }),
+        });
+    }
+    catch (error) {
+        const primary = copyError(error);
+        const cleanup = [];
+        if (targetOwner && target) {
+            try {
+                if (nativeTarget && parentOpen) {
+                    const removed = native.removeStagedFile(parentOwner.fd, path.basename(target.path), targetOwner.fd);
+                    if (removed === "preserved")
+                        throw new FsSafeError("path-mismatch", "copy cleanup preserved a replacement");
+                }
+                else if (identity) {
+                    removeRecordedCreationFileSync(target.path, identity, target.assertCurrent);
+                }
+            }
+            catch (failure) {
+                cleanup.push(failure);
+            }
+        }
+        for (const owner of [targetOwner, sourceOwner, parentOwner]) {
+            try {
+                owner?.close();
+            }
+            catch (failure) {
+                cleanup.push(failure);
+            }
+        }
+        if (cleanup.length) {
+            throw new FsSafeError(primary.code, primary.message, {
+                cause: new AggregateError([primary, ...cleanup], "copy and cleanup failed"),
+                details: { path: target?.path, cleanup: "failed" },
+            });
+        }
+        throw primary;
+    }
+}

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

@@ -4,6 +4,7 @@ import { type CreationPermissions, type CreationParentIdentity } from "./creatio
 export type { OwnedFileDescriptorSync } from "./create-owned-file.js";
 export type CreateFileOptions = CreateDirectoryOptions;
 export declare function createFileSync(targetPath: string, options?: CreateFileOptions): OwnedFileDescriptorSync;
+export declare function createFileWithAdmissionSync(targetPath: string, options?: CreateFileOptions, admission?: CreationAdmission): OwnedFileDescriptorSync;
 /** Internal async writer; Windows preparation uses the nonblocking stage owner. */
 export declare function createFileHandle(targetPath: string, options?: CreateFileOptions, admission?: CreationAdmission): Promise<FileHandle>;
 export type CreateDirectoryOptions = CreationPermissions & {

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

@@ -108,9 +108,12 @@ function createPrivateWindowsFile(selected, options, mode) {
     }
 }
 export function createFileSync(targetPath, options = {}) {
+    return createFileWithAdmissionSync(targetPath, options);
+}
+export function createFileWithAdmissionSync(targetPath, options = {}, admission = {}) {
     const permissions = resolveCreationPermissions(options, false);
     const assertion = options.assertBeforeMutation;
-    const selected = prepareCreationPath(targetPath);
+    const selected = prepareCreationPath(targetPath, admission.expectedParentIdentity);
     if (permissions.private && process.platform === "win32") {
         assertPrivateFileCreationAvailable();
         return createPrivateWindowsFile(selected, { ...permissions, assertBeforeMutation: assertion }, permissions.mode);

package/node_modules/@openclaw/fs-safe/dist/entry-publication.js

@@ -2,6 +2,7 @@ import fs, {} from "node:fs";
 import path from "node:path";
 import { assertDirectoryIdentitySync } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
+import { noReplaceUnavailable } from "./native-noreplace.js";
 import { assertSynchronousCallbackResult } from "./mutation-authority.js";
 import { captureNativeFdClose } from "./native-binding.js";
 import { requireNativeBinding } from "./native.js";
@@ -120,7 +121,8 @@ class Publication {
             }
             transition = native.outcome; // Capture BEFORE diagnostics, observations or close.
             if (native.errorCode || transition !== "committed") {
-                throw Object.assign(new Error(native.errorMessage ?? "entry publication did not commit"), { code: native.errorCode ?? "helper-failed" });
+                const error = Object.assign(new Error(native.errorMessage ?? "entry publication did not commit"), { code: native.errorCode ?? "helper-failed" });
+                throw noReplaceUnavailable(error, "retained entry publication") ?? error;
             }
             phase = "postcheck";
             verification = "failed";

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

@@ -12,4 +12,6 @@ export declare class FsSafeError extends Error {
         details?: FsSafeErrorDetails;
     });
 }
+/** A rejected no-replace rename capability, not a generic missing native helper. */
+export declare function isNoReplaceUnsupported(error: unknown): error is FsSafeError;
 export {};

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

@@ -25,3 +25,8 @@ export class FsSafeError extends Error {
         this.details = options.details;
     }
 }
+/** A rejected no-replace rename capability, not a generic missing native helper. */
+export function isNoReplaceUnsupported(error) {
+    return error instanceof FsSafeError && error.code === "helper-unavailable" &&
+        error.details?.capability === "rename-noreplace";
+}

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

@@ -1,4 +1,4 @@
-export { FsSafeError, categorizeFsSafeError, } from "./errors.js";
+export { FsSafeError, categorizeFsSafeError, isNoReplaceUnsupported, } from "./errors.js";
 export type * from "./errors.js";
 export { DEFAULT_ROOT_MAX_BYTES, root, type Root, } from "./root.js";
 export type * from "./root-public-types.js";

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

@@ -1,4 +1,4 @@
-export { FsSafeError, categorizeFsSafeError, } from "./errors.js";
+export { FsSafeError, categorizeFsSafeError, isNoReplaceUnsupported, } from "./errors.js";
 export { DEFAULT_ROOT_MAX_BYTES, root, } from "./root.js";
 export { configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
 export { writeExternalFileWithinRoot, } from "./output.js";

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

@@ -203,6 +203,7 @@ export interface NativeBinding {
     stagedFileMatches?(parentFd: number, basename: string, fileFd: number): boolean;
     removeStagedFile?(parentFd: number, basename: string, fileFd: number): "removed" | "name-absent" | "preserved";
     copyFileExclusive?(sourceFd: number, parentFd: number, basename: string, clone: CopyCloneMode, maxBytes: number | undefined, signal: AbortSignal | undefined): Promise<NativeFileCopyResult>;
+    copyFileExclusiveSync?(sourceFd: number, parentFd: number, basename: string, clone: CopyCloneMode, maxBytes: number | undefined): NativeFileCopyResult;
     cloneFileExclusive(sourceFd: number, targetRootFd: number, targetRelPath: string): number;
     copyFileRangeExclusive(sourceFd: number, targetRootFd: number, targetRelPath: string): Promise<NativeCopyResult>;
     createPrivateDirectory(path: string): void;
@@ -235,6 +236,8 @@ export interface NativeBinding {
     entryPublicationFilesystem?(parentFd: number): string;
     publishRetainedEntryNoReplace?(sourceParentFd: number, sourceBasename: string, sourceFd: number, targetParentFd: number, targetBasename: string): NativePublicationTransition;
     renameNoReplace(...args: NativeTwoPathArgs): void;
+    /** Linux auto-mode fallback through already-admitted direct-child parents. */
+    moveNoReplaceFallback?(...args: [...paths: NativeTwoPathArgs, expectedSourceDev: bigint, expectedSourceIno: bigint]): void;
     /** Identity-fenced retained-directory rename capability. */
     renameNoReplaceWithIdentity?(...args: [...paths: NativeTwoPathArgs, expectedSourceDev: bigint, expectedSourceIno: bigint]): void;
     renameReplace(...args: NativeTwoPathArgs): void;

package/node_modules/@openclaw/fs-safe/dist/native-move-fallback.d.ts

@@ -0,0 +1,3 @@
+import type { BigIntStats } from "node:fs";
+import type { NativeBinding } from "./native-binding.js";
+export declare function nativeMoveNoReplace(binding: NativeBinding, paths: Parameters<NativeBinding["renameNoReplace"]>, expected: BigIntStats | undefined, allowFallback: boolean, operation?: string): "link-unlink" | undefined;

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

@@ -0,0 +1,54 @@
+import { FsSafeError } from "./errors.js";
+import { cachedNoReplaceUnavailable, noReplaceUnavailable, rememberNoReplaceUnavailable, } from "./native-noreplace.js";
+function fallbackError(error, operation) {
+    const code = error?.code;
+    const message = error instanceof Error ? error.message : "native no-replace move fallback failed";
+    if (code === "EEXIST") {
+        return new FsSafeError("already-exists", "no-replace fallback destination exists", { cause: error });
+    }
+    if (code === "FS_SAFE_INTERNAL_MOVE_LINK_UNSUPPORTED") {
+        return new FsSafeError("helper-unavailable", message, { cause: error,
+            details: { capability: "rename-noreplace", fallback: "link-unlink", fallbackCapability: "linkat" } });
+    }
+    const sourceRemoval = new Map([
+        ["FS_SAFE_INTERNAL_MOVE_LINK_CHANGED", "not-attempted"],
+        ["FS_SAFE_INTERNAL_MOVE_SOURCE_LINKED", "still-linked"],
+        ["FS_SAFE_INTERNAL_MOVE_UNLINK_UNVERIFIED", "unverified"],
+        ["FS_SAFE_INTERNAL_MOVE_PUBLISHED", "removed"],
+    ]).get(code ?? "");
+    if (sourceRemoval) {
+        return new FsSafeError(code === "FS_SAFE_INTERNAL_MOVE_LINK_CHANGED" ? "path-mismatch" : "helper-failed", message, { cause: error, details: { operation, fallback: "link-unlink",
+                publication: "published", sourceRemoval } });
+    }
+    // Keep identity errors available to the caller's normalizer.
+    return error;
+}
+export function nativeMoveNoReplace(binding, paths, expected, allowFallback, operation = "move") {
+    const [sourceFd, source, targetFd, target] = paths;
+    let unavailable = cachedNoReplaceUnavailable(binding, sourceFd, operation);
+    if (!unavailable) {
+        try {
+            binding.renameNoReplace(...paths);
+            return;
+        }
+        catch (error) {
+            unavailable = noReplaceUnavailable(error, operation, true);
+            if (!unavailable)
+                throw error;
+            // As in sibling publication/quarantine, distinct sibling names cannot
+            // have a directory-ancestry EINVAL. Cross-parent moves must not cache it.
+            if (sourceFd === targetFd && source !== target) {
+                rememberNoReplaceUnavailable(binding, sourceFd, unavailable);
+            }
+        }
+    }
+    if (!allowFallback || process.platform !== "linux" || !binding.moveNoReplaceFallback || !expected)
+        throw unavailable;
+    try {
+        binding.moveNoReplaceFallback(...paths, expected.dev, expected.ino);
+        return expected.isFile() ? "link-unlink" : undefined;
+    }
+    catch (error) {
+        throw fallbackError(error, operation);
+    }
+}

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

@@ -0,0 +1,8 @@
+import { FsSafeError } from "./errors.js";
+import type { NativeBinding } from "./native-binding.js";
+export declare const NATIVE_NOREPLACE_UNSUPPORTED = "FS_SAFE_INTERNAL_RENAME_NOREPLACE_UNSUPPORTED";
+export declare function isNoReplaceUnavailable(error: unknown): error is FsSafeError;
+export declare function noReplaceUnavailable(error: unknown, operation: string, syscallOnly?: boolean): FsSafeError | undefined;
+export declare function rememberNoReplaceUnavailable(binding: NativeBinding, parentFd: number, error: FsSafeError): void;
+export declare function cachedNoReplaceUnavailable(binding: NativeBinding, parentFd: number, operation?: string): FsSafeError | undefined;
+export declare function cachedNoReplaceDevice(binding: NativeBinding, device: bigint, operation: string): FsSafeError | undefined;

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

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import { FsSafeError } from "./errors.js";
+export const NATIVE_NOREPLACE_UNSUPPORTED = "FS_SAFE_INTERNAL_RENAME_NOREPLACE_UNSUPPORTED";
+const unsupported = new WeakMap();
+const capabilityErrors = new WeakMap();
+const MAX_DEVICES = 128;
+function unavailable(operation, detail, cause) {
+    const error = new FsSafeError("helper-unavailable", `native no-replace ${operation} is unsupported on this filesystem (${detail})`, { cause, details: { capability: "rename-noreplace" } });
+    capabilityErrors.set(error, detail);
+    return error;
+}
+export function isNoReplaceUnavailable(error) {
+    return error instanceof FsSafeError && capabilityErrors.has(error);
+}
+export function noReplaceUnavailable(error, operation, syscallOnly = false) {
+    try {
+        const code = error?.code;
+        if (code !== NATIVE_NOREPLACE_UNSUPPORTED &&
+            !(syscallOnly && ["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP"].includes(code ?? "")))
+            return;
+        const capability = process.platform === "darwin" ? "renameatx_np RENAME_EXCL"
+            : process.platform === "win32" ? "native no-replace rename" : "renameat2 RENAME_NOREPLACE";
+        const detail = code === NATIVE_NOREPLACE_UNSUPPORTED
+            ? error.message : `${capability}: ${code}`;
+        return unavailable(operation, detail, error);
+    }
+    catch {
+        // Diagnostic getters do not establish non-publication.
+        return;
+    }
+}
+export function rememberNoReplaceUnavailable(binding, parentFd, error) {
+    const detail = capabilityErrors.get(error);
+    if (!detail)
+        return;
+    const device = fs.fstatSync(parentFd, { bigint: true }).dev;
+    let devices = unsupported.get(binding);
+    if (!devices)
+        unsupported.set(binding, devices = new Map());
+    if (!devices.has(device) && devices.size >= MAX_DEVICES)
+        devices.delete(devices.keys().next().value);
+    devices.set(device, detail);
+}
+export function cachedNoReplaceUnavailable(binding, parentFd, operation = "publication") {
+    if (!unsupported.has(binding))
+        return;
+    return cachedNoReplaceDevice(binding, fs.fstatSync(parentFd, { bigint: true }).dev, operation);
+}
+export function cachedNoReplaceDevice(binding, device, operation) {
+    const devices = unsupported.get(binding);
+    if (!devices)
+        return;
+    const detail = devices.get(device);
+    return detail ? unavailable(operation, detail) : undefined;
+}

package/node_modules/@openclaw/fs-safe/dist/native-pinned-write.d.ts

@@ -1,4 +1,4 @@
 import type { FileIdentityStat } from "./file-identity.js";
 import type { NativeBinding } from "./native.js";
 import type { PinnedWriteParams } from "./pinned-write-types.js";
-export declare function runPinnedWriteNative(binding: NativeBinding, params: PinnedWriteParams): Promise<FileIdentityStat>;
+export declare function runPinnedWriteNative(binding: NativeBinding, params: PinnedWriteParams, fallback: (input: PinnedWriteParams["input"]) => Promise<FileIdentityStat>): Promise<FileIdentityStat>;

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

@@ -57,7 +57,9 @@ import { capturePolicyAwareNativeParent } from "./native-policy-parent.js";
 import { openNativeParentAdmission, openNativeRootAdmission } from "./native-parent-admission.js";
 import { assertNativeStaging, writeNativeStage } from "./native-staged-file.js";
 import { captureNativeFdClose } from "./native-binding.js";
-export async function runPinnedWriteNative(binding, params) {
+import { cachedNoReplaceUnavailable } from "./native-noreplace.js";
+import { isFsSafeNativeRequired } from "./native-config.js";
+export async function runPinnedWriteNative(binding, params, fallback) {
     const env_1 = { stack: [], error: void 0, hasError: false };
     try {
         const closeFd = captureNativeFdClose(binding);
@@ -126,9 +128,17 @@ export async function runPinnedWriteNative(binding, params) {
                 windowsOwnsDirectories = true;
                 return await runPinnedWriteWindows(binding, params, root, parentFd, verificationGuard);
             }
+            if (params.overwrite === false && !(params.input.kind === "buffer" && params.input.stageBeforePublish === false)) {
+                const unavailable = cachedNoReplaceUnavailable(binding, parentFd);
+                if (unavailable) {
+                    if (isFsSafeNativeRequired() || (params.input.kind === "file" && params.input.clone === "always"))
+                        throw unavailable;
+                    return await fallback(params.input);
+                }
+            }
             const ownedParent = parentFd;
             parentFd = undefined;
-            return await writeNativeStage(binding, ownedParent, closeFd, directory, params, verificationGuard);
+            return await writeNativeStage(binding, ownedParent, closeFd, directory, params, verificationGuard, fallback);
         }
         catch (error) {
             admissionFailure = { error };

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

@@ -1,7 +1,9 @@
+import { NATIVE_NOREPLACE_UNSUPPORTED } from "./native-noreplace.js";
 export const NATIVE_RENAME_SOURCE_IDENTITY_MISMATCH = "FS_SAFE_INTERNAL_RENAME_SOURCE_IDENTITY_MISMATCH";
 export function classifyNativeRenameFailure(error) {
     try {
-        if (error?.code === NATIVE_RENAME_SOURCE_IDENTITY_MISMATCH) {
+        const code = error?.code;
+        if (code === NATIVE_RENAME_SOURCE_IDENTITY_MISMATCH || code === NATIVE_NOREPLACE_UNSUPPORTED) {
             return "uncommitted";
         }
     }

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

@@ -25,7 +25,7 @@ declare class NativeStagedFile implements StagedFile {
     #private;
     constructor(owner: NativeStageOwner);
     static create(owner: NativeStageOwner, input: PinnedWriteInput, maxBytes?: number): Promise<NativeStagedFile>;
-    static write(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], params: PinnedWriteParams, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;
+    static write(binding: NativeStagingBinding, parentFd: number, closeParentFd: (fd: number) => void, directory: StagedFileReceipt["directory"], params: PinnedWriteParams, parentGuard: AnyAsyncDirectoryGuard, fallback: (input: PinnedWriteInput) => Promise<FileIdentityStat>): Promise<FileIdentityStat>;
     get receipt(): StagedFileReceipt;
     assertCurrent(): Promise<void>;
     publish(basename: string, options: {