@openclaw/openshell-sandbox 2026.9.4 → 2026.9.6

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

@@ -1,9 +1,9 @@
 import fsSync, {} from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
-import { FsSafeError } from "./errors.js";
 import { sameFileIdentityForCleanup } from "./file-identity.js";
 import { getNativeBinding } from "./native.js";
+import { captureNativeFdClose } from "./native-binding.js";
 export function nativeOpenFlags(flags) {
     const closeOnExec = fsSync.constants.O_CLOEXEC;
     return (flags |
@@ -20,38 +20,16 @@ export function writeNativeFd(fd, data) {
         offset += written;
     }
 }
-export async function writeNativeInput(fd, input, maxBytes) {
-    let bytes = 0;
-    const write = (data) => {
-        bytes += data.byteLength;
-        if (maxBytes !== undefined && bytes > maxBytes) {
-            throw new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`);
-        }
-        writeNativeFd(fd, data);
-    };
-    if (input.kind === "buffer") {
-        write(typeof input.data === "string" ? Buffer.from(input.data, input.encoding ?? "utf8") : input.data);
-    }
-    else {
-        for await (const chunk of input.stream) {
-            write(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
-        }
-    }
-}
-function wrapNativeFd(fd, containment) {
+function wrapNativeFd(fd, closeFd) {
     let open = true;
     return {
         fd,
-        containment,
         async close() {
             if (open) {
                 open = false;
-                fsSync.closeSync(fd);
+                closeFd(fd);
             }
         },
-        async stat() {
-            return fsSync.fstatSync(fd);
-        },
         async writeFile(data, encoding) {
             writeNativeFd(fd, Buffer.isBuffer(data) ? data : Buffer.from(data, encoding ?? "utf8"));
         },
@@ -83,6 +61,7 @@ export async function createNativeExclusiveFile(targetPath, mode) {
     if (!binding) {
         return undefined;
     }
+    const closeFd = captureNativeFdClose(binding);
     const parentPath = path.dirname(targetPath);
     const basename = path.basename(targetPath);
     const parent = await fs.open(parentPath, fsSync.constants.O_RDONLY |
@@ -107,12 +86,12 @@ export async function createNativeExclusiveFile(targetPath, mode) {
         fd = opened.fd;
         fsSync.fchmodSync(fd, mode);
         created = fsSync.fstatSync(fd, { bigint: true });
-        return wrapNativeFd(fd, opened.containment);
+        return wrapNativeFd(fd, closeFd);
     }
     catch (error) {
         if (fd !== undefined) {
             try {
-                fsSync.closeSync(fd);
+                closeFd(fd);
             }
             catch {
                 // Preserve the original error.

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

@@ -0,0 +1,34 @@
+import { type BigIntStats, type Stats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import type { FileIdentityStat } from "./file-identity.js";
+import type { NativeBinding } from "./native.js";
+import { describeStagedDirectory } from "./staged-directory.js";
+type RootIdentity = Pick<FileIdentityStat, "dev" | "ino">;
+export type NativeRootAdmission = {
+    exactRoot: boolean;
+    reportCloseErrors?: boolean;
+    operation: string;
+    root: FileHandle;
+    rootPath: string;
+};
+export type NativeParentAdmission = {
+    fd: number;
+    close(): void;
+    guard: {
+        dir: string;
+        realPath: string;
+        stat: Stats | BigIntStats;
+    };
+    stagedDirectory?: ReturnType<typeof describeStagedDirectory>;
+};
+export declare function sameNativeIdentity(left: RootIdentity, right: RootIdentity): boolean;
+export declare function openNativeRootAdmission(binding: NativeBinding, params: {
+    rootPath: string;
+    rootIdentity?: RootIdentity;
+    operation?: string;
+    reportCloseErrors?: boolean;
+}): Promise<NativeRootAdmission>;
+export declare function openNativeParentAdmission(binding: NativeBinding, rootAdmission: Omit<NativeRootAdmission, "root"> & {
+    root: Pick<FileHandle, "fd">;
+}, relativeParentPath: string, observation?: "native-directory"): Promise<NativeParentAdmission>;
+export {};

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

@@ -0,0 +1,147 @@
+import fsSync, {} from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { inspectDirectoryIdentity, inspectDirectoryIdentitySync } from "./directory-guard.js";
+import { inspectNativeDirectoryObservation } from "./native-directory-observation.js";
+import { FsSafeError } from "./errors.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { realpathSync } from "./realpath.js";
+import { describeStagedDirectory, exactIdentityMatches } from "./staged-directory.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { assertNoWindowsPathAlias, pathForWindowsFilesystem } from "./windows-path-alias.js";
+export function sameNativeIdentity(left, right) {
+    return left.dev === right.dev && left.ino === right.ino;
+}
+function unavailable(message) {
+    return new FsSafeError("helper-unavailable", message);
+}
+function assertParentAdmissionAvailable(binding) {
+    if (typeof binding.openBeneath !== "function") {
+        throw unavailable("native parent directory admission is unavailable");
+    }
+    captureNativeFdClose(binding);
+}
+export async function openNativeRootAdmission(binding, params) {
+    assertParentAdmissionAvailable(binding);
+    const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+    assertNoWindowsPathAlias(params.rootPath, "filesystem", "native root uses a Windows filesystem namespace alias");
+    const root = await fs.open(pathForWindowsFilesystem(params.rootPath), directoryFlags);
+    try {
+        const exactRoot = typeof params.rootIdentity?.dev === "bigint" &&
+            typeof params.rootIdentity.ino === "bigint";
+        let rootMatches;
+        if (exactRoot) {
+            inspectFileIdentitySync(() => fsSync.fstatSync(root.fd, { bigint: true }), params.rootIdentity);
+            rootMatches = true;
+        }
+        else if (process.platform === "win32") {
+            if (typeof binding.fstatIdentity !== "function") {
+                throw unavailable("native root directory identity checks are unavailable");
+            }
+            const identity = binding.fstatIdentity(root.fd);
+            rootMatches = !params.rootIdentity || sameNativeIdentity(params.rootIdentity, identity);
+        }
+        else {
+            const identity = fsSync.fstatSync(root.fd, { bigint: true });
+            rootMatches = !params.rootIdentity || exactIdentityMatches(params.rootIdentity, identity);
+        }
+        if (!rootMatches) {
+            throw new FsSafeError("path-mismatch", `root path changed during ${params.operation ?? "native admission"}`);
+        }
+        return {
+            exactRoot,
+            reportCloseErrors: params.reportCloseErrors,
+            operation: params.operation ?? "native admission",
+            root,
+            rootPath: params.rootPath,
+        };
+    }
+    catch (error) {
+        try {
+            await root.close();
+        }
+        catch (closeError) {
+            // Windows admission keeps the typed boundary failure primary.
+            if (process.platform !== "win32" || params.reportCloseErrors) {
+                throw createSuppressedError(closeError, error, "native root admission and close failed");
+            }
+        }
+        throw error;
+    }
+}
+export async function openNativeParentAdmission(binding, rootAdmission, relativeParentPath, observation) {
+    assertParentAdmissionAvailable(binding);
+    const closeFd = captureNativeFdClose(binding);
+    const directoryFlags = fsSync.constants.O_RDONLY | (fsSync.constants.O_DIRECTORY ?? 0);
+    assertNoWindowsPathAlias(relativeParentPath, "relative", "native parent uses a Windows filesystem namespace alias");
+    const opened = binding.openBeneath(rootAdmission.root.fd, relativeParentPath, directoryFlags);
+    if (!opened || !Number.isInteger(opened.fd) || opened.fd < 0) {
+        throw unavailable("native parent directory admission did not provide a descriptor");
+    }
+    const parentFd = opened.fd;
+    try {
+        const parentInput = relativeParentPath
+            ? path.join(rootAdmission.rootPath, ...relativeParentPath.split("/"))
+            : rootAdmission.rootPath;
+        if (observation === "native-directory" && process.platform === "win32" && rootAdmission.exactRoot &&
+            typeof binding.observeDirectory === "function") {
+            const stat = inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true }));
+            let observed;
+            try {
+                observed = inspectNativeDirectoryObservation(binding, parentInput, stat);
+            }
+            catch (error) {
+                if (error?.code !== "OBSERVATION_UNAVAILABLE")
+                    throw error;
+            }
+            if (observed) {
+                assertNoWindowsPathAlias(observed.realPath, "filesystem", "native parent uses a Windows filesystem namespace alias");
+                inspectDirectoryIdentitySync(observed.realPath, stat, stat);
+                return {
+                    fd: parentFd,
+                    close: () => closeFd(parentFd),
+                    guard: { dir: observed.realPath, realPath: observed.realPath, stat },
+                };
+            }
+        }
+        const parentPath = realpathSync.native(pathForWindowsFilesystem(parentInput));
+        assertNoWindowsPathAlias(parentPath, "filesystem", "native parent uses a Windows filesystem namespace alias");
+        const stagedDirectory = process.platform === "win32"
+            ? undefined
+            : describeStagedDirectory(parentFd, parentPath);
+        const parentPathStat = rootAdmission.exactRoot
+            ? await inspectDirectoryIdentity(parentPath, inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true })))
+            : fsSync.lstatSync(pathForWindowsFilesystem(parentPath));
+        if (process.platform === "win32" && !rootAdmission.exactRoot) {
+            if (typeof binding.fstatIdentity !== "function") {
+                throw unavailable("native parent directory identity checks are unavailable");
+            }
+            const parentIdentity = binding.fstatIdentity(parentFd);
+            if (parentPathStat.isSymbolicLink() || !sameNativeIdentity(parentPathStat, parentIdentity)) {
+                throw new FsSafeError("path-mismatch", `${rootAdmission.operation} parent changed during resolution`);
+            }
+        }
+        else if (process.platform !== "win32" &&
+            (parentPathStat.isSymbolicLink() || !exactIdentityMatches(parentPathStat, stagedDirectory.identity))) {
+            throw new FsSafeError("path-mismatch", `${rootAdmission.operation} parent changed during resolution`);
+        }
+        return {
+            fd: parentFd,
+            close: () => closeFd(parentFd),
+            guard: { dir: parentPath, realPath: parentPath, stat: parentPathStat },
+            stagedDirectory,
+        };
+    }
+    catch (error) {
+        try {
+            closeFd(parentFd);
+        }
+        catch (closeError) {
+            if (process.platform !== "win32" || rootAdmission.reportCloseErrors) {
+                throw createSuppressedError(closeError, error, "native parent admission and close failed");
+            }
+        }
+        throw error;
+    }
+}

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

@@ -1,8 +1,6 @@
 import type { FileHandle } from "node:fs/promises";
-import type { AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
 import type { FileIdentityStat } from "./file-identity.js";
 import type { NativeBinding } from "./native.js";
-import type { PinnedWriteParams } from "./pinned-write.js";
-export declare function sameNativeIdentity(left: Pick<FileIdentityStat, "dev" | "ino">, right: Pick<FileIdentityStat, "dev" | "ino">): boolean;
+import type { PinnedWriteParams } from "./pinned-write-types.js";
 export declare function runPinnedWriteWindows(binding: NativeBinding, params: PinnedWriteParams, root: FileHandle, parentFd: number, parentGuard: AnyAsyncDirectoryGuard): Promise<FileIdentityStat>;
-//# sourceMappingURL=native-pinned-write-windows.d.ts.map

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

@@ -1,49 +1,155 @@
 import { syncFileBestEffortSync } from "./file-sync.js";
 import { randomUUID } from "node:crypto";
 import fsSync, {} from "node:fs";
+import path from "node:path";
+import { createFileHandle } from "./create.js";
+import { hasPreservedCreationArtifacts } from "./creation-boundary.js";
+import { assertSyncDirectoryGuard } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
-import { nativeOpenFlags, removeNativeCreatedFileIfStillPinned, writeNativeInput, } from "./native-operations.js";
+import { nativeOpenFlags, removeNativeCreatedFileIfStillPinned, } from "./native-operations.js";
+import { writePinnedInput } from "./pinned-write-input.js";
+import { captureNativeFdClose } from "./native-binding.js";
 import { inspectFileIdentitySync } from "./strict-file-identity.js";
-export function sameNativeIdentity(left, right) {
-    return left.dev === right.dev && left.ino === right.ino;
-}
-function closeWriteFd(fd) {
+import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
+import { classifyNativeRenameFailure } from "./native-rename-outcome.js";
+import { cleanupPinnedFilePath } from "./file-cleanup.js";
+import { createStagedFileReceipt, settleStagedFile } from "./staged-file-settlement.js";
+import { exactIdentityMatches } from "./staged-directory.js";
+import { inspectNativeDirectoryObservation } from "./native-directory-observation.js";
+function closeWriteFd(closeFd, fd) {
     if (fd === undefined)
         return;
     try {
-        fsSync.closeSync(fd);
+        closeFd(fd);
     }
     catch (error) {
-        return error;
+        return { error };
+    }
+}
+function readParentIdentity(parentFd, guard) {
+    const stat = inspectFileIdentitySync(() => fsSync.fstatSync(parentFd, { bigint: true }));
+    if (!stat.isDirectory() || !exactIdentityMatches(guard.stat, stat)) {
+        throw new FsSafeError("path-mismatch", "native write parent identity changed");
     }
+    return stat;
+}
+function assertNamedParentCurrent(binding, guard, identity) {
+    if (typeof binding.observeDirectory === "function") {
+        try {
+            const observed = inspectNativeDirectoryObservation(binding, guard.dir, identity);
+            if (observed.realPath !== guard.realPath) {
+                throw new FsSafeError("path-mismatch", "native write parent pathname changed");
+            }
+            return;
+        }
+        catch (error) {
+            if (error?.code !== "OBSERVATION_UNAVAILABLE")
+                throw error;
+        }
+    }
+    assertSyncDirectoryGuard({ ...guard, stat: identity });
 }
 export async function runPinnedWriteWindows(binding, params, root, parentFd, parentGuard) {
+    const closeFd = captureNativeFdClose(binding);
     const parentPath = parentGuard.realPath;
     let tempFd;
+    let privateHandle;
     let targetFd;
+    let publicationProbeFd;
     let tempIdentity;
     let tempName = "";
     let renamed = false;
     let completed = false;
+    const completeCreate = params.overwrite === false && params.input.kind !== "file" && params.input.stageBeforePublish === true;
+    let receipt;
+    let publication = Object.freeze({ status: "not-published" });
+    let phase = "prepare";
+    let failure;
+    const closeTemp = async () => {
+        const handle = privateHandle;
+        const fd = tempFd;
+        privateHandle = undefined;
+        tempFd = undefined;
+        if (handle)
+            await handle.close();
+        else if (fd !== undefined)
+            closeFd(fd);
+    };
     try {
         tempName = `.fs-safe-${randomUUID()}.tmp`;
-        tempFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL)).fd;
+        params.assertBeforeMutation?.();
+        if (params.private) {
+            const parentIdentity = fsSync.fstatSync(parentFd, { bigint: true });
+            privateHandle = await createFileHandle(path.join(parentPath, tempName), {
+                private: true,
+                mode: 0o600,
+                assertBeforeMutation: params.assertBeforeMutation,
+            }, {
+                expectedParentIdentity: {
+                    dev: parentIdentity.dev, ino: parentIdentity.ino, realPath: parentPath,
+                },
+            });
+            tempFd = privateHandle.fd;
+        }
+        else {
+            tempFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(fsSync.constants.O_WRONLY | fsSync.constants.O_CREAT | fsSync.constants.O_EXCL)).fd;
+        }
         const verificationIdentity = inspectFileIdentitySync(() => fsSync.fstatSync(tempFd, { bigint: true }));
         tempIdentity = verificationIdentity;
         // Creation is requested at 0600 in the binding, but a restrictive umask
         // can remove owner access. Keep the unpublished inode private and
         // reopenable until the published name has been identity-fenced.
         fsSync.fchmodSync(tempFd, 0o600);
-        await writeNativeInput(tempFd, params.input, params.maxBytes);
-        if (params.sync !== false)
-            syncFileBestEffortSync(tempFd);
-        if (params.overwrite === false) {
-            binding.renameNoReplace(parentFd, tempName, parentFd, params.basename);
+        await writePinnedInput(tempFd, params.input, params.maxBytes, params.assertBeforeMutation);
+        if (params.sync !== false) {
+            if (params.strictFileSync)
+                fsSync.fsyncSync(tempFd);
+            else
+                syncFileBestEffortSync(tempFd);
         }
-        else {
-            binding.renameReplace(parentFd, tempName, parentFd, params.basename);
+        if (params.input.kind === "file")
+            await params.input.verifySource();
+        if (completeCreate) {
+            const parentIdentity = readParentIdentity(parentFd, parentGuard);
+            receipt = createStagedFileReceipt(Object.freeze({
+                path: parentGuard.dir,
+                realPath: parentGuard.realPath,
+                identity: Object.freeze({ dev: parentIdentity.dev, ino: parentIdentity.ino }),
+            }), tempName, fsSync.fstatSync(tempFd, { bigint: true }));
+        }
+        phase = "publish";
+        assertFinalSymlinkRejected(path.join(parentPath, params.basename), params.rejectFinalSymlink);
+        params.assertBeforeMutation?.();
+        if (params.assertBeforeMutation) {
+            // Callbacks can replace names synchronously. Fence the named parent and
+            // stage against retained descriptors before the rename can expose bytes.
+            assertNamedParentCurrent(binding, parentGuard, readParentIdentity(parentFd, parentGuard));
+            publicationProbeFd = binding.openBeneath(parentFd, tempName, nativeOpenFlags(fsSync.constants.O_RDONLY)).fd;
+            const named = inspectFileIdentitySync(() => fsSync.fstatSync(publicationProbeFd, { bigint: true }), verificationIdentity);
+            const retained = inspectFileIdentitySync(() => fsSync.fstatSync(tempFd, { bigint: true }), verificationIdentity);
+            if (!named.isFile() || !retained.isFile() || named.nlink !== 1n || retained.nlink !== 1n) {
+                throw new FsSafeError("path-mismatch", "native write stage changed before publication");
+            }
+            assertFinalSymlinkRejected(path.join(parentPath, params.basename), params.rejectFinalSymlink);
+        }
+        try {
+            if (params.overwrite === false) {
+                binding.renameNoReplace(parentFd, tempName, parentFd, params.basename);
+            }
+            else {
+                binding.renameReplace(parentFd, tempName, parentFd, params.basename);
+            }
+        }
+        catch (error) {
+            if (completeCreate && classifyNativeRenameFailure(error) === "indeterminate") {
+                publication = Object.freeze({ status: "indeterminate", basename: params.basename, overwrite: false });
+            }
+            throw error;
         }
         renamed = true;
+        if (receipt)
+            publication = Object.freeze({ status: "published", staged: receipt, basename: params.basename, overwrite: false });
+        params.onPublished?.(verificationIdentity);
         targetFd = binding.openBeneath(parentFd, params.basename, nativeOpenFlags(fsSync.constants.O_RDONLY)).fd;
         const targetStat = inspectFileIdentitySync(() => fsSync.fstatSync(targetFd, { bigint: true }), verificationIdentity);
         const targetIdentity = binding.fstatIdentity(targetFd);
@@ -55,18 +161,28 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
         // verifiable and so broader modes are never exposed before that fence.
         try {
             fsSync.fchmodSync(targetFd, params.mode);
-            if (params.sync !== false)
-                syncFileBestEffortSync(targetFd);
+            // Windows FlushFileBuffers needs write access; the verification reopen is read-only.
+            if (params.sync !== false) {
+                if (params.strictFileSync)
+                    fsSync.fsyncSync(tempFd);
+                else
+                    syncFileBestEffortSync(tempFd);
+            }
         }
         catch (error) {
-            closeWriteFd(targetFd);
-            targetFd = undefined;
-            removeNativeCreatedFileIfStillPinned({
-                parentPath,
-                parentFd,
-                basename: params.basename,
-                created: tempIdentity,
-            });
+            if (!completeCreate) {
+                closeWriteFd(closeFd, targetFd);
+                targetFd = undefined;
+            }
+            // Staged copies and streamed creates preserve publication for caller recovery.
+            if (params.input.kind !== "file" && !params.input.stageBeforePublish) {
+                removeNativeCreatedFileIfStillPinned({
+                    parentPath,
+                    parentFd,
+                    basename: params.basename,
+                    created: tempIdentity,
+                });
+            }
             throw error;
         }
         if (params.sync !== false)
@@ -76,21 +192,61 @@ export async function runPinnedWriteWindows(binding, params, root, parentFd, par
         completed = true;
         return { dev: targetIdentity.dev, ino: targetIdentity.ino };
     }
+    catch (error) {
+        failure = { error };
+        throw error;
+    }
     finally {
-        const targetCloseError = closeWriteFd(targetFd);
-        const tempCloseError = closeWriteFd(tempFd);
-        if (!renamed) {
-            removeNativeCreatedFileIfStillPinned({
-                parentPath,
-                parentFd,
-                basename: tempName,
-                created: tempIdentity,
+        const preservedPreparation = params.private && tempFd === undefined && hasPreservedCreationArtifacts(failure?.error);
+        if (completeCreate || preservedPreparation) {
+            await settleStagedFile({
+                temporaryBasename: tempName, publication, phase, failure,
+                cleanup: async () => {
+                    if (preservedPreparation)
+                        return "preserved";
+                    if (publication.status === "indeterminate")
+                        return "preserved";
+                    if (renamed || tempFd === undefined)
+                        return "not-needed";
+                    return await cleanupPinnedFilePath({
+                        pathname: path.join(parentPath, tempName), handle: { fd: tempFd },
+                        identity: tempIdentity, parentGuard, throwOnCleanupError: true,
+                    });
+                },
+                close: [
+                    () => { if (targetFd !== undefined)
+                        closeFd(targetFd); },
+                    () => { if (publicationProbeFd !== undefined)
+                        closeFd(publicationProbeFd); },
+                    closeTemp,
+                    () => closeFd(parentFd),
+                    () => root.close(),
+                ],
             });
         }
-        const parentCloseError = closeWriteFd(parentFd);
-        await root.close().catch(() => undefined);
-        const closeError = targetCloseError ?? tempCloseError ?? parentCloseError;
-        if (completed && closeError !== undefined)
-            throw closeError;
+        else {
+            const targetCloseFailure = closeWriteFd(closeFd, targetFd);
+            const probeCloseFailure = closeWriteFd(closeFd, publicationProbeFd);
+            let tempCloseFailure;
+            try {
+                await closeTemp();
+            }
+            catch (error) {
+                tempCloseFailure = { error };
+            }
+            if (!renamed) {
+                removeNativeCreatedFileIfStillPinned({
+                    parentPath,
+                    parentFd,
+                    basename: tempName,
+                    created: tempIdentity,
+                });
+            }
+            const parentCloseFailure = closeWriteFd(closeFd, parentFd);
+            await root.close().catch(() => undefined);
+            const closeFailure = targetCloseFailure ?? probeCloseFailure ?? tempCloseFailure ?? parentCloseFailure;
+            if (completed && closeFailure)
+                throw closeFailure.error;
+        }
     }
 }

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

@@ -1,5 +1,4 @@
 import type { FileIdentityStat } from "./file-identity.js";
 import type { NativeBinding } from "./native.js";
-import type { PinnedWriteParams } from "./pinned-write.js";
+import type { PinnedWriteParams } from "./pinned-write-types.js";
 export declare function runPinnedWriteNative(binding: NativeBinding, params: PinnedWriteParams): Promise<FileIdentityStat>;
-//# sourceMappingURL=native-pinned-write.d.ts.map