@openclaw/openshell-sandbox 2026.9.3 → 2026.9.5

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"publish-copy-stage.d.ts","sourceRoot":"","sources":["../src/publish-copy-stage.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAE/C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAGnE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAIhE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,WAAW,CAAC;IACtB,WAAW,EAAE,sBAAsB,CAAC;IACpC,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAC;IAClC,WAAW,CAAC,EAAE,CAAC,QAAQ,EAAE,sBAAsB,KAAK,IAAI,CAAC;CAC1D,GAAG,IAAI,CAqCP"}

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

@@ -0,0 +1,47 @@
+import fs, {} from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+// Node has no portable no-replace rename. Link only our completed private stage,
+// then unlink it in the same JS turn so local readers never observe two names.
+export function publishCopyStage(params) {
+    const { identity, temporaryPath, targetPath } = params;
+    const staged = fs.lstatSync(temporaryPath, { bigint: true });
+    const opened = fs.fstatSync(params.fd, { bigint: true });
+    if (!staged.isFile() || staged.isSymbolicLink() || staged.nlink !== 1n ||
+        !sameFileIdentityForCleanup(staged, identity) ||
+        !sameFileIdentityForCleanup(opened, identity)) {
+        throw new FsSafeError("path-mismatch", "exclusive copy stage changed before publication");
+    }
+    params.assertBeforeMutation?.();
+    fs.linkSync(temporaryPath, targetPath);
+    let observerRejected = false;
+    let observerError;
+    try {
+        params.onPublished?.(identity);
+    }
+    catch (error) {
+        observerRejected = true;
+        observerError = error;
+    }
+    try {
+        const parent = fs.lstatSync(path.dirname(temporaryPath), { bigint: true });
+        const current = fs.lstatSync(temporaryPath, { bigint: true });
+        if (parent.isSymbolicLink() || !parent.isDirectory() ||
+            !sameFileIdentityForCleanup(parent, params.parentGuard.stat) ||
+            current.isSymbolicLink() || !current.isFile() ||
+            !sameFileIdentityForCleanup(current, identity)) {
+            throw new FsSafeError("path-mismatch", "published copy temporary name changed before cleanup");
+        }
+        // This removes the stage's name, never the published destination or source.
+        fs.unlinkSync(temporaryPath);
+    }
+    catch (error) {
+        throw new FsSafeError("helper-failed", "published copy temporary cleanup failed", {
+            cause: observerRejected ? new AggregateError([observerError, error], "observer and cleanup failed") : error,
+            details: { publication: "published", path: targetPath, dev: identity.dev, ino: identity.ino, cleanup: "failed" },
+        });
+    }
+    if (observerRejected)
+        throw observerError;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"publish-file.d.ts","sourceRoot":"","sources":["../src/publish-file.ts"],"names":[],"mappings":"AACA,OAAe,EAAoB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAI/D,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAI5B,OAAO,EAML,KAAK,qCAAqC,EAC3C,MAAM,2BAA2B,CAAC;AAGnC,YAAY,EACV,2BAA2B,EAC3B,wCAAwC,EACxC,kCAAkC,EAClC,gCAAgC,EAChC,qCAAqC,GACtC,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,4BAA4B,GACpC,cAAc,GACd,eAAe,GACf,kBAAkB,CAAC;AAEvB,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,UAAU,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;IAC3D,QAAQ,EAAE,KAAK,CAAC;IAChB,aAAa,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAkBF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE/D;AA0ND,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB,CAAC,EAAE,gBAAgB,CAAC;IAC1C,QAAQ,EAAE,4BAA4B,CAAC;IACvC,aAAa,CAAC,EAAE,qCAAqC,CAAC;IACtD,aAAa,CAAC,EAAE,gBAAgB,CAAC;CAClC,GAAG,OAAO,CAAC,0BAA0B,CAAC,CA4MtC"}
+{"version":3,"file":"publish-file.d.ts","sourceRoot":"","sources":["../src/publish-file.ts"],"names":[],"mappings":"AACA,OAAe,EAAoB,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAG/D,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EAC1B,MAAM,2BAA2B,CAAC;AAGnC,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAML,KAAK,qCAAqC,EAC3C,MAAM,2BAA2B,CAAC;AAKnC,YAAY,EACV,2BAA2B,EAC3B,wCAAwC,EACxC,kCAAkC,EAClC,gCAAgC,EAChC,qCAAqC,GACtC,MAAM,2BAA2B,CAAC;AAEnC,MAAM,MAAM,4BAA4B,GAAG,cAAc,GAAG,eAAe,GAAG,kBAAkB,CAAC;AAEjG,MAAM,MAAM,0BAA0B,GAAG;IACvC,MAAM,EAAE,UAAU,GAAG,gBAAgB,GAAG,kBAAkB,CAAC;IAC3D,QAAQ,EAAE,KAAK,CAAC;IAChB,aAAa,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAIF,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE/D;AA0ND,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,sBAAsB,CAAC,EAAE,gBAAgB,CAAC;IAC1C,QAAQ,EAAE,4BAA4B,CAAC;IACvC,aAAa,CAAC,EAAE,qCAAqC,CAAC;IACtD,aAAa,CAAC,EAAE,gBAAgB,CAAC;CAClC,GAAG,OAAO,CAAC,0BAA0B,CAAC,CA6NtC"}

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

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import fsSync, {} from "node:fs";
-import fs from "node:fs/promises";
+import fs, {} from "node:fs/promises";
 import path from "node:path";
 import { pinDirectory, } from "./directory-durability.js";
 import { FsSafeError } from "./errors.js";
