@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

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

@@ -0,0 +1,7 @@
+import type { RenameIdentityPolicy } from "./pinned-write.js";
+export type { RenameIdentityPolicy };
+export declare function validateRenameIdentity(policy: RenameIdentityPolicy | undefined): void;
+export declare function atomicExpectedContentHash(policy: RenameIdentityPolicy | undefined, content: string | Uint8Array): string | undefined;
+export declare function withAtomicRenameIdentityLock<T>(filePath: string, fn: () => Promise<T>): Promise<T>;
+export declare function withAtomicRenameIdentityLockSync<T>(filePath: string, fn: () => T): T;
+//# sourceMappingURL=replace-file-rename-policy.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/replace-file-rename-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-file-rename-policy.d.ts","sourceRoot":"","sources":["../src/replace-file-rename-policy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAE9D,YAAY,EAAE,oBAAoB,EAAE,CAAC;AAErC,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,oBAAoB,GAAG,SAAS,GAAG,IAAI,CAIrF;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,oBAAoB,GAAG,SAAS,EACxC,OAAO,EAAE,MAAM,GAAG,UAAU,GAC3B,MAAM,GAAG,SAAS,CAGpB;AAcD,wBAAsB,4BAA4B,CAAC,CAAC,EAClD,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED,wBAAgB,gCAAgC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAEpF"}

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

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { withFileLock, withFileLockSync } from "./file-lock.js";
+import { sha256Hex } from "./file-identity.js";
+export function validateRenameIdentity(policy) {
+    if (policy !== undefined && policy !== "strict" && policy !== "verify-content-with-lock") {
+        throw new RangeError("renameIdentity must be strict or verify-content-with-lock");
+    }
+}
+export function atomicExpectedContentHash(policy, content) {
+    if (policy !== "verify-content-with-lock")
+        return undefined;
+    return sha256Hex(typeof content === "string" ? content : Buffer.from(content));
+}
+function lockOptions(filePath) {
+    const resolved = path.resolve(filePath);
+    return {
+        managerKey: `fs-safe.atomic:${resolved}`,
+        lockPath: path.join(path.dirname(resolved), `.fs-safe-atomic-${sha256Hex(resolved)}.lock`),
+        staleMs: 30_000,
+        timeoutMs: 5_000,
+        payload: () => ({ pid: process.pid, createdAt: new Date().toISOString() }),
+        retry: { retries: 5, minTimeout: 100, maxTimeout: 2_000, factor: 2 },
+    };
+}
+export async function withAtomicRenameIdentityLock(filePath, fn) {
+    return await withFileLock(filePath, lockOptions(filePath), fn);
+}
+export function withAtomicRenameIdentityLockSync(filePath, fn) {
+    return withFileLockSync(filePath, lockOptions(filePath), fn);
+}

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

