@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -50,15 +50,24 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     var e = new Error(message);
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
+import { assertDarwinCreationAcl, assertPrivateCreationFile } from "./creation-boundary.js";
 import { requireNativeBinding } from "./native.js";
 import { syncFileBestEffortSync } from "./file-sync.js";
 import { randomUUID } from "node:crypto";
-import fs from "node:fs";
+import fs, {} from "node:fs";
+import path from "node:path";
 import { FsSafeError } from "./errors.js";
-import { writeNativeInput } from "./native-operations.js";
+import { assertSynchronousCallbackResult, MutationAuthorityError } from "./mutation-authority.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { writePinnedInput } from "./pinned-write-input.js";
+import { assertNativeCopyCompleted, createNativeCopyFile } from "./copy-file-input.js";
 import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
+import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
+import { classifyNativeRenameFailure } from "./native-rename-outcome.js";
+import { createStagedFileReceipt, stagedFileFailure as failure } from "./staged-file-settlement.js";
 export function assertNativeStaging(binding) {
     if ([
+        binding.closeOwnedFd,
         binding.createStagedFile,
         binding.stagedFileMatches,
         binding.removeStagedFile,
@@ -75,46 +84,34 @@ function assertBasename(name, portable) {
     }
 }
 const NOT_PUBLISHED = Object.freeze({ status: "not-published" });
-const UNCOMMITTED_RENAME_ERRORS = new Set([
-    "EACCES", "EBADF", "EBUSY", "EEXIST", "EINVAL", "EISDIR", "ELOOP", "EMLINK",
-    "ENAMETOOLONG", "ENOENT", "ENOSPC", "ENOSYS", "ENOTDIR", "ENOTEMPTY", "ENOTSUP",
-    "EPERM", "EROFS", "ETXTBSY", "EXDEV",
-]);
-function failure(error, details) {
-    const code = error instanceof FsSafeError
-        ? error.code
-        : error?.code === "EEXIST" ? "already-exists" : "helper-failed";
-    return new FsSafeError(code, `staged file ${details.phase} failed`, { cause: error, details });
-}
 class NativeStagedFile {
-    #binding;
-    #parentFd;
-    #directory;
-    #portableNames;
-    #publishedMode;
-    #sync;
-    #name = `.fs-safe-${randomUUID()}.tmp`;
+    #owner;
+    #closeFd;
+    #assertBeforeMutation;
+    #private;
+    #verifyMode;
     #state = { status: "open", publication: NOT_PUBLISHED };
     #receipt;
-    constructor(binding, parentFd, directory, portableNames, publishedMode, sync) {
-        this.#binding = binding;
-        this.#parentFd = parentFd;
-        this.#directory = directory;
-        this.#portableNames = portableNames;
-        this.#publishedMode = publishedMode;
-        this.#sync = sync;
+    #rejectFinalSymlink = false;
+    constructor(owner) {
+        const name = owner.name ?? `.fs-safe-${randomUUID()}.tmp`;
+        assertBasename(name, owner.portableNames !== false);
+        this.#closeFd = captureNativeFdClose(owner.binding);
+        this.#owner = { ...owner, name };
+        this.#assertBeforeMutation = owner.assertBeforeMutation;
+        this.#private = owner.permissionPolicy === "private-creation";
+        this.#verifyMode = owner.permissionPolicy !== undefined;
     }
-    // Takes ownership of parentFd, including all construction and preparation failures.
-    static async create(binding, parentFd, directory, input, mode, maxBytes, 
-    // Public staging uses portable names; existing POSIX writes accept literal names.
-    portableNames = true, sync = true) {
+    // Public staging supplies a Node parent; pinned writes supply a native parent.
+    // The supplied closer owns parentFd even on construction or preparation failure.
+    static async create(owner, input, maxBytes) {
         let staged;
         try {
-            staged = new NativeStagedFile(binding, parentFd, directory, portableNames, mode, sync);
+            staged = new NativeStagedFile(owner);
         }
         catch (error) {
             try {
-                fs.closeSync(parentFd);
+                owner.closeParentFd(owner.parentFd);
             }
             catch (closeError) {
                 throw new AggregateError([error, closeError], "staged owner construction and close failed");
@@ -124,15 +121,41 @@ class NativeStagedFile {
         await staged.#prepare(input, maxBytes);
         return staged;
     }
-    static async write(binding, parentFd, directory, params, parentGuard) {
+    static async write(binding, parentFd, closeParentFd, directory, params, parentGuard) {
         const env_1 = { stack: [], error: void 0, hasError: false };
         try {
+            const exclusive = params.overwrite === false && params.input.kind === "buffer" && params.input.stageBeforePublish === false;
             // This owner never escapes. Only the internal verifier borrows its fd;
             // public descriptor methods remain await-free and cannot race disposal.
-            const staged = __addDisposableResource(env_1, await NativeStagedFile.create(binding, parentFd, directory, params.input, params.mode, params.maxBytes, false, params.sync), true);
-            const published = await staged.publish(params.basename, { overwrite: params.overwrite !== false });
+            const staged = __addDisposableResource(env_1, await NativeStagedFile.create({
+                binding, parentFd, closeParentFd, directory, mode: params.mode, sync: params.sync,
+                // Public staging uses portable names; existing POSIX writes accept literal names.
+                portableNames: false, assertBeforeMutation: params.assertBeforeMutation,
+                name: exclusive ? params.basename : undefined, strictFileSync: params.strictFileSync,
+                permissionPolicy: params.private ? "private-creation" : params.verifyPosixMode === true ? "mode-only" : undefined,
+            }, params.input, params.maxBytes), true);
+            staged.#rejectFinalSymlink = params.rejectFinalSymlink === true;
+            if (params.input.kind === "file")
+                await params.input.verifySource();
+            if (exclusive) {
+                staged.#assertCurrent();
+                params.assertBeforeMutation?.();
+                if (staged.#verifyMode)
+                    staged.#assertCurrent();
+            }
+            const published = exclusive
+                ? staged.#completePublication(params.basename, false, params.onPublished)
+                : await staged.publish(params.basename, { overwrite: params.overwrite !== false }, params.onPublished);
             const identity = published.staged.identity;
-            await params.verifyPublished?.(staged.#file(), identity, parentGuard);
+            try {
+                await params.verifyPublished?.(staged.#file(), identity, parentGuard);
+            }
+            catch (error) {
+                if (params.overwrite === false && params.input.kind !== "file" && params.input.stageBeforePublish === true) {
+                    throw failure(error, { phase: "publish", publication: published });
+                }
+                throw error;
+            }
             return { dev: identity.dev, ino: identity.ino };
         }
         catch (e_1) {
@@ -164,54 +187,96 @@ class NativeStagedFile {
         }
         return state.fileFd;
     }
-    #assertNamed(name) {
+    #assertNamed(name, expectedMode) {
         const fd = this.#file();
-        const stat = this.#binding.stagedFileMatches(this.#parentFd, name, fd)
+        const stat = this.#owner.binding.stagedFileMatches(this.#owner.parentFd, name, fd)
             ? fs.fstatSync(fd, { bigint: true }) : undefined;
         if (!stat || stat.nlink !== 1n) {
             throw new FsSafeError("path-mismatch", "staged entry no longer names the exclusive created file");
         }
+        this.#assertPermissions(fd, stat, expectedMode);
         return Number(stat.mode & 4095n);
     }
     #assertCurrent() {
         if (this.#open().publication.status !== "not-published") {
             throw new FsSafeError("helper-failed", "staged file publication has already been attempted");
         }
-        assertStagedDirectoryCurrent(this.#directory);
-        this.#assertNamed(this.#name);
+        assertStagedDirectoryCurrent(this.#owner.directory);
+        this.#assertNamed(this.#owner.name, 0o600);
+    }
+    #assertPermissions(fd, stat, expectedMode) {
+        if (this.#private)
+            assertPrivateCreationFile(stat, fd);
+        if (this.#verifyMode && Number(stat.mode & 4095n) !== expectedMode) {
+            throw new FsSafeError("insecure-permissions", "filesystem did not enforce the staged file mode");
+        }
+    }
+    #assertStagePermissions(fd) {
+        this.#assertPermissions(fd, fs.fstatSync(fd, { bigint: true }), 0o600);
     }
     async #prepare(input, maxBytes) {
         try {
-            const mode = this.#publishedMode;
+            const mode = this.#owner.mode;
             if (!Number.isInteger(mode) || mode < 0 || mode > 0o7777) {
                 throw new FsSafeError("invalid-path", "invalid staged file mode");
             }
-            assertStagedDirectoryCurrent(this.#directory);
+            const fileSignal = input.kind === "file" && this.#verifyMode ? input.signal : undefined;
+            if (input.kind === "file" && this.#verifyMode) {
+                fileSignal?.throwIfAborted();
+                if (input.clone === "always") {
+                    throw new FsSafeError("helper-unavailable", "required cloning cannot verify staged permissions before copying");
+                }
+            }
+            assertStagedDirectoryCurrent(this.#owner.directory);
             // The exclusive open performs no fallible post-open checks. Store its fd
             // before every subsequent operation, including the first metadata read.
             const state = this.#open();
-            state.fileFd = this.#binding.createStagedFile(this.#parentFd, this.#name);
+            if (this.#private)
+                assertDarwinCreationAcl(this.#owner.parentFd, "file");
+            this.#assertBeforeMutation?.();
+            if (this.#private)
+                assertDarwinCreationAcl(this.#owner.parentFd, "file");
+            // Native copying populates its new file before returning its descriptor.
+            const copied = input.kind === "file" && !this.#verifyMode
+                ? await createNativeCopyFile(this.#owner.binding, input, this.#owner.parentFd, this.#owner.name, maxBytes, false)
+                : undefined;
+            state.fileFd = copied?.fd;
+            if (state.fileFd === undefined) {
+                this.#assertBeforeMutation?.();
+                if (this.#private)
+                    assertDarwinCreationAcl(this.#owner.parentFd, "file");
+                state.fileFd = this.#owner.binding.createStagedFile(this.#owner.parentFd, this.#owner.name);
+            }
             const fd = state.fileFd;
+            if (input.kind === "file")
+                assertNativeCopyCompleted(input, copied);
+            const assertBeforeChmod = this.#assertBeforeMutation;
+            const beforeChmodResult = assertBeforeChmod?.();
+            if (this.#private) {
+                assertSynchronousCallbackResult(beforeChmodResult, "assertBeforeMutation");
+                assertPrivateCreationFile(fs.fstatSync(fd, { bigint: true }), fd);
+            }
             fs.fchmodSync(fd, 0o600);
-            await writeNativeInput(fd, input, maxBytes);
-            if (this.#sync)
-                syncFileBestEffortSync(fd);
+            // Some filesystems report successful chmod without enforcing its mode.
+            if (this.#verifyMode)
+                this.#assertStagePermissions(fd);
+            const assertBeforeMutation = this.#verifyMode ? () => {
+                assertSynchronousCallbackResult(this.#assertBeforeMutation?.(), "assertBeforeMutation");
+                fileSignal?.throwIfAborted();
+                this.#assertStagePermissions(fd);
+            } : this.#assertBeforeMutation;
+            if (!copied)
+                await writePinnedInput(fd, input, maxBytes, assertBeforeMutation);
+            if (this.#verifyMode)
+                this.#assertStagePermissions(fd);
+            if (this.#owner.sync !== false) {
+                if (this.#owner.strictFileSync)
+                    fs.fsyncSync(fd);
+                else
+                    syncFileBestEffortSync(fd);
+            }
             const stat = fs.fstatSync(fd, { bigint: true });
-            this.#receipt = Object.freeze({
-                directory: this.#directory,
-                temporaryBasename: this.#name,
-                identity: Object.freeze({
-                    dev: stat.dev,
-                    ino: stat.ino,
-                    mode: Number(stat.mode & 4095n),
-                    nlink: stat.nlink,
-                    size: stat.size,
-                    uid: Number(stat.uid),
-                    gid: Number(stat.gid),
-                    mtimeNs: stat.mtimeNs,
-                    ctimeNs: stat.ctimeNs,
-                }),
-            });
+            this.#receipt = createStagedFileReceipt(this.#owner.directory, this.#owner.name, stat);
             this.#assertCurrent();
         }
         catch (error) {
@@ -230,58 +295,41 @@ class NativeStagedFile {
     async assertCurrent() {
         this.#assertCurrent();
     }
-    async publish(basename, options) {
+    async publish(basename, options, onPublished) {
         const overwrite = options?.overwrite;
         try {
             const state = this.#open();
-            assertBasename(basename, this.#portableNames);
-            if (basename === this.#name || typeof overwrite !== "boolean") {
+            assertBasename(basename, this.#owner.portableNames !== false);
+            if (basename === this.#owner.name || typeof overwrite !== "boolean") {
                 throw new FsSafeError("invalid-path", "publication needs a distinct basename and explicit overwrite policy");
             }
             this.#assertCurrent();
+            assertFinalSymlinkRejected(path.join(this.#owner.directory.realPath, basename), this.#rejectFinalSymlink);
+            this.#assertBeforeMutation?.();
+            if (this.#assertBeforeMutation) {
+                this.#assertCurrent();
+                assertFinalSymlinkRejected(path.join(this.#owner.directory.realPath, basename), this.#rejectFinalSymlink);
+            }
             try {
                 if (overwrite) {
-                    this.#binding.renameReplace(this.#parentFd, this.#name, this.#parentFd, basename);
+                    this.#owner.binding.renameReplace(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
                 }
                 else {
-                    this.#binding.renameNoReplace(this.#parentFd, this.#name, this.#parentFd, basename);
+                    this.#owner.binding.renameNoReplace(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
                 }
             }
             catch (error) {
-                // Unknown rename errors can be indeterminate on remote filesystems.
-                if (!UNCOMMITTED_RENAME_ERRORS.has(error?.code ?? "")) {
+                // Only explicit pre-dispatch provenance can rule out a committed rename.
+                if (classifyNativeRenameFailure(error) === "indeterminate") {
                     state.publication = Object.freeze({ status: "indeterminate", basename, overwrite });
                 }
                 throw error;
             }
-            // Commit is recorded synchronously before any post-rename operation.
-            const receipt = Object.freeze({
-                status: "published",
-                staged: this.receipt,
-                basename,
-                overwrite,
-            });
-            state.publication = receipt;
-            const stagedMode = this.#assertNamed(basename);
-            assertStagedDirectoryCurrent(this.#directory);
-            // Keep contents private until the published name passes its identity
-            // fence. Mode changes use the owned fd, including for final mode 000.
-            const fd = this.#file();
-            if (this.#publishedMode !== 0o600 || stagedMode !== 0o600)
-                fs.fchmodSync(fd, this.#publishedMode);
-            // With sync enabled, content was synced before rename. A lost chmod leaves staged 0600,
-            // no wider than modes retaining owner rw. Restrictive modes and observed
-            // widening of the stage still need the permission correction made durable.
-            if (this.#sync && ((this.#publishedMode & 0o600) !== 0o600 || (stagedMode & ~this.#publishedMode) !== 0)) {
-                syncFileBestEffortSync(fd);
-            }
-            if (this.#sync)
-                syncFileBestEffortSync(this.#parentFd);
-            this.#assertNamed(basename);
-            assertStagedDirectoryCurrent(this.#directory);
-            return receipt;
+            return this.#completePublication(basename, overwrite, onPublished);
         }
         catch (error) {
+            if (error instanceof MutationAuthorityError)
+                throw error;
             // Closure rejects further use, not the recorded outcome of an earlier publication.
             const publication = this.#state.status === "closed"
                 ? this.#state.receipt.publication
@@ -289,6 +337,32 @@ class NativeStagedFile {
             throw failure(error, { phase: "publish", publication });
         }
     }
+    #completePublication(basename, overwrite, onPublished) {
+        // Record complete content before fallible post-publication verification.
+        const receipt = Object.freeze({ status: "published", staged: this.receipt, basename, overwrite });
+        this.#open().publication = receipt;
+        onPublished?.(receipt.staged.identity);
+        const stagedMode = this.#assertNamed(basename, 0o600);
+        assertStagedDirectoryCurrent(this.#owner.directory);
+        // Keep contents private until the name passes its identity fence. Mode
+        // changes use the owned fd, including for final mode 000.
+        const fd = this.#file();
+        if (this.#owner.mode !== 0o600 || stagedMode !== 0o600)
+            fs.fchmodSync(fd, this.#owner.mode);
+        // Content was synced during preparation. A lost chmod leaves 0600, no wider
+        // than modes retaining owner rw; restrictive modes still need a durable correction.
+        if (this.#owner.sync !== false && ((this.#owner.mode & 0o600) !== 0o600 || (stagedMode & ~this.#owner.mode) !== 0)) {
+            if (this.#owner.strictFileSync)
+                fs.fsyncSync(fd);
+            else
+                syncFileBestEffortSync(fd);
+        }
+        if (this.#owner.sync !== false)
+            syncFileBestEffortSync(this.#owner.parentFd);
+        this.#assertNamed(basename, this.#owner.mode);
+        assertStagedDirectoryCurrent(this.#owner.directory);
+        return receipt;
+    }
     #finalize() {
         if (this.#state.status === "closed") {
             return this.#state;
@@ -301,7 +375,7 @@ class NativeStagedFile {
         }
         else if (state.publication.status === "not-published" && state.fileFd !== undefined) {
             try {
-                outcome = this.#binding.removeStagedFile(this.#parentFd, this.#name, state.fileFd);
+                outcome = this.#owner.binding.removeStagedFile(this.#owner.parentFd, this.#owner.name, state.fileFd);
             }
             catch (error) {
                 outcome = "failed";
@@ -309,12 +383,15 @@ class NativeStagedFile {
             }
         }
         let resources = "closed";
-        for (const fd of [state.fileFd, this.#parentFd]) {
+        for (const [fd, closeFd] of [
+            [state.fileFd, this.#closeFd],
+            [this.#owner.parentFd, this.#owner.closeParentFd],
+        ]) {
             if (fd === undefined) {
                 continue;
             }
             try {
-                fs.closeSync(fd);
+                closeFd(fd);
             }
             catch (error) {
                 resources = "close-failed";
@@ -322,7 +399,7 @@ class NativeStagedFile {
             }
         }
         const receipt = Object.freeze({
-            temporaryBasename: this.#name,
+            temporaryBasename: this.#owner.name,
             publication: state.publication,
             status: outcome,
             resources,
@@ -358,5 +435,8 @@ export async function stageFileInDirectory(options) {
     const input = { kind: "buffer", data: Buffer.from(options.content) };
     const mode = options.mode ?? 0o600;
     const parent = openStagedDirectory(options.directory);
-    return await createNativeStage(binding, parent.fd, parent.receipt, input, mode);
+    return await createNativeStage({
+        binding, parentFd: parent.fd, closeParentFd: fs.closeSync,
+        directory: parent.receipt, mode, permissionPolicy: "mode-only",
+    }, input);
 }

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

@@ -1,4 +1,4 @@
-import type { NativeBinding } from "./native-binding.js";
+import { type NativeBinding } from "./native-binding.js";
 export type { NativeBinding } from "./native-binding.js";
 export declare function __loadBundledNativeForTest(): NativeBinding;
 export declare function __nativeLoaderDetectorsForTest(): {
@@ -11,4 +11,3 @@ export declare function getNativeBinding(): NativeBinding | undefined;
 export declare function requireNativeBinding(): NativeBinding;
 export declare function __setNativeLoaderForTest(loader: () => NativeBinding): void;
 export declare function __resetNativeLoaderForTest(): void;
-//# sourceMappingURL=native.d.ts.map

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

@@ -1,6 +1,7 @@
 import { closeSync, openSync, readSync, readdirSync, } from "node:fs";
 import { createRequire } from "node:module";
 import { FsSafeError } from "./errors.js";
+import { captureNativeFdClose } from "./native-binding.js";
 import { getFsSafeNativeConfig } from "./native-config.js";
 const require = createRequire(import.meta.url);
 let binding;
@@ -21,7 +22,7 @@ function isMuslFromReport() {
             return true;
     }
     catch {
-        // Continue with filesystem and ELF inspection.
+        // Continue with ELF and filesystem inspection.
     }
     return undefined;
 }
@@ -113,7 +114,7 @@ function isMuslFromElfInterpreter() {
 function isMusl() {
     if (process.platform !== "linux")
         return false;
-    for (const detector of [isMuslFromReport, isMuslFromFilesystem, isMuslFromElfInterpreter]) {
+    for (const detector of [isMuslFromReport, isMuslFromElfInterpreter, isMuslFromFilesystem]) {
         const result = detector();
         if (result !== undefined)
             return result;
@@ -144,7 +145,9 @@ function loadBundledBinding() {
     if (!target) {
         throw new Error(`Unsupported OS or architecture: ${process.platform}-${process.arch}`);
     }
-    return require(nativePackageForTarget(target));
+    const loaded = require(nativePackageForTarget(target));
+    captureNativeFdClose(loaded);
+    return loaded;
 }
 export function __loadBundledNativeForTest() {
     return loadBundledBinding();
@@ -166,7 +169,9 @@ export function getNativeBinding() {
     if (!attempted) {
         attempted = true;
         try {
-            binding = loadBinding();
+            const loaded = loadBinding();
+            captureNativeFdClose(loaded);
+            binding = loaded;
         }
         catch (error) {
             loadError = error;

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

@@ -1,8 +1,7 @@
-import type { BigIntStats } from "node:fs";
+import { type BigIntStats } from "node:fs";
 import type { FileHandle } from "node:fs/promises";
 export declare function recordFileOpenFailure(error: unknown, filePath: string): never;
 export declare function recordExclusiveCreateFailure(error: unknown, filePath: string): never;
 export declare function openedPathResolutionError(error?: Error): Error;
 export declare function recordPreOpenFileChange(error: unknown, handle: FileHandle, filePath: string, before: BigIntStats | undefined, opened: BigIntStats | undefined): Promise<void>;
 export declare function recordOpenedFileFailure(error: unknown, handle: FileHandle, filePath: string, identity: BigIntStats): Promise<void>;
-//# sourceMappingURL=opened-file-failure.d.ts.map

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

@@ -1,3 +1,4 @@
+import fsSync, {} from "node:fs";
 import { FsSafeError } from "./errors.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
 import { isFileObservationFailure, recordFileObservationFailure } from "./file-observation.js";
@@ -19,7 +20,7 @@ export async function recordPreOpenFileChange(error, handle, filePath, before, o
         return;
     try {
         await inspectFileIdentity(async () => before);
-        const current = await inspectFileIdentity(() => handle.stat({ bigint: true }), opened);
+        const current = await inspectFileIdentity(() => fsSync.fstatSync(handle.fd, { bigint: true }), opened);
         if (current.isFile() && [0n, 1n].includes(current.nlink) &&
             (before.dev !== current.dev || before.ino !== current.ino)) {
             // A stale pathname sample is not proof that its former inode was unlinked.
@@ -35,7 +36,7 @@ export async function recordOpenedFileFailure(error, handle, filePath, identity)
         !identity.isFile() || identity.nlink > 1n)
         return;
     try {
-        const current = await inspectFileIdentity(() => handle.stat({ bigint: true }), identity);
+        const current = await inspectFileIdentity(() => fsSync.fstatSync(handle.fd, { bigint: true }), identity);
         if (current.isFile() && current.nlink === 0n)
             recordFileObservationFailure(error, `unlinked:${filePath}`);
     }

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

@@ -13,4 +13,3 @@ export declare function resolveOpenedFileRealPathForFd(fd: number, handleStat: F
     realPath: string;
     stat: Stats | BigIntStats;
 }>;
-//# sourceMappingURL=opened-realpath.d.ts.map

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

@@ -4,9 +4,19 @@ import path from "node:path";
 import { openedPathResolutionError } from "./opened-file-failure.js";
 import { sameFileIdentity } from "./file-identity.js";
 import { isNotFoundPathError } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 export async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
-    const handleStat = fsSync.fstatSync(handle.fd);
-    return (await resolveOpenedFileRealPathForFd(handle.fd, handleStat, ioPath)).realPath;
+    const fd = handle.fd;
+    const identity = inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }));
+    const resolved = await resolveOpenedFileRealPathForFd(fd, identity, ioPath);
+    let first = resolved.stat;
+    inspectFileIdentitySync(() => {
+        const current = first ?? fsSync.statSync(resolved.realPath, { bigint: true });
+        first = undefined;
+        return current;
+    }, identity);
+    return resolved.realPath;
 }
 export async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
     const statOptions = typeof handleStat.dev === "bigint" || typeof handleStat.ino === "bigint"
@@ -16,7 +26,7 @@ export async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
         : [];
     for (const fdPath of fdCandidates) {
         try {
-            const fdRealPath = fsSync.realpathSync.native(fdPath);
+            const fdRealPath = realpathSync.native(fdPath);
             const fdRealStat = statOptions ? fsSync.statSync(fdRealPath, statOptions) : fsSync.statSync(fdRealPath);
             if (sameFileIdentity(handleStat, fdRealStat)) {
                 return { realPath: fdRealPath, stat: fdRealStat };
@@ -27,7 +37,7 @@ export async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
         }
     }
     try {
-        const ioRealPath = fsSync.realpathSync.native(ioPath);
+        const ioRealPath = realpathSync.native(ioPath);
         const ioRealStat = statOptions ? fsSync.statSync(ioRealPath, statOptions) : fsSync.statSync(ioRealPath);
         if (sameFileIdentity(handleStat, ioRealStat)) {
             return { realPath: ioRealPath, stat: ioRealStat };
@@ -53,7 +63,7 @@ export async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
 async function resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptions) {
     let parentReal;
     try {
-        parentReal = fsSync.realpathSync.native(path.dirname(ioPath));
+        parentReal = realpathSync.native(path.dirname(ioPath));
     }
     catch (err) {
         if (isNotFoundPathError(err)) {
@@ -76,7 +86,7 @@ async function resolveOpenedFileRealPathFromParent(handleStat, ioPath, statOptio
         try {
             const candidateStat = statOptions ? fsSync.lstatSync(candidatePath, statOptions) : fsSync.lstatSync(candidatePath);
             if (candidateStat.isFile() && sameFileIdentity(handleStat, candidateStat)) {
-                const realPath = fsSync.realpathSync.native(candidatePath);
+                const realPath = realpathSync.native(candidatePath);
                 const stat = statOptions ? fsSync.statSync(realPath, statOptions) : fsSync.statSync(realPath);
                 if (sameFileIdentity(handleStat, stat))
                     return { realPath, stat };

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

@@ -5,6 +5,8 @@ export type ExternalFileWriteOptions<T = void> = {
     maxBytes?: number;
     mode?: number;
     staging?: "workspace" | "sibling";
+    /** Isolate sibling producers; workspace staging is already private. */
+    producerIsolation?: "private-directory";
     fallbackFileName?: string;
 };
 export type ExternalFileWriteResult<T = void> = {
@@ -12,4 +14,3 @@ export type ExternalFileWriteResult<T = void> = {
     result: T;
 };
 export declare function writeExternalFileWithinRoot<T = void>(options: ExternalFileWriteOptions<T>): Promise<ExternalFileWriteResult<T>>;
-//# sourceMappingURL=output.d.ts.map