@openclaw/feishu 2026.9.8 → 2026.10.1-beta.2

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-stale-admission.js

@@ -22,7 +22,7 @@ export function handleSyncStaleAdmission(acquisition, params) {
     try {
         rawSnapshot = readSidecarLockRawSnapshotSync(acquisition.lockPath, {
             rejectNonFile: true,
-            onOpenFailure: (error) => {
+            onOpenFailure: () => {
                 lockFileOpenDenied = true;
                 assertUnheld();
             },

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

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { acquireFileLockSyncWithRoot } from "./file-lock-sync-root-acquire.js";
 import { withSyncHeldLockHandle } from "./file-lock-sync-root-held.js";
 import path from "node:path";
@@ -227,6 +228,13 @@ export function acquireFileLockSync(targetPath, options) {
                 const noFollow = process.platform !== "win32" && typeof fs.constants.O_NOFOLLOW === "number"
                     ? fs.constants.O_NOFOLLOW
                     : 0;
+                try {
+                    assertExclusiveCreateLeaf(lockPath);
+                }
+                catch (error) {
+                    exclusiveCreateConflict = error.code === "EEXIST";
+                    throw error;
+                }
                 try {
                     fd = fs.openSync(lockPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_EXCL | noFollow, 0o600);
                 }

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

@@ -12,6 +12,7 @@ import { prepareSecretFileWrite } from "./secret-file.js";
 import { resolveSecureTempRoot } from "./secure-temp-dir.js";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { readRegularFile } from "./regular-file.js";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { errorCauseOptions } from "./root-errors.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export async function ensureParentInRoot(scopedRoot, relativePath, mode) {
@@ -67,6 +68,7 @@ export async function writeStreamToTempSource(params) {
     let handle = null;
     let handleClosedByStream = false;
     try {
+        assertExclusiveCreateLeaf(filePath);
         handle = await fs.open(filePath, "wx", params.mode);
         const writable = handle.createWriteStream();
         writable.once("close", () => {

package/node_modules/@openclaw/fs-safe/dist/file-store-sync-write.js

@@ -8,8 +8,9 @@ import { ensureParentSync, ensureStoreDirectorySync, } from "./file-store-bounda
 import { assertSyncStoreDirectoryReceipt } from "./file-store-sync-directory.js";
 import { isPathInside } from "./path.js";
 import { resolveReadOpenFlags } from "./read-open-flags.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 { errorCauseOptions } from "./root-errors.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
@@ -75,35 +76,36 @@ export function writeFileSyncAtomic(params) {
         });
     }
     const tempPath = path.join(parentGuard.dir, `.fs-safe-${process.pid}-${randomUUID()}.tmp`);
-    const owner = new SyncAtomicTempOwner(tempPath);
+    const io = AtomicIo.sync(fs);
+    const owner = new AtomicTempOwner(tempPath, io);
     let originalFailure;
     try {
         getFsSafeTestHooks()?.beforeFileStoreSyncPrivateWrite?.(filePath);
         assertSyncStoreDirectoryReceipt(parentGuard);
         owner.start();
-        const temp = writeTempFileSync({
-            fsModule: fs, tempPath, content: params.content, mode: params.mode, sync: false,
+        io.fchmodSync = (descriptor, mode) => {
+            try {
+                fs.fchmodSync(descriptor, mode);
+            }
+            catch {
+                // Best-effort on platforms that do not enforce POSIX modes.
+            }
+        };
+        const temp = runSync(writeTempFile(io, {
+            tempPath, content: params.content, mode: params.mode, sync: false,
             onIdentity: owner.onIdentity,
-            fchmodSync: (descriptor, mode) => {
-                try {
-                    fs.fchmodSync(descriptor, mode);
-                }
-                catch {
-                    // Best-effort on platforms that do not enforce POSIX modes.
-                }
-            },
-        });
+        }));
         owner.adopt(temp);
         // Preserve the store's strict fsync errors; the generic temp helper tolerates EPERM.
         if (params.durable)
-            fs.fsyncSync(temp.fd);
-        verifyStoreFile(temp.fd, owner.identity, tempPath);
+            fs.fsyncSync(temp.file.fd);
+        verifyStoreFile(temp.file.fd, owner.identity, tempPath);
         assertSyncStoreDirectoryReceipt(parentGuard);
         fs.renameSync(tempPath, filePath);
         owner.markRenamed();
         assertSyncStoreDirectoryReceipt(parentGuard);
         try {
-            verifyStoreFile(temp.fd, owner.identity, filePath);
+            verifyStoreFile(temp.file.fd, owner.identity, filePath);
         }
         catch (error) {
             if (error instanceof FsSafeError) {
@@ -123,6 +125,6 @@ export function writeFileSyncAtomic(params) {
         throw error;
     }
     finally {
-        owner.finish({ fsModule: fs, originalFailure, throwOnCleanupError: false });
+        runSync(owner.finish({ originalFailure, throwOnCleanupError: false }));
     }
 }

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

@@ -8,7 +8,7 @@ import { writeFileSyncAtomic } from "./file-store-sync-write.js";
 import { createJsonStore } from "./json-document-store.js";
 import { stringifyJsonDocument } from "./json-stringify.js";
 import { isNotFoundPathError } from "./path.js";
-import { throwFsSafeReadError } from "./root-errors.js";
+import { errorCauseOptions, throwFsSafeReadError } from "./root-errors.js";
 import { root } from "./root.js";
 import { DEFAULT_ROOT_MAX_BYTES } from "./root-impl.js";
 import { matchRootFileOpenFailure, openRootFileSync } from "./root-file.js";
@@ -38,9 +38,7 @@ function handleSyncStoreReadOpenFailure(opened) {
             if (isNotFound(failure.error)) {
                 return null;
             }
-            throw new FsSafeError("path-mismatch", "store target changed during read", {
-                cause: failure.error instanceof Error ? failure.error : undefined,
-            });
+            throw new FsSafeError("path-mismatch", "store target changed during read", errorCauseOptions(failure.error));
         },
         validation: (failure) => {
             if (failure.error instanceof FsSafeError) {
@@ -48,15 +46,11 @@ function handleSyncStoreReadOpenFailure(opened) {
             }
             // Validation failures mean the path existed but violated store policy
             // (directory, hardlink, symlink race). Do not report them as missing.
-            throw new FsSafeError("path-mismatch", "store target failed read validation", {
-                cause: failure.error instanceof Error ? failure.error : undefined,
-            });
+            throw new FsSafeError("path-mismatch", "store target failed read validation", errorCauseOptions(failure.error));
         },
         io: (failure) => throwFsSafeReadError(failure.error, "store"),
         fallback: (failure) => {
-            throw new FsSafeError("path-mismatch", "store target changed during read", {
-                cause: failure.error instanceof Error ? failure.error : undefined,
-            });
+            throw new FsSafeError("path-mismatch", "store target changed during read", errorCauseOptions(failure.error));
         },
     });
 }

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

@@ -1,12 +1,4 @@
-/**
- * Returns true when `fs.stat()` can stat the path.
- *
- * This follows stat semantics: broken symlinks return false, while symlinks to
- * existing targets return true.
- */
+/** True if stat succeeds; follows symlinks, so broken links return false. */
 export declare function pathExists(filePath: string): Promise<boolean>;
-/**
- * Synchronous counterpart to `pathExists()`, with the same `fs.statSync()`
- * semantics.
- */
+/** Synchronous {@link pathExists}. */
 export declare function pathExistsSync(filePath: string): boolean;

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

@@ -1,11 +1,6 @@
 import fs from "node:fs";
 import { pathForWindowsFilesystem } from "./windows-path-alias.js";
-/**
- * Returns true when `fs.stat()` can stat the path.
- *
- * This follows stat semantics: broken symlinks return false, while symlinks to
- * existing targets return true.
- */
+/** True if stat succeeds; follows symlinks, so broken links return false. */
 export async function pathExists(filePath) {
     try {
         fs.statSync(pathForWindowsFilesystem(filePath));
@@ -15,10 +10,7 @@ export async function pathExists(filePath) {
         return false;
     }
 }
-/**
- * Synchronous counterpart to `pathExists()`, with the same `fs.statSync()`
- * semantics.
- */
+/** Synchronous {@link pathExists}. */
 export function pathExistsSync(filePath) {
     try {
         fs.statSync(pathForWindowsFilesystem(filePath));

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

@@ -2,10 +2,8 @@ import { type RootBoundaryIdentity } from "./root-boundary.js";
 import { type MutationDirectoryObservation } from "./pinned-mutation-observation.js";
 import type { PinnedCreatedDirectoryReceipt, PinnedMutationAdmissionReceipt, PinnedMutationAuthorizationToken } from "./pinned-write-types.js";
 /**
- * Creates each missing path component from `rootReal` down to `targetPath`,
- * guarding every step. Returns the real (symlink-resolved) path of the final
- * component so callers can guard/use that path directly instead of
- * re-deriving it from the original, possibly-symlinked, lexical path.
+ * Guard each component from rootReal to targetPath; optionally create missing ones.
+ * Returns the resolved path: use it, rather than the lexical input, for later guards.
  */
 export declare function mkdirPathComponentsWithGuards(params: {
     rootReal: string;
@@ -15,6 +13,7 @@ export declare function mkdirPathComponentsWithGuards(params: {
     beforeUseComponent?: (componentPath: string, prospectiveTargetPath: string, retainedTargetPath: string | undefined) => Promise<void> | void;
     afterCreateComponent?: (receipt: PinnedCreatedDirectoryReceipt) => PinnedMutationAuthorizationToken | undefined;
     assertBeforeMutation?: () => void;
+    createMissing?: boolean;
     mode?: number;
     private?: boolean;
     rejectSymlinks?: boolean;

package/node_modules/@openclaw/fs-safe/dist/guarded-mkdir.js

@@ -10,7 +10,7 @@ import { assertNoWindowsPathAlias, pathForWindowsFilesystem, resolvePathPreservi
 import { realpathSync } from "./realpath.js";
 import { admitPathInsideRoot } from "./root-boundary.js";
 import { checkedMutationDirectory } from "./pinned-mutation-observation.js";
-import { createPathSegmentRoute, joinPathSegmentRoute, } from "./path-segment-route.js";
+import { createPathSegmentRoute, joinPathSegmentRoute, sameAbsolutePath, } from "./path-segment-route.js";
 function sameDirectoryFacts(left, right) {
     return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode &&
         left.nlink === right.nlink;
@@ -55,9 +55,6 @@ function createdDirectoryEvidence(admission, parent, childPath) {
         return undefined;
     }
 }
-function sameAbsolutePath(left, right) {
-    return path.relative(path.resolve(left), path.resolve(right)) === "";
-}
 function suppliedExactRootIdentity(identity) {
     return typeof identity?.dev === "bigint" && typeof identity.ino === "bigint"
         ? { dev: identity.dev, ino: identity.ino }
@@ -87,10 +84,8 @@ async function realpathOrThrowNotFile(target) {
     }
 }
 /**
- * Creates each missing path component from `rootReal` down to `targetPath`,
- * guarding every step. Returns the real (symlink-resolved) path of the final
- * component so callers can guard/use that path directly instead of
- * re-deriving it from the original, possibly-symlinked, lexical path.
+ * Guard each component from rootReal to targetPath; optionally create missing ones.
+ * Returns the resolved path: use it, rather than the lexical input, for later guards.
  */
 export async function mkdirPathComponentsWithGuards(params) {
     const rawRootReal = params.rootReal;
@@ -181,7 +176,7 @@ export async function mkdirPathComponentsWithGuards(params) {
                 }
             }
         }
-        if (shouldCreate) {
+        if (shouldCreate && params.createMissing !== false) {
             params.assertBeforeMutation?.();
             // Both policy and ordinary mkdir must renew the parent after callbacks.
             inspectGuardCurrent(parentGuard);
@@ -244,15 +239,8 @@ export async function mkdirPathComponentsWithGuards(params) {
         }
         const admittedNextPath = admittedNextReal.path;
         if (stat?.isSymbolicLink()) {
-            // An existing path component may legitimately be a symlink to a real
-            // directory inside the root (e.g. a skill-bank layout). We already
-            // verified above that it resolves inside the root, so treat the
-            // resolved real path as the directory for the rest of this walk
-            // instead of rejecting it outright. Guard checks from here on operate
-            // on the real (non-symlink) path, preserving TOCTOU protection for
-            // every subsequent segment. Callers that need the final directory
-            // (e.g. to guard it themselves after this function returns) must use
-            // the returned resolved path, not their own lexical parent path.
+            // Containment was checked above. Continue through the symlink's real directory
+            // so subsequent guards bind that directory.
             const targetStat = fsSync.statSync(admittedNextPath);
             if (!targetStat.isDirectory()) {
                 throw directoryComponentNotDirectoryError();

package/node_modules/@openclaw/fs-safe/dist/guest-dispatch-python.js

@@ -33,7 +33,7 @@ export const GUEST_FILESYSTEM_DISPATCH_PYTHON = [
     "                sys.exit(SANDBOX_CREATE_EXISTS_EXIT_CODE)",
     "        elif operation == 'read':",
     "            if len(sys.argv) > 5:",
-    "                read_file_bounded(parent_fd, sys.argv[4], int(sys.argv[5]))",
+    "                read_file(parent_fd, sys.argv[4], int(sys.argv[5]))",
     "            else:",
     "                read_file(parent_fd, sys.argv[4])",
     "        elif operation == 'readdir':",

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

@@ -42,7 +42,6 @@ export const GUEST_FILESYSTEM_RENAME_NO_REPLACE_PYTHON = [
     "        flags = 0x00000004  # RENAME_EXCL",
     "    else:",
     "        rename_fn = None",
-    "        flags = 0",
     "    if rename_fn is not None:",
     "        rename_fn.argtypes = [ctypes.c_int, ctypes.c_char_p, ctypes.c_int, ctypes.c_char_p, ctypes.c_uint]",
     "        rename_fn.restype = ctypes.c_int",
@@ -77,7 +76,6 @@ export const GUEST_FILESYSTEM_CREATE_EXCLUSIVE_PYTHON = [
     "    staging_name = None",
     "    temp_fd = None",
     "    temp_name = 'payload'",
-    "    temp_inode = None",
     "    try:",
     "        try:",
     "            os.lstat(basename, dir_fd=parent_fd)",

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

@@ -204,7 +204,9 @@ export const GUEST_FILESYSTEM_PYTHON = [
     "",
     GUEST_FILESYSTEM_CREATE_EXCLUSIVE_PYTHON,
     "",
-    "def read_file_impl(parent_fd, basename, max_bytes):",
+    "def read_file(parent_fd, basename, max_bytes=None):",
+    "    if max_bytes is not None and max_bytes < 0:",
+    "        raise OSError(errno.EINVAL, 'read limit must be non-negative', basename)",
     "    file_fd = os.open(basename, READ_FLAGS, dir_fd=parent_fd)",
     "    try:",
     "        file_stat = os.fstat(file_fd)",
@@ -227,14 +229,6 @@ export const GUEST_FILESYSTEM_PYTHON = [
     "    finally:",
     "        os.close(file_fd)",
     "",
-    "def read_file(parent_fd, basename):",
-    "    read_file_impl(parent_fd, basename, None)",
-    "",
-    "def read_file_bounded(parent_fd, basename, max_bytes):",
-    "    if max_bytes < 0:",
-    "        raise OSError(errno.EINVAL, 'read limit must be non-negative', basename)",
-    "    read_file_impl(parent_fd, basename, max_bytes)",
-    "",
     "def remove_tree(parent_fd, basename):",
     "    entry_stat = os.lstat(basename, dir_fd=parent_fd)",
     "    if not stat.S_ISDIR(entry_stat.st_mode) or stat.S_ISLNK(entry_stat.st_mode):",

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

@@ -2,7 +2,7 @@ export { FsSafeError, categorizeFsSafeError, } 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";
-export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
+export { configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
 export type * from "./config.js";
 export { writeExternalFileWithinRoot, } from "./output.js";
 export type * from "./output.js";

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

@@ -1,5 +1,5 @@
 export { FsSafeError, categorizeFsSafeError, } from "./errors.js";
 export { DEFAULT_ROOT_MAX_BYTES, root, } from "./root.js";
-export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
+export { configureFsSafeNative, getFsSafeNativeConfig, } from "./native-config.js";
 export { writeExternalFileWithinRoot, } from "./output.js";
 export { configureFsSafeLocks, getFsSafeLockConfig, } from "./lock-config.js";

package/node_modules/@openclaw/fs-safe/dist/json-durable-queue-directory.js

@@ -45,11 +45,7 @@ class QueueDirectory {
             throw new Error(`durable queue path is not a directory: ${dir}`);
         }
         const segments = path.relative(base, target).split(path.sep).filter(Boolean);
-        for (let index = 0; index < segments.length; index++) {
-            const segment = segments[index];
-            if (segment === undefined) {
-                continue;
-            }
+        for (const segment of segments) {
             current = path.join(current, segment);
             let stat;
             try {

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

@@ -7,8 +7,9 @@ import { stringifyJsonDocument } from "./json-stringify.js";
 import { readRegularFile, readRegularFileSync, statRegularFile } from "./regular-file.js";
 import { openRootFileSync } from "./root-file.js";
 import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
-import { writeTempFileSync } from "./replace-file-descriptor.js";
-import { SyncAtomicTempOwner } from "./replace-file-temp-owner.js";
+import { writeTempFile, syncDirectoryBestEffort } from "./replace-file-descriptor.js";
+import { AtomicIo, runSync } from "./atomic-io.js";
+import { AtomicTempOwner } from "./replace-file-temp-owner.js";
 import { admitStandalonePublicationPath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
 import { writeTextAtomic } from "./text-atomic.js";
 import { sleep } from "./timing.js";
@@ -57,28 +58,8 @@ function trySetSecureMode(fd) {
         // Best-effort mode application stays on the retained staging descriptor.
     }
 }
-function trySyncDirectory(pathname) {
-    let fd;
-    try {
-        fd = fsSync.openSync(path.dirname(pathname), "r");
-        fsSync.fsyncSync(fd);
-    }
-    catch {
-        // best-effort; some platforms/filesystems do not support syncing directories.
-    }
-    finally {
-        if (fd !== undefined) {
-            try {
-                fsSync.closeSync(fd);
-            }
-            catch {
-                // best-effort cleanup
-            }
-        }
-    }
-}
 function renameJsonFileWithFallback(owner, pathname) {
-    owner.assertCurrent(fsSync);
+    runSync(owner.assertCurrent());
     try {
         fsSync.renameSync(owner.pathname, pathname);
         return;
@@ -86,9 +67,9 @@ function renameJsonFileWithFallback(owner, pathname) {
     catch (error) {
         const code = error?.code;
         if (code === "EPERM" || code === "EEXIST") {
-            owner.assertCurrent(fsSync);
+            runSync(owner.assertCurrent());
             fsSync.rmSync(pathname, { force: true });
-            owner.assertCurrent(fsSync);
+            runSync(owner.assertCurrent());
             fsSync.renameSync(owner.pathname, pathname);
             return;
         }
@@ -113,31 +94,32 @@ export function writeJsonSync(pathname, data) {
     const tmpPath = path.format({ ...path.parse(filePath), base: `.fs-safe-${randomUUID()}.tmp` });
     const payload = `${stringifyJsonDocument(data, null, 2)}\n`;
     fsSync.mkdirSync(recursiveMkdirPath(path.dirname(filePath)), { recursive: true, mode: JSON_DIR_MODE });
-    const owner = new SyncAtomicTempOwner(tmpPath);
+    const io = AtomicIo.sync(fsSync);
+    const owner = new AtomicTempOwner(tmpPath, io);
     let originalFailure;
     try {
         owner.start();
-        const temp = writeTempFileSync({
-            fsModule: fsSync, tempPath: tmpPath, content: payload, mode: JSON_FILE_MODE,
+        const temp = runSync(writeTempFile(io, {
+            tempPath: tmpPath, content: payload, mode: JSON_FILE_MODE,
             sync: false, onIdentity: owner.onIdentity,
-        });
+        }));
         owner.adopt(temp);
-        owner.assertCurrent(fsSync);
-        trySetSecureMode(temp.fd);
-        fsSync.fsyncSync(temp.fd);
+        runSync(owner.assertCurrent());
+        trySetSecureMode(temp.file.fd);
+        fsSync.fsyncSync(temp.file.fd);
         renameJsonFileWithFallback(owner, filePath);
         owner.markRenamed();
-        owner.assertPublished(fsSync, filePath);
-        trySetSecureMode(temp.fd);
-        trySyncDirectory(filePath);
-        owner.assertPublished(fsSync, filePath);
+        runSync(owner.assertPublished(filePath));
+        trySetSecureMode(temp.file.fd);
+        runSync(syncDirectoryBestEffort(io, path.dirname(filePath)));
+        runSync(owner.assertPublished(filePath));
     }
     catch (error) {
         originalFailure = { error };
         throw error;
     }
     finally {
-        owner.finish({ fsModule: fsSync, originalFailure, throwOnCleanupError: false });
+        runSync(owner.finish({ originalFailure, throwOnCleanupError: false }));
     }
 }
 export class JsonFileReadError extends Error {

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

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import fsSync, { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { assertExclusiveCreateLeaf } from "./exclusive-create.js";
 import { assertSyncDirectoryGuard, createAsyncDirectoryGuard } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { guardedRename } from "./guarded-mutation.js";
@@ -142,6 +143,7 @@ async function copyRegularFilePinned(params) {
         }
         await assertSourceStillMatches(params.from, openedIdentity);
         const parentGuard = await createAsyncDirectoryGuard(path.dirname(params.to), { bigint: true });
+        assertExclusiveCreateLeaf(params.to);
         const destinationHandle = await fs.open(params.to, fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_EXCL, modeBits(params.mode) || 0o666);
         let destinationIdentity;
         try {

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

@@ -3,6 +3,7 @@ export declare class MutationAuthorityError extends FsSafeError {
     readonly rejection: unknown;
     constructor(rejection: unknown);
 }
+export declare function isMutationAuthorityError(error: unknown): error is MutationAuthorityError;
 export declare function assertSynchronousCallbackResult(returned: unknown, name: string): void;
 export declare function composeMutationAssertions(defaultAssertion?: () => void, callAssertion?: () => void): (() => void) | undefined;
 export declare function rethrowMutationAuthorityError(error: unknown): never;

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

@@ -7,6 +7,14 @@ export class MutationAuthorityError extends FsSafeError {
         this.rejection = rejection;
     }
 }
+export function isMutationAuthorityError(error) {
+    try {
+        return error instanceof MutationAuthorityError;
+    }
+    catch {
+        return false;
+    }
+}
 export function assertSynchronousCallbackResult(returned, name) {
     if (returned !== null &&
         (typeof returned === "object" || typeof returned === "function") &&
@@ -34,7 +42,7 @@ export function composeMutationAssertions(defaultAssertion, callAssertion) {
     };
 }
 export function rethrowMutationAuthorityError(error) {
-    if (error instanceof MutationAuthorityError)
+    if (isMutationAuthorityError(error))
         throw error.rejection;
     // Cleanup failures and indeterminate publication receipts must retain their context.
     throw error;

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

@@ -1,4 +1,22 @@
 import type { RetainedFileResult } from "./retained-file-types.js";
+export type NativePublicationTransition = {
+    outcome: "committed" | "not-published" | "indeterminate";
+    errorCode?: string;
+    errorMessage?: string;
+};
+export interface NativeWindowsEntryPublication {
+    readonly admission: {
+        outcome: string;
+        errorCode?: string;
+        errorMessage?: string;
+    };
+    current(published: boolean): void;
+    publish(): NativePublicationTransition;
+    close(): {
+        code: string;
+        message: string;
+    }[];
+}
 export interface NativeRetainedFile {
     readonly admission: RetainedFileResult | {
         status: "retained";
@@ -63,6 +81,17 @@ export interface NativeOwnedTreeRemovalResult {
     errorCode?: string;
     errorMessage?: string;
 }
+export interface NativeRootRemovalEntry {
+    dev: bigint;
+    ino: bigint;
+    directory: boolean;
+    symlink: boolean;
+}
+export interface NativeRootRemovalDirectory {
+    readonly fd: number;
+    read(): string | null;
+    close(): void;
+}
 export interface NativeWindowsAccessControlEntry {
     sid: string;
     mask: number;
@@ -103,10 +132,19 @@ type NativeTwoPathArgs = [
     targetRelPath: string
 ];
 export interface NativeBinding {
+    rootRemovalStat?(parent: number, name: string): NativeRootRemovalEntry;
+    rootRemovalUnlink?(parent: number, name: string, dev: bigint, ino: bigint, directory: boolean): void;
+    openRootRemovalDirectory?(parent: number, name: string, dev: bigint, ino: bigint): NativeRootRemovalDirectory;
+    openCreateBeneath?(parentFd: number, basename: string, flags: number, mode: number): number;
+    renameReplaceWithIdentity?(sourceParent: number, source: string, targetParent: number, target: string, dev: bigint, ino: bigint): void;
     /** Windows-only, private handle custody; no borrowed/runtime descriptors. */
     retainWindowsFile?(directory: string, basename: string, parentDev: bigint, parentIno: bigint, dev: bigint, ino: bigint, size: bigint, mtimeNs: bigint, ctimeNs: bigint, sha256: string, maxBytes: number): NativeRetainedFile;
     watchRegister?(root: string, limit: number, callback: (batch: import("./watch-native.js").NativeWatchWireBatch) => void, persistent: boolean): number;
     watchConfigure?(id: number, anchors: string[], exclusions: string[]): void;
+    watchEntries?(id: number, entries: import("./watch-native.js").NativeWatchEntry[]): {
+        directories: number;
+        changed: boolean;
+    };
     watchAdd?(id: number, directory: {
         root: string;
         relative: string;
@@ -164,7 +202,7 @@ export interface NativeBinding {
     createStagedFile?(parentFd: number, basename: string): number;
     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, sync: boolean): Promise<NativeFileCopyResult>;
+    copyFileExclusive?(sourceFd: number, parentFd: number, basename: string, clone: CopyCloneMode, maxBytes: number | undefined, signal: AbortSignal | undefined): Promise<NativeFileCopyResult>;
     cloneFileExclusive(sourceFd: number, targetRootFd: number, targetRelPath: string): number;
     copyFileRangeExclusive(sourceFd: number, targetRootFd: number, targetRelPath: string): Promise<NativeCopyResult>;
     createPrivateDirectory(path: string): void;
@@ -180,15 +218,22 @@ export interface NativeBinding {
     linkBeneath(...args: NativeTwoPathArgs): void;
     /** Direct-child mkdir; true is receipt provenance only, never cleanup ownership. */
     mkdirChildBeneath?(parentFd: number, basename: string, mode: number): boolean;
+    mkdirOpenChildBeneath?(parentFd: number, basename: string, mode: number, flags: number): {
+        fd: number;
+        created: boolean;
+    };
     mkdirBeneath(rootFd: number, relPath: string, mode: number): void;
     openBeneath(rootFd: number, relPath: string, flags: number): NativeOpenBeneathResult;
-    readArchiveEntryNative(path: string, kind: string, requested: string, maxBytes: number, limits: TarMeterLimits, signal: AbortSignal): Promise<Buffer>;
     readOwnerAndDacl(path: string): NativeWindowsSecurityFacts;
     /** Internal Windows-only inspection of the exact borrowed Node descriptor. */
     inspectWindowsSecureFileHandle?(fd: number): NativeWindowsDescriptorSecurityFacts;
     ownedTreeRemovalAvailable?(parentFd: number): boolean;
     removeOwnedTree?(parentFd: number, basename: string, directoryFd: number): Promise<NativeOwnedTreeRemovalResult>;
     removeOwnedTreeSync?(parentFd: number, basename: string, directoryFd: number): NativeOwnedTreeRemovalResult;
+    /** Local filesystem admission for one-way cooperative entry publication. */
+    retainWindowsEntryPublication?(sourcePath: string, name: string, sourceDev: bigint, sourceIno: bigint, targetPath: string, targetName: string, targetDev: bigint, targetIno: bigint, dev: bigint, ino: bigint, kind: "file" | "directory" | "symlink"): NativeWindowsEntryPublication;
+    entryPublicationFilesystem?(parentFd: number): string;
+    publishRetainedEntryNoReplace?(sourceParentFd: number, sourceBasename: string, sourceFd: number, targetParentFd: number, targetBasename: string): NativePublicationTransition;
     renameNoReplace(...args: NativeTwoPathArgs): void;
     /** Identity-fenced retained-directory rename capability. */
     renameNoReplaceWithIdentity?(...args: [...paths: NativeTwoPathArgs, expectedSourceDev: bigint, expectedSourceIno: bigint]): void;

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

@@ -2,15 +2,7 @@ export type FsSafeNativeMode = "auto" | "off" | "require";
 export type FsSafeNativeConfig = {
     mode: FsSafeNativeMode;
 };
-/** @deprecated Compatibility bridge for 0.4 upgrades. Use {@link FsSafeNativeConfig}. */
-export type FsSafePythonConfig = {
-    mode: FsSafeNativeMode;
-    pythonPath?: string;
-};
 export declare function configureFsSafeNative(config: Partial<FsSafeNativeConfig>): void;
-/**
- * @deprecated Compatibility bridge for 0.4 upgrades. Use configureFsSafeNative.
- */
-export declare function configureFsSafePython(config: Partial<FsSafePythonConfig>): void;
 export declare function getFsSafeNativeConfig(): FsSafeNativeConfig;
+export declare function isFsSafeNativeRequired(): boolean;
 export declare function __resetFsSafeNativeConfigForTest(): void;