@@ -8,30 +8,18 @@ import { hashFileHandle } from "./file-hash.js";
 import { sameFileIdentity, sameFileIdentityForCleanup, } from "./file-identity.js";
 import { syncFileBestEffortSync } from "./file-sync.js";
 import { getNativeBinding, requireNativeBinding } from "./native.js";
+import { captureNativeFdClose } from "./native-binding.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { directorySyncFailure, publicationFailure, rememberCreatedTarget, } from "./publish-file-failure.js";
+import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
-const HARDLINK_FALLBACK_CODES = new Set([
-    "EPERM",
-    "EXDEV",
-    "ENOTSUP",
-    "EOPNOTSUPP",
-    "ENOSYS",
-]);
-const NATIVE_COPY_FALLBACK_CODES = new Set([
-    "EINVAL",
-    "ENOSYS",
-    "ENOTSUP",
-    "EOPNOTSUPP",
-    "EPERM",
-    "EXDEV",
-]);
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+const HARDLINK_FALLBACK_CODES = new Set(["EPERM", "EXDEV", "ENOTSUP", "EOPNOTSUPP", "ENOSYS"]);
+const NATIVE_COPY_FALLBACK_CODES = new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP", "EPERM", "EXDEV"]);
 export function isHardlinkFallbackError(error) {
     return HARDLINK_FALLBACK_CODES.has(error?.code ?? "");
 }