@@ -0,0 +1,53 @@
+import syncFs, { type BigIntStats } from "node:fs";
+import fs, { type FileHandle } from "node:fs/promises";
+import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
+type AsyncOwnerFileSystem = Pick<typeof fs, "lstat" | "open" | "unlink">;
+type SyncOwnerFileSystem = Pick<typeof syncFs, "closeSync" | "fstatSync" | "lstatSync" | "openSync" | "readFileSync" | "unlinkSync">;
+export declare function cleanupPinnedFilePath(params: {
+    pathname: string;
+    handle: FileHandle;
+    identity?: BigIntStats;
+    parentGuard: AnyAsyncDirectoryGuard;
+}): Promise<void>;
+export declare class AsyncAtomicTempOwner {
+    #private;
+    readonly pathname: string;
+    constructor(pathname: string);
+    start(): void;
+    readonly onIdentity: (identity: BigIntStats) => void;
+    adopt(temp: {
+        handle: FileHandle;
+        identity: BigIntStats;
+    }): void;
+    get identity(): BigIntStats;
+    assertCurrent(fsModule: AsyncOwnerFileSystem, pathname?: string): Promise<void>;
+    assertPublished(fsModule: AsyncOwnerFileSystem, pathname: string, expectedHash?: string): Promise<void>;
+    markRenamed(): void;
+    finish(params: {
+        fsModule: AsyncOwnerFileSystem;
+        originalError?: unknown;
+        throwOnCleanupError: boolean;
+    }): Promise<void>;
+}
+export declare class SyncAtomicTempOwner {
+    #private;
+    readonly pathname: string;
+    constructor(pathname: string);
+    start(): void;
+    readonly onIdentity: (identity: BigIntStats) => void;
+    adopt(temp: {
+        fd: number;
+        identity: BigIntStats;
+    }): void;
+    get identity(): BigIntStats;
+    assertCurrent(fsModule: SyncOwnerFileSystem, pathname?: string): void;
+    assertPublished(fsModule: SyncOwnerFileSystem, pathname: string, expectedHash?: string): void;
+    markRenamed(): void;
+    finish(params: {
+        fsModule: SyncOwnerFileSystem;
+        originalError?: unknown;
+        throwOnCleanupError: boolean;
+    }): void;
+}
+export {};
+//# sourceMappingURL=replace-file-temp-owner.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/replace-file-temp-owner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-file-temp-owner.d.ts","sourceRoot":"","sources":["../src/replace-file-temp-owner.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,EAAE,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,EAAE,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAA6B,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAO9F,KAAK,oBAAoB,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC;AACzE,KAAK,mBAAmB,GAAG,IAAI,CAC7B,OAAO,MAAM,EACb,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,cAAc,GAAG,YAAY,CACrF,CAAC;AAgEF,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,WAAW,EAAE,sBAAsB,CAAC;CACrC,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBhB;AA+BD,qBAAa,oBAAoB;;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAM1B,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,QAAQ,CAAC,UAAU,aAAc,WAAW,KAAG,IAAI,CAGjD;IAEF,KAAK,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAG/D;IAED,IAAI,QAAQ,IAAI,WAAW,CAG1B;IAEK,aAAa,CAAC,QAAQ,EAAE,oBAAoB,EAAE,QAAQ,SAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB3F;IAEK,eAAe,CACnB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CA4Cf;IAED,WAAW,IAAI,IAAI,CAGlB;IAEK,MAAM,CAAC,MAAM,EAAE;QACnB,QAAQ,EAAE,oBAAoB,CAAC;QAC/B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;KAC9B,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB;CACF;AAED,qBAAa,mBAAmB;;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAM1B,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,QAAQ,CAAC,UAAU,aAAc,WAAW,KAAG,IAAI,CAGjD;IAEF,KAAK,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAGvD;IAED,IAAI,QAAQ,IAAI,WAAW,CAG1B;IAED,aAAa,CAAC,QAAQ,EAAE,mBAAmB,EAAE,QAAQ,SAAgB,GAAG,IAAI,CAkB3E;IAED,eAAe,CACb,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,CAgDN;IAED,WAAW,IAAI,IAAI,CAGlB;IAED,MAAM,CAAC,MAAM,EAAE;QACb,QAAQ,EAAE,mBAAmB,CAAC;QAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;KAC9B,GAAG,IAAI,CAgCP;CACF"}

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

