@openclaw/openshell-sandbox 2026.9.3 → 2026.9.5

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

@@ -1,4 +1,4 @@
-import { constants as fsConstants } from "node:fs";
+import fsSync, { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, } from "./archive-limits.js";
@@ -6,6 +6,7 @@ import { FsSafeError } from "./errors.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { tempFile } from "./temp-target.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 async function closeFileHandle(handle) {
     if (handle)
         await handle.close().catch(() => undefined);
@@ -23,11 +24,14 @@ export async function writeFileHandleFully(params) {
 }
 export async function stageArchiveFileForExtraction(params) {
     params.deadline.check();
-    const sourcePath = path.resolve(params.archivePath);
+    const archivePath = params.archivePath;
+    assertNoWindowsPathAlias(archivePath);
+    const sourcePath = path.resolve(archivePath);
+    assertNoWindowsPathAlias(sourcePath);
     const initialStat = await inspectFileIdentity(async () => {
-        const stat = await fs.lstat(sourcePath, { bigint: true });
+        const stat = fsSync.lstatSync(sourcePath, { bigint: true });
         if (stat.isSymbolicLink() || !stat.isFile()) {
-            throw new Error(`archive is not a regular file: ${params.archivePath}`);
+            throw new Error(`archive is not a regular file: ${archivePath}`);
         }
         return stat;
     });
@@ -43,13 +47,13 @@ export async function stageArchiveFileForExtraction(params) {
             fileName: path.basename(sourcePath),
         });
         const opened = await inspectFileIdentity(async () => {
-            const stat = await handle.stat({ bigint: true });
+            const stat = fsSync.fstatSync(handle.fd, { bigint: true });
             if (!stat.isFile())
                 throw new Error("archive changed during validation");
             return stat;
         }, initialStat);
         await inspectFileIdentity(async () => {
-            const stat = await fs.lstat(sourcePath, { bigint: true });
+            const stat = fsSync.lstatSync(sourcePath, { bigint: true });
             if (stat.isSymbolicLink() || !stat.isFile())
                 throw new Error("archive changed during validation");
             return stat;
@@ -61,11 +65,13 @@ export async function stageArchiveFileForExtraction(params) {
                 ? fsConstants.O_NOFOLLOW
                 : 0);
         output = await fs.open(staged.path, flags, 0o600);
-        const buffer = Buffer.allocUnsafe(64 * 1024);
+        const buffer = Buffer.allocUnsafe(Math.min(512 * 1024, Math.max(64 * 1024, Number(opened.size)), params.limits.maxArchiveBytes + 1));
         let written = 0;
         while (true) {
             params.deadline.check();
-            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+            const length = Math.min(buffer.length, params.limits.maxArchiveBytes - written + 1);
+            const { bytesRead } = await handle.read(buffer, 0, length, null);
+            params.deadline.check();
             if (bytesRead === 0)
                 break;
             written += bytesRead;

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

@@ -1 +1 @@
-{"version":3,"file":"archive-kind.d.ts","sourceRoot":"","sources":["../src/archive-kind.ts"],"names":[],"mappings":"AAMA,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,WAAW,GAAG,UAAU,GAAG,KAAK,CAAC;AAmBnE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAcvE;AAED,KAAK,2BAA2B,GAAG;IACjC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAkBF,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,MAAM,CAAC,CA4BjB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAQjE"}
+{"version":3,"file":"archive-kind.d.ts","sourceRoot":"","sources":["../src/archive-kind.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,WAAW,GAAG,UAAU,GAAG,KAAK,CAAC;AAmBnE,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,GAAG,IAAI,CAcvE;AAED,KAAK,2BAA2B,GAAG;IACjC,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAkBF,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAAC,MAAM,CAAC,CA4BjB;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI,CAQjE"}

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

@@ -1,3 +1,4 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { FsSafeError } from "./errors.js";
@@ -37,7 +38,7 @@ async function hasPackedRootMarker(extractDir, rootMarkers) {
             continue;
         }
         try {
-            await fs.stat(path.join(extractDir, trimmed));
+            fsSync.statSync(path.join(extractDir, trimmed));
             return true;
         }
         catch {
@@ -49,7 +50,7 @@ async function hasPackedRootMarker(extractDir, rootMarkers) {
 export async function resolvePackedRootDir(extractDir, options) {
     const direct = path.join(extractDir, "package");
     try {
-        const stat = await fs.stat(direct);
+        const stat = fsSync.statSync(direct);
         if (stat.isDirectory()) {
             return direct;
         }

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

@@ -1,4 +1,5 @@
 import { type ExtractionDeadline } from "./archive-deadline.js";
+import { type ArchiveDirectoryGuard } from "./archive-staging.js";
 export type ArchivePublicationEntry = {
     path: string;
     kind: "file" | "directory";
@@ -10,8 +11,12 @@ type MergeParams = {
     destinationRealDir: string;
     deadline?: ExtractionDeadline;
 };
-export declare function mergePlannedArchiveIntoDestination(params: MergeParams & {
+type GuardedMergeParams = Pick<MergeParams, "sourceDir" | "deadline"> & {
+    destinationGuard: ArchiveDirectoryGuard;
+};
+export declare function mergePlannedArchiveIntoDestination(params: GuardedMergeParams & {
     entries: readonly ArchivePublicationEntry[];
+    durable?: boolean;
 }): Promise<void>;
 export declare function mergeExtractedTreeIntoDestination(params: MergeParams): Promise<void>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"archive-merge.d.ts","sourceRoot":"","sources":["../src/archive-merge.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoC,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAelG,MAAM,MAAM,uBAAuB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AACjG,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AAEF,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,WAAW,GAAG;IAAE,OAAO,EAAE,SAAS,uBAAuB,EAAE,CAAA;CAAE,GACpE,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1F"}
+{"version":3,"file":"archive-merge.d.ts","sourceRoot":"","sources":["../src/archive-merge.ts"],"names":[],"mappings":"AAGA,OAAO,EAAoC,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAClG,OAAO,EAIL,KAAK,qBAAqB,EAC3B,MAAM,sBAAsB,CAAC;AAc9B,MAAM,MAAM,uBAAuB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AACjG,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,kBAAkB,CAAC;CAC/B,CAAC;AACF,KAAK,kBAAkB,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,GAAG,UAAU,CAAC,GAAG;IACtE,gBAAgB,EAAE,qBAAqB,CAAC;CACzC,CAAC;AAEF,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,kBAAkB,GAAG;IAAE,OAAO,EAAE,SAAS,uBAAuB,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,GAC9F,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAsB,iCAAiC,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAS1F"}

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

@@ -1,27 +1,48 @@
+import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { ownExtractionDestinationMutation } from "./archive-deadline.js";
 import { assertDirectoryIdentityGuard, assertResolvedInsideDestination, createDirectoryIdentityGuard, createArchiveSymlinkTraversalError, preparePrivateArchiveOutputPath, } from "./archive-staging.js";
-import {} from "./directory-guard.js";
 import {} from "./directory-mode-owner.js";
 import { pinNodeDirectoryForMode } from "./directory-mode-node.js";
 import { FsSafeError } from "./errors.js";
 import { formatErrorDetail } from "./error-detail.js";
 import { isPathInside } from "./path.js";
-import { root } from "./root.js";
+import { rootFromDirectoryGuard } from "./root-impl.js";
+import { realpathSync } from "./realpath.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
+import { onCopyPublication } from "./copy-publication.js";
+import { syncFileBestEffortSync } from "./file-sync.js";
+import { finalizeArchivePublication } from "./archive-durability.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export async function mergePlannedArchiveIntoDestination(params) {
-    await mergeTree(params, params.entries);
+    assertMergePathInputs(params);
+    await mergeTree(params, params.entries, params.durable === true);
 }
 export async function mergeExtractedTreeIntoDestination(params) {
-    await mergeTree(params);
+    const sourceDir = params.sourceDir;
+    const destinationDir = params.destinationDir;
+    const destinationRealDir = params.destinationRealDir;
+    assertNoWindowsPathAlias(sourceDir);
+    assertNoWindowsPathAlias(destinationDir);
+    assertNoWindowsPathAlias(destinationRealDir);
+    const destinationGuard = await createDirectoryIdentityGuard(destinationRealDir);
+    await mergeTree({ sourceDir, deadline: params.deadline, destinationGuard });
 }
-async function mergeTree(params, publication) {
+function assertMergePathInputs(params) {
+    assertNoWindowsPathAlias(params.sourceDir);
+    assertNoWindowsPathAlias(params.destinationGuard.dir);
+    assertNoWindowsPathAlias(params.destinationGuard.realPath);
+}
+async function mergeTree(params, publication, durable = true) {
+    const publishedFiles = [];
+    const publishedDirectories = [];
     const check = () => params.deadline?.check();
     check();
-    const destinationGuard = await createDirectoryIdentityGuard(params.destinationRealDir);
-    check();
-    const targetRoot = await root(params.destinationRealDir);
+    const { destinationGuard } = params;
+    const destinationDir = destinationGuard.dir;
+    const destinationRealDir = destinationGuard.realPath;
+    const targetRoot = rootFromDirectoryGuard(destinationGuard);
     check();
     const sourceGuard = await createDirectoryIdentityGuard(params.sourceDir);
     check();
@@ -29,7 +50,7 @@ async function mergeTree(params, publication) {
     for (const entry of publication ?? []) {
         // Resolve admitted spelling in private staging, preserving the volume's case
         // and Unicode behavior without assigning explicit modes to distinct parents.
-        const stagedPath = await fs.realpath(path.join(params.sourceDir, entry.path));
+        const stagedPath = realpathSync.native(path.join(params.sourceDir, entry.path));
         check();
         if (!isPathInside(sourceGuard.realPath, stagedPath) || plan.has(stagedPath)) {
             throw new FsSafeError("path-mismatch", "archive publication paths changed in staging");
@@ -58,12 +79,12 @@ async function mergeTree(params, publication) {
             const sourcePath = path.join(sourceDir, entry.name);
             const relPath = path.relative(params.sourceDir, sourcePath);
             const originalPath = relPath.split(path.sep).join("/");
-            const destinationPath = path.join(params.destinationDir, relPath);
-            const sourceStat = await fs.lstat(sourcePath);
+            const destinationPath = path.join(destinationDir, relPath);
+            const sourceStat = fsSync.lstatSync(sourcePath);
             check();
             if (sourceStat.isSymbolicLink())
                 throw createArchiveSymlinkTraversalError(originalPath);
-            const sourceReal = await fs.realpath(sourcePath);
+            const sourceReal = realpathSync.native(sourcePath);
             check();
             if (!isPathInside(sourceGuard.realPath, sourceReal))
                 throw createArchiveSymlinkTraversalError(originalPath);
@@ -77,8 +98,9 @@ async function mergeTree(params, publication) {
             }
             const mode = plan ? planned?.mode ?? 0o755 : sourceStat.mode & 0o777;
             await preparePrivateArchiveOutputPath({
-                ...params, relPath, outPath: destinationPath, originalPath, isDirectory: kind === "directory",
-            }, assertGuards);
+                destinationDir, destinationRealDir, deadline: params.deadline,
+                relPath, outPath: destinationPath, originalPath, isDirectory: kind === "directory",
+            }, assertGuards, destinationGuard);
             check();
             if (kind === "directory") {
                 // Ownership spans open, descendants, finalization and close, including timeout.
@@ -98,6 +120,11 @@ async function mergeTree(params, publication) {
                         ancestors.push({ guard, owner });
                         try {
                             await walk(sourcePath);
+                            if (publication) {
+                                await assertGuards();
+                                publishedDirectories.push({ guard, mode, parents: ancestors.slice(0, -1).map((ancestor) => ancestor.guard) });
+                                return;
+                            }
                             await getFsSafeTestHooks()?.beforeArchiveOutputMutation?.("chmod", destinationPath);
                             check();
                             await assertGuards();
@@ -108,7 +135,7 @@ async function mergeTree(params, publication) {
                                     await assertDirectoryIdentityGuard(guard);
                                     check();
                                     await assertResolvedInsideDestination({
-                                        destinationRealDir: params.destinationRealDir, targetPath: destinationPath, originalPath,
+                                        destinationRealDir, targetPath: destinationPath, originalPath,
                                     });
                                     check();
                                 } });
@@ -129,21 +156,39 @@ async function mergeTree(params, publication) {
                 await ownExtractionDestinationMutation(params.deadline, async () => {
                     await assertGuards();
                     try {
-                        await targetRoot.copyIn(relPath, sourcePath, { mkdir: true, mode });
+                        const options = {
+                            mkdir: true, mode, durable: publication ? false : true,
+                        };
+                        if (publication && durable) {
+                            options[onCopyPublication] = async (fd, identity) => {
+                                check();
+                                if ((mode & 0o400) === 0) {
+                                    // Final mode may prohibit reopening. Sync the writer's still-owned
+                                    // descriptor without widening permissions or syncing its parent.
+                                    syncFileBestEffortSync(fd);
+                                    check();
+                                }
+                                else {
+                                    publishedFiles.push({ relativePath: relPath, identity,
+                                        guards: ancestors.map((ancestor) => ancestor.guard) });
+                                }
+                            };
+                        }
+                        await targetRoot.copyIn(relPath, sourcePath, options);
                         check();
                         await assertGuards();
                         await assertResolvedInsideDestination({
-                            destinationRealDir: params.destinationRealDir, targetPath: destinationPath, originalPath,
+                            destinationRealDir, targetPath: destinationPath, originalPath,
                         });
                         check();
-                        const stat = await fs.lstat(destinationPath);
+                        const stat = fsSync.lstatSync(destinationPath);
                         check();
                         if (stat.isSymbolicLink() || (stat.isFile() && stat.nlink > 1)) {
                             throw createArchiveSymlinkTraversalError(originalPath);
                         }
                     }
                     catch (error) {
-                        // copyIn alone owns cleanup; no receipt permits archive-layer unlink.
+                        // copyIn cleans unpublished stages; merge never gains rollback authority.
                         if (error instanceof FsSafeError && (error.code === "hardlink" || error.code === "path-alias")) {
                             throw createArchiveSymlinkTraversalError(originalPath);
                         }
@@ -154,4 +199,8 @@ async function mergeTree(params, publication) {
         }
     };
     await walk(params.sourceDir);
+    if (publication) {
+        await finalizeArchivePublication({ targetRoot, destinationGuard, sourceGuard,
+            files: publishedFiles, directories: publishedDirectories, durable, deadline: params.deadline });
+    }
 }

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

@@ -5,6 +5,7 @@ import type { ExtractArchiveOptions } from "./archive-options.js";
 import type { NativeBinding } from "./native.js";
 export declare function throwMappedNativeArchiveError(error: unknown): never;
 export declare function extractNativeArchive(params: {
+    durable?: boolean;
     binding: NativeBinding;
     archivePath: string;
     destDir: string;

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

@@ -1 +1 @@
-{"version":3,"file":"archive-native.d.ts","sourceRoot":"","sources":["../src/archive-native.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAOlE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAYnE;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,WAAW,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,4BAA4B,CAAC;IACrC,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,qBAAqB,CAAC,aAAa,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;CAClD,GAAG,OAAO,CAAC,IAAI,CAAC,CA6FhB"}
+{"version":3,"file":"archive-native.d.ts","sourceRoot":"","sources":["../src/archive-native.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAEL,KAAK,4BAA4B,EACjC,KAAK,cAAc,EACpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAOlE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAYnE;AAED,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,aAAa,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,WAAW,CAAC;IAClB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,4BAA4B,CAAC;IACrC,SAAS,EAAE,cAAc,CAAC;IAC1B,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;IACjD,WAAW,CAAC,EAAE,qBAAqB,CAAC,aAAa,CAAC,CAAC;IACnD,UAAU,CAAC,EAAE,qBAAqB,CAAC,YAAY,CAAC,CAAC;CAClD,GAAG,OAAO,CAAC,IAAI,CAAC,CAkFhB"}

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

@@ -1,14 +1,15 @@
 import { classifyArchiveParserError } from "./archive-parser-errors.js";
 import { constants as fsConstants } from "node:fs";
 import fs from "node:fs/promises";
-import { ArchiveFormatError, ArchiveSecurityError, isArchiveFormatErrorMessage, } from "./archive-errors.js";
-import { stripArchivePath, validateArchiveEntryPath } from "./archive-entry.js";
+import { ArchiveFormatError, isArchiveFormatErrorMessage, } from "./archive-errors.js";
+import { validateArchiveEntryPath } from "./archive-entry.js";
 import { createArchiveEntryPlanner } from "./archive-plan.js";
 import { stageArchiveFileForExtraction } from "./archive-input.js";
 import { assertArchiveEntryCountWithinLimit, } from "./archive-limits.js";
-import { prepareArchiveDestinationDir, withStagedArchiveDestination, } from "./archive-staging.js";
+import { prepareArchiveDestinationGuard, withStagedArchiveDestination, } from "./archive-staging.js";
 import { mergePlannedArchiveIntoDestination } from "./archive-merge.js";
 import { admitZipFile } from "./archive-zip-admission.js";
+import { validateNativeZipManifest } from "./archive-zip-manifest.js";
 export function throwMappedNativeArchiveError(error) {
     if (error instanceof Error) {
         const mapped = classifyArchiveParserError(error.message, { cause: error });
@@ -32,34 +33,23 @@ export async function extractNativeArchive(params) {
     });
     try {
         const zipEntries = [];
-        const physicalCount = params.kind === "zip"
-            ? await admitZipFile(stagedArchive.path, limits, params.deadline, (entry) => { zipEntries.push(entry); })
-            : undefined;
-        const destinationRealDir = await prepareArchiveDestinationDir(params.destDir);
+        if (params.kind === "zip") {
+            await admitZipFile(stagedArchive.path, limits, params.deadline, (entry) => { zipEntries.push(entry); });
+        }
+        const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
+        const destinationRealDir = destinationGuard.realPath;
         await withStagedArchiveDestination({
             destinationRealDir,
             run: async (stagingDir) => {
                 params.deadline.check();
+                // N-API retains completed task state on its signal; each pass needs its own.
                 const manifest = await params.binding
-                    .inspectArchiveNative(stagedArchive.path, params.kind, tarLimits, params.deadline.signal)
+                    .inspectArchiveNative(stagedArchive.path, params.kind, tarLimits, AbortSignal.any([params.deadline.signal]))
                     .catch(throwMappedNativeArchiveError);
                 params.deadline.check();
                 assertArchiveEntryCountWithinLimit(manifest.length, limits);
-                if (physicalCount !== undefined && manifest.length !== physicalCount) {
-                    throw new ArchiveSecurityError("entry-path", "zip decoder collapsed entry names");
-                }
                 if (params.kind === "zip") {
-                    for (const [ordinal, entry] of manifest.entries()) {
-                        const physical = zipEntries[ordinal];
-                        // Native ZIP indices are physical central-directory ordinals. Legacy
-                        // filename decoding remains native-selected; compare names when known.
-                        if (!physical || physical.index !== ordinal || entry.index !== ordinal ||
-                            entry.size !== physical.size ||
-                            (physical.path !== undefined && stripArchivePath(entry.path, 0) !== stripArchivePath(physical.path, 0)) ||
-                            (physical.creatorSystem === 3 && entry.mode !== physical.externalAttributes >>> 16)) {
-                            throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
-                        }
-                    }
+                    validateNativeZipManifest(manifest, zipEntries);
                 }
                 // Recheck the native manifest at the shared policy boundary before
                 // any caller callback observes an entry.
@@ -84,7 +74,7 @@ export async function extractNativeArchive(params) {
                     (typeof fsConstants.O_DIRECTORY === "number" ? fsConstants.O_DIRECTORY : 0));
                 try {
                     params.deadline.check();
-                    await params.binding.extractArchiveNative(stagedArchive.path, params.kind, directory.fd, plan.map((entry) => ({ ...entry, mode: entry.kind === "directory" ? 0o700 : 0o600 })), tarLimits, params.deadline.signal).catch(throwMappedNativeArchiveError);
+                    await params.binding.extractArchiveNative(stagedArchive.path, params.kind, directory.fd, plan.map((entry) => ({ ...entry, mode: entry.kind === "directory" ? 0o700 : 0o600 })), tarLimits, AbortSignal.any([params.deadline.signal])).catch(throwMappedNativeArchiveError);
                 }
                 finally {
                     await directory.close().catch(() => undefined);
@@ -92,9 +82,9 @@ export async function extractNativeArchive(params) {
                 params.deadline.check();
                 await mergePlannedArchiveIntoDestination({
                     entries: plan,
+                    durable: params.durable,
                     sourceDir: stagingDir,
-                    destinationDir: params.destDir,
-                    destinationRealDir,
+                    destinationGuard,
                     deadline: params.deadline,
                 });
                 params.deadline.check();

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

@@ -9,6 +9,8 @@ export type ExtractArchiveOptions = {
     archivePath: string;
     destDir: string;
     timeoutMs: number;
+    /** Sync published files and directories before returning. Defaults to false. */
+    durable?: boolean;
     kind?: ArchiveKind;
     stripComponents?: number;
     tarGzip?: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"archive-options.d.ts","sourceRoot":"","sources":["../src/archive-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,CAAC"}
+{"version":3,"file":"archive-options.d.ts","sourceRoot":"","sources":["../src/archive-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EACV,kBAAkB,EAClB,sBAAsB,EACtB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;IACjC,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,MAAM,CAAC,EAAE,aAAa,CAAC;IACvB,UAAU,CAAC,EAAE,sBAAsB,CAAC;IACpC,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,CAAC"}

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

@@ -17,7 +17,7 @@ export function createArchiveEntryPlanner(params, archiveKind) {
         const canonicalPath = stripArchivePath(entry.path, 0);
         if (!canonicalPath)
             return null;
-        const relPath = stripArchivePath(canonicalPath, strip);
+        const relPath = strip === 0 ? canonicalPath : stripArchivePath(canonicalPath, strip);
         if (!relPath)
             return null;
         validateArchiveEntryPath(relPath, { escapeLabel: params.escapeLabel });

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

@@ -1 +1 @@
-{"version":3,"file":"archive-read.d.ts","sourceRoot":"","sources":["../src/archive-read.ts"],"names":[],"mappings":"AAcA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAkLpG,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,GAChD,OAAO,CAAC,MAAM,CAAC,CA6EjB"}
+{"version":3,"file":"archive-read.d.ts","sourceRoot":"","sources":["../src/archive-read.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAiD,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AA0OpG,wBAAsB,gBAAgB,CACpC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,WAAW,CAAA;CAAE,GAChD,OAAO,CAAC,MAAM,CAAC,CAkBjB"}