-function sourceOpenFlags() {
-    return resolveReadOpenFlags();
-}
+function sourceOpenFlags() { return resolveReadOpenFlags(); }
 function directoryOpenFlags() {
     return (fsSync.constants.O_RDONLY |
         (typeof fsSync.constants.O_DIRECTORY === "number" ? fsSync.constants.O_DIRECTORY : 0));
@@ -40,8 +28,8 @@ async function openNativeParent(filePath) {
     const parentPath = path.dirname(filePath);
     const handle = await fs.open(parentPath, directoryOpenFlags());
     try {
-        const pathname = await fs.lstat(parentPath, { bigint: true });
-        const opened = await handle.stat({ bigint: true });
+        const pathname = fsSync.lstatSync(parentPath, { bigint: true });
+        const opened = fsSync.fstatSync(handle.fd, { bigint: true });
         if (pathname.isSymbolicLink() || !sameFileIdentity(pathname, opened)) {
             throw new FsSafeError("path-mismatch", "publication parent changed while opening");
         }
@@ -55,8 +43,8 @@ async function openNativeParent(filePath) {
 async function assertPinnedSourceCurrent(params) {
     // Windows file indexes can exceed Number.MAX_SAFE_INTEGER, so publication
     // fences must compare bigint stats instead of rounded numeric identities.
-    const opened = await params.handle.stat({ bigint: true });
-    const current = await fs.lstat(params.sourcePath, { bigint: true });
+    const opened = fsSync.fstatSync(params.handle.fd, { bigint: true });
+    const current = fsSync.lstatSync(params.sourcePath, { bigint: true });
     if (!opened.isFile() ||
         current.isSymbolicLink() ||
         !current.isFile() ||
@@ -67,6 +55,7 @@ async function assertPinnedSourceCurrent(params) {
 }
 async function copyPinnedSource(params) {
     if (params.native && params.targetNativeParent) {
+        const closeFd = captureNativeFdClose(params.native);
         for (const method of ["clone", "copy-file-range"]) {
             let nativeFd;
             try {
@@ -90,15 +79,15 @@ async function copyPinnedSource(params) {
                 throw error;
             }
             let target;
-            let createdIdentity = fsSync.fstatSync(nativeFd, { bigint: true });
-            rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
             try {
+                let createdIdentity = fsSync.fstatSync(nativeFd, { bigint: true });
+                rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
                 fsSync.fchmodSync(nativeFd, 0o600);
                 createdIdentity = fsSync.fstatSync(nativeFd, { bigint: true });
                 await getFsSafeTestHooks()?.afterPublishTargetCreated?.("exclusive-copy", params.targetPath, createdIdentity);
-                const identity = await fs.lstat(params.targetPath, { bigint: true });
+                const identity = fsSync.lstatSync(params.targetPath, { bigint: true });
                 target = await fs.open(params.targetPath, sourceOpenFlags());
-                const opened = await target.stat({ bigint: true });
+                const opened = fsSync.fstatSync(target.fd, { bigint: true });
                 if (identity.isSymbolicLink() ||
                     !identity.isFile() ||
                     !sameFileIdentity(createdIdentity, identity) ||
@@ -106,8 +95,9 @@ async function copyPinnedSource(params) {
                     throw new FsSafeError("path-mismatch", "native publication target changed after copy");
                 }
                 const hashed = await hashFileHandle(target, params.native);
-                fsSync.closeSync(nativeFd);
+                const completedFd = nativeFd;
                 nativeFd = undefined;
+                closeFd(completedFd);
                 return {
                     handle: target,
                     exactIdentity: opened,
@@ -121,16 +111,16 @@ async function copyPinnedSource(params) {
             }
             finally {
                 if (nativeFd !== undefined)
-                    fsSync.closeSync(nativeFd);
+                    closeFd(nativeFd);
             }
         }
     }
     const target = await fs.open(params.targetPath, "wx+", 0o600);
-    const createdIdentity = await target.stat({ bigint: true });
-    rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
     try {
+        const createdIdentity = fsSync.fstatSync(target.fd, { bigint: true });
+        rememberCreatedTarget(params.failure, createdIdentity, "copy-verify");
         await target.chmod(0o600);
-        const exactIdentity = await target.stat({ bigint: true });
+        const exactIdentity = fsSync.fstatSync(target.fd, { bigint: true });
         await getFsSafeTestHooks()?.afterPublishTargetCreated?.("exclusive-copy", params.targetPath, exactIdentity);
         const hash = createHash("sha256");
         const buffer = Buffer.allocUnsafe(64 * 1024);
@@ -164,7 +154,7 @@ async function removeCreatedTargetIfUnchanged(targetPath, identity) {
         return "unknown";
     }
     try {
-        const current = await fs.lstat(targetPath, { bigint: true });
+        const current = fsSync.lstatSync(targetPath, { bigint: true });
         if (!current.isSymbolicLink() && sameFileIdentityForCleanup(current, identity)) {
             await fs.rm(targetPath);
             return "removed";
@@ -189,13 +179,28 @@ async function syncPublishedParent(params) {
     }
 }
 export async function publishFileExclusive(params) {
-    const sourcePath = path.resolve(params.sourcePath);
-    const targetPath = path.resolve(params.targetPath);
+    const sourcePathInput = admitStandalonePublicationPath(params.sourcePath, "publication source uses a Windows filesystem namespace alias");
+    const targetPathInput = admitStandalonePublicationPath(params.targetPath, "publication target uses a Windows filesystem namespace alias");
+    const parentReceiptInput = params.parentReceipt;
+    const parentReceipt = parentReceiptInput
+        ? { path: parentReceiptInput.path, realPath: parentReceiptInput.realPath,
+            identity: parentReceiptInput.identity }
+        : undefined;
+    if (parentReceipt) {
+        assertNoWindowsPathAlias(parentReceipt.path, "filesystem", "publication parent uses a Windows filesystem namespace alias");
+    }
+    const sourcePath = path.resolve(sourcePathInput);
+    const targetPath = path.resolve(targetPathInput);
+    assertNoWindowsPathAlias(sourcePath, "filesystem", "publication source uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(targetPath, "filesystem", "publication target uses a Windows filesystem namespace alias");
     const parentPath = path.dirname(targetPath);
-    if (params.parentReceipt && path.resolve(params.parentReceipt.path) !== parentPath) {
+    if (parentReceipt && path.resolve(parentReceipt.path) !== parentPath) {
         throw new FsSafeError("path-mismatch", "publication parent receipt does not match target parent");
     }
-    const sourcePathStat = await fs.lstat(sourcePath);
+    if (parentReceipt) {
+        assertNoWindowsPathAlias(parentReceipt.realPath, "filesystem", "publication parent uses a Windows filesystem namespace alias");
+    }
+    const sourcePathStat = fsSync.lstatSync(sourcePath);
     if (sourcePathStat.isSymbolicLink() || !sourcePathStat.isFile()) {
         throw new FsSafeError("not-file", "publication source must be a regular file");
     }
@@ -203,52 +208,54 @@ export async function publishFileExclusive(params) {
     let parent;
     let sourceNativeParent;
     let targetNativeParent;
+    const strategy = params.strategy;
     const failure = {
-        phase: params.strategy === "rename-noreplace" ? "rename-create" : "hardlink-create",
+        phase: strategy === "rename-noreplace" ? "rename-create" : "hardlink-create",
         targetCreated: false,
         preserveTarget: false,
     };
     try {
-        parent = await pinDirectory(params.parentReceipt ?? parentPath, {
+        parent = await pinDirectory(parentReceipt ?? parentPath, {
             label: "publication parent",
         });
-        const sourceIdentity = await source.stat();
-        const sourceExactIdentity = await source.stat({ bigint: true });
-        const sourcePathExactIdentity = await fs.lstat(sourcePath, { bigint: true });
+        const sourceIdentity = fsSync.fstatSync(source.fd);
+        const sourceExactIdentity = fsSync.fstatSync(source.fd, { bigint: true });
+        const sourcePathExactIdentity = fsSync.lstatSync(sourcePath, { bigint: true });
+        const expectedSourceIdentity = params.expectedSourceIdentity;
         if (sourcePathExactIdentity.isSymbolicLink() ||
             !sourcePathExactIdentity.isFile() ||
             !sameFileIdentity(sourcePathExactIdentity, sourceExactIdentity) ||
-            (params.expectedSourceIdentity &&
-                !sameFileIdentity(params.expectedSourceIdentity, typeof params.expectedSourceIdentity.dev === "bigint" ||
-                    typeof params.expectedSourceIdentity.ino === "bigint"
+            (expectedSourceIdentity &&
+                !sameFileIdentity(expectedSourceIdentity, typeof expectedSourceIdentity.dev === "bigint" ||
+                    typeof expectedSourceIdentity.ino === "bigint"
                     ? sourceExactIdentity
                     : sourceIdentity))) {
             throw new FsSafeError("path-mismatch", "publication source identity did not match");
         }
         await parent.assertCurrent();
         await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
-        const native = params.strategy === "rename-noreplace"
+        const native = strategy === "rename-noreplace"
             ? requireNativeBinding()
             : getNativeBinding();
         if (native) {
             sourceNativeParent = await openNativeParent(sourcePath);
             targetNativeParent = await openNativeParent(targetPath);
         }
-        if (params.strategy === "rename-noreplace") {
+        if (strategy === "rename-noreplace") {
             const binding = requireNativeBinding();
             binding.renameNoReplace(sourceNativeParent.handle.fd, sourceNativeParent.basename, targetNativeParent.handle.fd, targetNativeParent.basename);
             rememberCreatedTarget(failure, sourceExactIdentity, "rename-verify");
             // A failed post-rename fence must not delete the only remaining name.
             failure.preserveTarget = true;
             await getFsSafeTestHooks()?.afterPublishTargetCreated?.("rename-noreplace", targetPath, sourceExactIdentity);
-            const targetExactIdentity = await fs.lstat(targetPath, { bigint: true });
+            const targetExactIdentity = fsSync.lstatSync(targetPath, { bigint: true });
             if (targetExactIdentity.isSymbolicLink() ||
                 !targetExactIdentity.isFile() ||
                 !sameFileIdentity(targetExactIdentity, sourceExactIdentity)) {
                 throw new FsSafeError("path-mismatch", "no-replace publication target changed");
             }
             try {
-                await fs.lstat(sourcePath);
+                fsSync.lstatSync(sourcePath);
                 throw new FsSafeError("path-mismatch", "no-replace publication source still exists");
             }
             catch (error) {
@@ -257,7 +264,7 @@ export async function publishFileExclusive(params) {
                 }
             }
             syncFileBestEffortSync(sourceNativeParent.handle.fd);
-            const targetIdentity = await fs.lstat(targetPath);
+            const targetIdentity = fsSync.lstatSync(targetPath);
             return {
                 method: "rename-noreplace",
                 identity: targetIdentity,
@@ -278,14 +285,14 @@ export async function publishFileExclusive(params) {
             }
             rememberCreatedTarget(failure, sourceExactIdentity, "hardlink-verify");
             await getFsSafeTestHooks()?.afterPublishTargetCreated?.("hardlink", targetPath, sourceExactIdentity);
-            const targetExactIdentity = await fs.lstat(targetPath, { bigint: true });
+            const targetExactIdentity = fsSync.lstatSync(targetPath, { bigint: true });
             if (targetExactIdentity.isSymbolicLink() ||
                 !targetExactIdentity.isFile() ||
                 !sameFileIdentity(targetExactIdentity, sourceExactIdentity)) {
                 throw new FsSafeError("path-mismatch", "hardlink publication target changed");
             }
             await assertPinnedSourceCurrent({ sourcePath, handle: source, identity: sourceExactIdentity });
-            const targetIdentity = await fs.lstat(targetPath);
+            const targetIdentity = fsSync.lstatSync(targetPath);
             return {
                 method: "hardlink",
                 identity: targetIdentity,
@@ -300,7 +307,7 @@ export async function publishFileExclusive(params) {
         catch (error) {
             if (failure.targetCreated ||
                 !isHardlinkFallbackError(error) ||
-                params.strategy === "link-required") {
+                strategy === "link-required") {
                 throw error;
             }
         }
@@ -316,9 +323,9 @@ export async function publishFileExclusive(params) {
                 failure,
             });
             target = copied.handle;
-            targetIdentity = await target.stat();
-            const targetPathStat = await fs.lstat(targetPath);
-            const targetPathExactStat = await fs.lstat(targetPath, { bigint: true });
+            targetIdentity = fsSync.fstatSync(target.fd);
+            const targetPathStat = fsSync.lstatSync(targetPath);
+            const targetPathExactStat = fsSync.lstatSync(targetPath, { bigint: true });
             const copiedBack = await hashFileHandle(target, native);
             const sourceAfter = await hashFileHandle(source, native);
             if (targetPathStat.isSymbolicLink() ||

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"realpath.d.ts","sourceRoot":"","sources":["../src/realpath.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,YAAY,WAAyB,MAAM;oBACtC,MAAM;CACtB,CAAC"}

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

@@ -0,0 +1,43 @@
+import fs from "node:fs";
+import { platform } from "node:os";
+import { getSystemErrorName } from "node:util";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+const runtimePlatform = process.versions.bun ? platform() : undefined;
+const bunPosix = runtimePlatform === "darwin" || runtimePlatform === "linux" ? runtimePlatform : undefined;
+function resolve(input, native) {
+    if (bunPosix) {
+        // Bun 1.4.2 normalizes native path components and opens the leaf for reads.
+        // The Rust OS resolver preserves permissions, locks and physical spelling.
+        // Reuse our N-API addon so this also works with JIT disabled; Bun's FFI
+        // bridge requires JIT and would duplicate native loading and memory handling.
+        // Remove this routing once the Bun baseline includes oven-sh/bun#42374.
+        if (input.includes("\0")) {
+            throw Object.assign(new TypeError("realpath input must not contain null bytes"), {
+                code: "ERR_INVALID_ARG_VALUE",
+            });
+        }
+        const binding = getNativeBinding();
+        if (binding?.canonicalizePath) {
+            // Ordinary resolution normalizes both the input and each expanded symlink.
+            const result = binding.canonicalizePath(input, !native);
+            if (result.path !== undefined)
+                return result.path;
+            const errno = -(result.errno);
+            const code = getSystemErrorName(errno);
+            throw Object.assign(new Error(`${code}: realpath '${input}'`), {
+                code, errno, syscall: "realpath", path: input,
+            });
+        }
+        if (getFsSafeNativeConfig().mode === "require") {
+            throw new FsSafeError("helper-unavailable", "native fs-safe canonicalization is unavailable");
+        }
+        // The workaround belongs to the same optional addon, so "off" disables it
+        // too. With off or a missing addon in auto, Bun's upstream limits still apply.
+    }
+    return native ? fs.realpathSync.native(input) : fs.realpathSync(input);
+}
+export const realpathSync = Object.assign((input) => resolve(input, false), {
+    native: (input) => resolve(input, true),
+});

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"recursive-mkdir-path.d.ts","sourceRoot":"","sources":["../src/recursive-mkdir-path.ts"],"names":[],"mappings":"AAKA,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAG5D"}

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

@@ -0,0 +1,8 @@
+import { platform } from "node:os";
+import { absolutePathWithRawSegments } from "./root-path-existing.js";
+const needsAbsolutePath = Boolean(process.versions.bun) && platform() === "win32";
+/** Bun's Windows recursive mkdir cannot inspect existing relative dot components. */
+export function recursiveMkdirPath(directory) {
+    // Preserve junction/parent traversal; path.resolve would erase those components.
+    return needsAbsolutePath ? absolutePathWithRawSegments(directory) : directory;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"regular-file.d.ts","sourceRoot":"","sources":["../src/regular-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,KAAK,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,MAAM,MAAM,SAAS,CAAC;AAmB7B,MAAM,MAAM,qBAAqB,GAAG;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAExF,KAAK,8BAA8B,GAAG,IAAI,CACxC,OAAO,MAAM,CAAC,SAAS,EACvB,UAAU,GAAG,SAAS,GAAG,UAAU,CACpC,GACC,OAAO,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC;AAEtE,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,SAAS,GAAE,8BAAiD,GAC3D,MAAM,CASR;AAaD,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CActF;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,qBAAqB,CAc3E;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CA6D3C;AA2DD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,CAAC;CACb,CAoCA;AAmBD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgFxF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CAgF7E"}
+{"version":3,"file":"regular-file.d.ts","sourceRoot":"","sources":["../src/regular-file.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,KAAK,EAAE,MAAM,SAAS,CAAC;AAClD,OAAO,MAAM,MAAM,SAAS,CAAC;AAuB7B,MAAM,MAAM,qBAAqB,GAAG;IAAE,OAAO,EAAE,IAAI,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAExF,KAAK,8BAA8B,GAAG,IAAI,CACxC,OAAO,MAAM,CAAC,SAAS,EACvB,UAAU,GAAG,SAAS,GAAG,UAAU,CACpC,GACC,OAAO,CAAC,IAAI,CAAC,OAAO,MAAM,CAAC,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC,CAAC,CAAC;AAEtE,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,SAAS,GAAE,8BAAiD,GAC3D,MAAM,CASR;AAaD,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAetF;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,qBAAqB,CAe3E;AAED,wBAAsB,eAAe,CAAC,MAAM,EAAE;IAC5C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC,CA+D3C;AA2DD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IACpF,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,KAAK,CAAC;CACb,CAsCA;AAmBD,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkFxF;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,wBAAwB,GAAG,IAAI,CAkF7E"}