@@ -0,0 +1,376 @@
+import syncFs, {} from "node:fs";
+import fs, {} from "node:fs/promises";
+import { assertAsyncDirectoryGuard } from "./directory-guard.js";
+import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup, sha256Hex } from "./file-identity.js";
+import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
+import { registerTempPathForExit } from "./temp-cleanup.js";
+const PUBLISHED_READ_FLAGS = resolveReadOpenFlags();
+function assertOwnedFile(stat, pathname, pathnameEntry) {
+    if (stat.isSymbolicLink()) {
+        throw new FsSafeError("symlink", `Atomic replace owned file became a symlink: ${pathname}`);
+    }
+    if (!stat.isFile()) {
+        throw new FsSafeError("not-file", `Atomic replace owned file must remain regular: ${pathname}`);
+    }
+    if (stat.nlink > 1n || (pathnameEntry && stat.nlink !== 1n)) {
+        throw new FsSafeError("hardlink", `Atomic replace owned file must retain one link: ${pathname}`);
+    }
+}
+function missingOwnedFile(pathname, cause) {
+    return new FsSafeError("path-mismatch", `Atomic replace owned file disappeared: ${pathname}`, {
+        cause,
+    });
+}
+function cleanupFailure(originalError, cleanupError) {
+    if (originalError !== undefined) {
+        return new Error(`Atomic file replace failed (${String(originalError)}); cleanup also failed (${String(cleanupError)})`, { cause: originalError });
+    }
+    return cleanupError instanceof Error ? cleanupError : new Error(String(cleanupError));
+}
+async function cleanupOwnedPath(params) {
+    if (!params.identity)
+        return true;
+    try {
+        const current = params.fsModule === fs
+            ? syncFs.lstatSync(params.pathname, { bigint: true })
+            : await params.fsModule.lstat(params.pathname, { bigint: true });
+        if (current.isSymbolicLink() ||
+            !current.isFile() ||
+            current.nlink !== 1n ||
+            !sameFileIdentityForCleanup(current, params.identity)) {
+            return true;
+        }
+        await params.fsModule.unlink(params.pathname);
+        return true;
+    }
+    catch (cleanupError) {
+        if (cleanupError.code === "ENOENT")
+            return true;
+        if (params.throwOnCleanupError) {
+            throw cleanupFailure(params.originalError, cleanupError);
+        }
+        return false;
+    }
+}
+// Borrowed handle: the caller retains it until this best-effort cleanup finishes.
+export async function cleanupPinnedFilePath(params) {
+    if (!params.identity)
+        return;
+    try {
+        const guard = params.parentGuard;
+        if ([guard.stat.dev, guard.stat.ino].some((value) => typeof value === "number" && !Number.isSafeInteger(value)))
+            return;
+        await assertAsyncDirectoryGuard(guard);
+        const parent = syncFs.lstatSync(guard.dir, { bigint: true });
+        if (parent.isSymbolicLink() || !parent.isDirectory() ||
+            !sameFileIdentityForCleanup(parent, guard.stat))
+            return;
+        const opened = syncFs.fstatSync(params.handle.fd, { bigint: true });
+        if (!opened.isFile() || opened.nlink !== 1n ||
+            !sameFileIdentityForCleanup(opened, params.identity))
+            return;
+        await cleanupOwnedPath({
+            fsModule: fs,
+            pathname: params.pathname,
+            identity: params.identity,
+            throwOnCleanupError: false,
+        });
+    }
+    catch {
+        // Unverifiable authority must preserve the path and the original write failure.
+    }
+}
+function cleanupOwnedPathSync(params) {
+    if (!params.identity)
+        return true;
+    try {
+        const current = params.fsModule.lstatSync(params.pathname, { bigint: true });
+        if (current.isSymbolicLink() ||
+            !current.isFile() ||
+            current.nlink !== 1n ||
+            !sameFileIdentityForCleanup(current, params.identity)) {
+            return true;
+        }
+        params.fsModule.unlinkSync(params.pathname);
+        return true;
+    }
+    catch (cleanupError) {
+        if (cleanupError.code === "ENOENT")
+            return true;
+        if (params.throwOnCleanupError) {
+            throw cleanupFailure(params.originalError, cleanupError);
+        }
+        return false;
+    }
+}
+export class AsyncAtomicTempOwner {
+    pathname;
+    #handle;
+    #identity;
+    #exists = false;
+    #unregister;
+    constructor(pathname) {
+        this.pathname = pathname;
+        this.#unregister = registerTempPathForExit(pathname, { singleLinkFile: true });
+    }
+    start() {
+        this.#exists = true;
+    }
+    onIdentity = (identity) => {
+        this.#identity = identity;
+        this.#unregister.setIdentity(identity);
+    };
+    adopt(temp) {
+        this.#handle = temp.handle;
+        this.onIdentity(temp.identity);
+    }
+    get identity() {
+        if (!this.#identity)
+            throw new Error("Atomic temp owner has no identity");
+        return this.#identity;
+    }
+    async assertCurrent(fsModule, pathname = this.pathname) {
+        const opened = await inspectFileIdentity(async () => {
+            const stat = fsModule === fs ? syncFs.fstatSync(this.#handle.fd, { bigint: true })
+                : await this.#handle.stat({ bigint: true });
+            assertOwnedFile(stat, pathname, false);
+            return stat;
+        }, this.identity);
+        try {
+            await inspectFileIdentity(async () => {
+                const stat = fsModule === fs ? syncFs.lstatSync(pathname, { bigint: true })
+                    : await fsModule.lstat(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, opened);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw missingOwnedFile(pathname, error);
+            }
+            throw error;
+        }
+    }
+    async assertPublished(fsModule, pathname, expectedHash) {
+        try {
+            await this.assertCurrent(fsModule, pathname);
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof FsSafeError) || error.code !== "path-mismatch" || !expectedHash) {
+                throw error;
+            }
+        }
+        let published;
+        try {
+            try {
+                published = await fsModule.open(pathname, PUBLISHED_READ_FLAGS);
+            }
+            catch (error) {
+                if (error.code === "ELOOP") {
+                    throw new FsSafeError("symlink", `Atomic replace published file became a symlink: ${pathname}`, {
+                        cause: error,
+                    });
+                }
+                throw error;
+            }
+            const identity = await inspectFileIdentity(async () => {
+                const stat = fsModule === fs ? syncFs.fstatSync(published.fd, { bigint: true })
+                    : await published.stat({ bigint: true });
+                assertOwnedFile(stat, pathname, false);
+                return stat;
+            });
+            await inspectFileIdentity(async () => {
+                const stat = fsModule === fs ? syncFs.lstatSync(pathname, { bigint: true })
+                    : await fsModule.lstat(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, identity);
+            if (sha256Hex(await published.readFile()) !== expectedHash) {
+                throw new FsSafeError("path-mismatch", `Atomic replace published content changed: ${pathname}`);
+            }
+            await this.#handle?.close();
+            this.#handle = published;
+            this.#identity = identity;
+            published = undefined;
+        }
+        finally {
+            await published?.close().catch(() => undefined);
+        }
+    }
+    markRenamed() {
+        this.#exists = false;
+        this.#unregister();
+    }
+    async finish(params) {
+        let deferredError;
+        let cleanupComplete = !this.#exists;
+        if (this.#exists) {
+            try {
+                cleanupComplete = await cleanupOwnedPath({
+                    fsModule: params.fsModule,
+                    pathname: this.pathname,
+                    identity: this.#identity,
+                    originalError: params.originalError,
+                    throwOnCleanupError: params.throwOnCleanupError,
+                });
+            }
+            catch (error) {
+                deferredError = error;
+            }
+        }
+        if (cleanupComplete)
+            this.#unregister();
+        try {
+            await this.#handle?.close();
+        }
+        catch (closeError) {
+            deferredError = deferredError
+                ? new AggregateError([deferredError, closeError], "Atomic temp cleanup and close failed")
+                : params.originalError !== undefined
+                    ? new AggregateError([params.originalError, closeError], "Atomic file replace and close failed")
+                    : closeError;
+        }
+        if (deferredError)
+            throw deferredError;
+    }
+}
+export class SyncAtomicTempOwner {
+    pathname;
+    #fd;
+    #identity;
+    #exists = false;
+    #unregister;
+    constructor(pathname) {
+        this.pathname = pathname;
+        this.#unregister = registerTempPathForExit(pathname, { singleLinkFile: true });
+    }
+    start() {
+        this.#exists = true;
+    }
+    onIdentity = (identity) => {
+        this.#identity = identity;
+        this.#unregister.setIdentity(identity);
+    };
+    adopt(temp) {
+        this.#fd = temp.fd;
+        this.onIdentity(temp.identity);
+    }
+    get identity() {
+        if (!this.#identity)
+            throw new Error("Atomic temp owner has no identity");
+        return this.#identity;
+    }
+    assertCurrent(fsModule, pathname = this.pathname) {
+        const opened = inspectFileIdentitySync(() => {
+            const stat = fsModule.fstatSync(this.#fd, { bigint: true });
+            assertOwnedFile(stat, pathname, false);
+            return stat;
+        }, this.identity);
+        try {
+            inspectFileIdentitySync(() => {
+                const stat = fsModule.lstatSync(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, opened);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw missingOwnedFile(pathname, error);
+            }
+            throw error;
+        }
+    }
+    assertPublished(fsModule, pathname, expectedHash) {
+        try {
+            this.assertCurrent(fsModule, pathname);
+            return;
+        }
+        catch (error) {
+            if (!(error instanceof FsSafeError) || error.code !== "path-mismatch" || !expectedHash) {
+                throw error;
+            }
+        }
+        let publishedFd;
+        try {
+            try {
+                publishedFd = fsModule.openSync(pathname, PUBLISHED_READ_FLAGS);
+            }
+            catch (error) {
+                if (error.code === "ELOOP") {
+                    throw new FsSafeError("symlink", `Atomic replace published file became a symlink: ${pathname}`, {
+                        cause: error,
+                    });
+                }
+                throw error;
+            }
+            const identity = inspectFileIdentitySync(() => {
+                const stat = fsModule.fstatSync(publishedFd, { bigint: true });
+                assertOwnedFile(stat, pathname, false);
+                return stat;
+            });
+            inspectFileIdentitySync(() => {
+                const stat = fsModule.lstatSync(pathname, { bigint: true });
+                assertOwnedFile(stat, pathname, true);
+                return stat;
+            }, identity);
+            if (sha256Hex(fsModule.readFileSync(publishedFd)) !== expectedHash) {
+                throw new FsSafeError("path-mismatch", `Atomic replace published content changed: ${pathname}`);
+            }
+            fsModule.closeSync(this.#fd);
+            this.#fd = publishedFd;
+            this.#identity = identity;
+            publishedFd = undefined;
+        }
+        finally {
+            if (publishedFd !== undefined) {
+                try {
+                    fsModule.closeSync(publishedFd);
+                }
+                catch {
+                    // Best-effort close after a rejected content verification.
+                }
+            }
+        }
+    }
+    markRenamed() {
+        this.#exists = false;
+        this.#unregister();
+    }
+    finish(params) {
+        let deferredError;
+        let cleanupComplete = !this.#exists;
+        if (this.#exists) {
+            try {
+                cleanupComplete = cleanupOwnedPathSync({
+                    fsModule: params.fsModule,
+                    pathname: this.pathname,
+                    identity: this.#identity,
+                    originalError: params.originalError,
+                    throwOnCleanupError: params.throwOnCleanupError,
+                });
+            }
+            catch (error) {
+                deferredError = error;
+            }
+        }
+        if (cleanupComplete)
+            this.#unregister();
+        if (this.#fd !== undefined) {
+            try {
+                params.fsModule.closeSync(this.#fd);
+            }
+            catch (closeError) {
+                deferredError = deferredError
+                    ? new AggregateError([deferredError, closeError], "Atomic temp cleanup and close failed")
+                    : params.originalError !== undefined
+                        ? new AggregateError([params.originalError, closeError], "Atomic file replace and close failed")
+                        : closeError;
+            }
+        }
+        if (deferredError)
+            throw deferredError;
+    }
+}

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

@@ -0,0 +1,58 @@
+import syncFs from "node:fs";
+import fs from "node:fs/promises";
+import { type ReplaceFileAtomicRestoreCleanup, type ReplaceFileAtomicRestoreFailureDetails, type ReplaceFileCopyFallbackRestorePolicy, type ReplaceFileDestinationHardlinkPolicy } from "./replace-file-copy-fallback.js";
+import { type RenameIdentityPolicy } from "./replace-file-rename-policy.js";
+export type ReplaceFileAtomicFileSystem = {
+    promises: Pick<typeof fs, "mkdir" | "writeFile" | "rename" | "copyFile" | "unlink" | "rm" | "open" | "stat" | "lstat"> & {
+        /** @deprecated Accepted for adapter compatibility but never called. */
+        chmod?: typeof fs.chmod;
+    };
+};
+export type ReplaceFileAtomicSyncFileSystem = Pick<typeof syncFs, "mkdirSync" | "readFileSync" | "writeFileSync" | "renameSync" | "copyFileSync" | "unlinkSync" | "rmSync" | "openSync" | "fsyncSync" | "closeSync" | "fstatSync" | "statSync" | "lstatSync" | "ftruncateSync" | "readSync" | "writeSync"> & {
+    /** @deprecated Accepted for adapter compatibility but never called. */
+    chmodSync?: typeof syncFs.chmodSync;
+    fchmodSync?: typeof syncFs.fchmodSync;
+};
+export type { RenameIdentityPolicy, ReplaceFileAtomicRestoreCleanup, ReplaceFileAtomicRestoreFailureDetails, ReplaceFileCopyFallbackRestorePolicy, ReplaceFileDestinationHardlinkPolicy, };
+type ReplaceFileAtomicBaseOptions = {
+    filePath: string;
+    content: string | Uint8Array;
+    dirMode?: number;
+    mode?: number;
+    preserveExistingMode?: boolean;
+    tempPrefix?: string;
+    renameMaxRetries?: number;
+    renameRetryBaseDelayMs?: number;
+    copyFallbackOnPermissionError?: boolean;
+    copyFallbackRestore?: ReplaceFileCopyFallbackRestorePolicy;
+    maxRestoreBytes?: number;
+    destinationHardlinks?: ReplaceFileDestinationHardlinkPolicy;
+    /** Strict by default; locked content verification is an explicit FUSE compatibility policy. */
+    renameIdentity?: RenameIdentityPolicy;
+    syncTempFile?: boolean;
+    syncParentDir?: boolean;
+    throwOnCleanupError?: boolean;
+};
+export type ReplaceFileAtomicOptions = ReplaceFileAtomicBaseOptions & {
+    fileSystem?: ReplaceFileAtomicFileSystem;
+    /** Runs while the exact staged file is retained; replacing or hardlinking it is rejected. */
+    beforeRename?: (params: {
+        filePath: string;
+        tempPath: string;
+    }) => Promise<void>;
+};
+export type ReplaceFileAtomicSyncOptions = ReplaceFileAtomicBaseOptions & {
+    fileSystem?: ReplaceFileAtomicSyncFileSystem;
+    /** Runs while the exact staged file is retained; replacing or hardlinking it is rejected. */
+    beforeRename?: (params: {
+        filePath: string;
+        tempPath: string;
+    }) => void;
+};
+export type ReplaceFileAtomicResult = {
+    method: "rename" | "copy-fallback";
+};
+export declare function replaceFileAtomic(options: ReplaceFileAtomicOptions): Promise<ReplaceFileAtomicResult>;
+export declare function replaceFileAtomicWithDirectorySync(options: ReplaceFileAtomicOptions, syncParent?: (directoryPath: string) => Promise<unknown>): Promise<ReplaceFileAtomicResult>;
+export declare function replaceFileAtomicSync(options: ReplaceFileAtomicSyncOptions): ReplaceFileAtomicResult;
+//# sourceMappingURL=replace-file.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replace-file.d.ts","sourceRoot":"","sources":["../src/replace-file.ts"],"names":[],"mappings":"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"}