@openclaw/openshell-sandbox 2026.9.5 → 2026.9.6

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

@@ -1,38 +1,37 @@
-import { createTarEntryPlanner } from "./archive-tar.js";
+import { createTarEntryPlanner, createArchiveEntrySelector, resolveArchiveFilteredEntryPolicy, createArchiveEntryPlanner, } from "./archive-plan.js";
 import { inspectTar, replayTar } from "./archive-tar-stream.js";
 import { runPinnedWriteHelper } from "./pinned-write.js";
 import { constants as fsConstants } from "node:fs";
-import fs from "node:fs/promises";
+import fs, {} from "node:fs/promises";
 import path from "node:path";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
-import { createArchiveOutputPathTracker, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 import { createPipelineTimeoutError, waitForDeadline, withExtractionDeadline, } from "./archive-deadline.js";
-import { assertArchiveEntryCountWithinLimit, assertArchiveEntryPathComponentsWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, resolveTarMeterLimits, } from "./archive-limits.js";
-import { assertPortableArchiveKind, resolveArchiveKind } from "./archive-kind.js";
-import { prepareArchiveDestinationGuard, preparePrivateArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
-import { mergePlannedArchiveIntoDestination } from "./archive-merge.js";
+import { assertArchiveEntryCountWithinLimit, createByteBudgetTracker, createExtractBudgetTransform, resolveExtractLimits, resolveTarMeterLimits, } from "./archive-limits.js";
+import { resolveArchiveKind } from "./archive-kind.js";
+import { prepareArchiveDestinationGuard, preparePrivateArchiveOutputPath, } from "./archive-staging.js";
+import { withStagedArchivePublication } from "./archive-merge.js";
 import { loadZipArchiveWithPreflight } from "./archive-zip-preflight.js";
-import { isZipSymlinkEntry, zipEntryDeclaredSize, zipEntryMode, } from "./archive-zip-entry.js";
+import { admittedZipEntries } from "./archive-zip-loader.js";
+import { zipEntryKind, zipEntryDeclaredSize, zipEntryMode, } from "./archive-zip-entry.js";
 import { createZipIntegrityTransform, normalizeZipIntegrityError, } from "./archive-zip-integrity.js";
-import { FsSafeError } from "./errors.js";
-import { ArchiveSecurityError } from "./archive-errors.js";
-import { extractNativeArchive } from "./archive-native.js";
+import { ArchiveSecurityError, ArchiveFormatError, isArchiveFormatErrorMessage, } from "./archive-errors.js";
 import { stageArchiveFileForExtraction } from "./archive-input.js";
-import { getNativeBinding } from "./native.js";
-import { resolveArchiveFilteredEntryPolicy, shouldExtractArchiveEntry, } from "./archive-policy.js";
+import { getNativeBinding, } from "./native.js";
 import { writeSiblingTempFile } from "./sibling-temp.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
-import { realpathSync } from "./realpath.js";
+import { classifyArchiveParserError } from "./archive-parser-errors.js";
+import { validateArchiveEntryPath } from "./archive-entry.js";
+import { admitZipFile } from "./archive-zip-admission.js";
+import { validateNativeZipManifest } from "./archive-zip-manifest.js";
 export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
 export { resolveArchiveKind, resolvePackedRootDir } from "./archive-kind.js";
 export { readArchiveEntry } from "./archive-read.js";
-export { inspectTarArchive } from "./archive-tar-inspect.js";
 export { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, DEFAULT_MAX_ARCHIVE_BYTES_ZIP, DEFAULT_MAX_ENTRIES, DEFAULT_MAX_EXTRACTED_BYTES, DEFAULT_MAX_ENTRY_BYTES, DEFAULT_MAX_META_ENTRY_BYTES, DEFAULT_MAX_ENTRY_PATH_COMPONENTS, } from "./archive-limits.js";
 export { ArchiveFormatError } from "./archive-errors.js";
 export { ArchiveSecurityError } from "./archive-staging.js";
 export { createArchiveSymlinkTraversalError, mergeExtractedTreeIntoDestination, prepareArchiveDestinationDir, prepareArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
-export { createTarEntryPreflightChecker } from "./archive-tar.js";
+export { createTarEntryPreflightChecker } from "./archive-plan.js";
 export { loadZipArchiveWithPreflight, readZipCentralDirectoryEntryCount, } from "./archive-zip-preflight.js";
 const SUPPORTS_NOFOLLOW = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants;
 const OPEN_WRITE_CREATE_FLAGS = fsConstants.O_WRONLY |
@@ -47,26 +46,6 @@ async function readZipEntryStream(entry) {
     const buf = await entry.async("nodebuffer");
     return Readable.from(buf);
 }
-function resolveZipOutputPath(params) {
-    validateArchiveEntryPath(params.entryPath);
-    const canonicalPath = stripArchivePath(params.entryPath, 0);
-    if (!canonicalPath)
-        return null;
-    const relPath = params.strip === 0 ? canonicalPath : stripArchivePath(canonicalPath, params.strip);
-    if (!relPath) {
-        return null;
-    }
-    validateArchiveEntryPath(relPath);
-    return {
-        canonicalPath,
-        relPath,
-        outPath: resolveArchiveOutputPath({
-            rootDir: params.destinationDir,
-            relPath,
-            originalPath: params.entryPath,
-        }),
-    };
-}
 async function writeZipFileEntry(params) {
     params.deadline.check();
     params.budget.startEntry();
@@ -95,7 +74,7 @@ async function writeZipFileEntry(params) {
                 }
                 params.deadline.check();
                 if (!handleClosedByStream) {
-                    await tempHandle.close().catch(() => undefined);
+                    await tempHandle.close();
                     handleClosedByStream = true;
                 }
                 tempHandle = null;
@@ -117,95 +96,56 @@ async function writeZipFileEntry(params) {
     }
 }
 async function extractZip(params) {
-    const limits = resolveExtractLimits(params.limits);
-    const stagedArchive = await stageArchiveFileForExtraction({
-        archivePath: params.archivePath,
-        limits,
-        deadline: params.deadline,
+    const { limits, deadline } = params;
+    const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
+    deadline.check();
+    const buffer = await fs.readFile(params.archivePath, { signal: deadline.signal });
+    deadline.check();
+    const zip = await waitForDeadline(loadZipArchiveWithPreflight(buffer, limits), deadline);
+    deadline.check();
+    const entries = admittedZipEntries(zip);
+    assertArchiveEntryCountWithinLimit(entries.length, limits);
+    const budget = createByteBudgetTracker(limits);
+    await withStagedArchivePublication({ ...params, destinationGuard }, async (stagingDir) => {
+        const { select } = createArchiveEntrySelector({ ...params, rootDir: stagingDir });
+        const acceptedEntries = [];
+        for (const entry of entries) {
+            deadline.check();
+            const entryKind = zipEntryKind(entry);
+            const relPath = select({ path: entry.name, kind: entryKind, size: zipEntryDeclaredSize(entry) });
+            if (relPath === null)
+                continue;
+            if (entryKind === "symlink") {
+                throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
+            }
+            if (entryKind === "other")
+                continue;
+            const mode = zipEntryMode(entry, params.entryModes);
+            acceptedEntries.push({ path: relPath, kind: entry.dir ? "directory" : "file", mode });
+            const outPath = path.join(stagingDir, relPath);
+            await preparePrivateArchiveOutputPath({
+                destinationDir: stagingDir,
+                destinationRealDir: stagingDir,
+                relPath,
+                outPath,
+                originalPath: entry.name,
+                isDirectory: entry.dir,
+                deadline,
+            });
+            if (!entry.dir) {
+                await writeZipFileEntry({ entry, outPath, budget, deadline });
+            }
+        }
+        return acceptedEntries;
     });
-    try {
-        const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
-        const destinationRealDir = destinationGuard.realPath;
-        params.deadline.check();
-        const buffer = await fs.readFile(stagedArchive.path, { signal: params.deadline.signal });
-        params.deadline.check();
-        const zip = await waitForDeadline(loadZipArchiveWithPreflight(buffer, limits), params.deadline);
-        params.deadline.check();
-        const entries = Object.values(zip.files);
-        const strip = Math.max(0, Math.floor(params.stripComponents ?? 0));
-        assertArchiveEntryCountWithinLimit(entries.length, limits);
-        const budget = createByteBudgetTracker(limits);
-        const trackOutputPath = createArchiveOutputPathTracker();
-        await withStagedArchiveDestination({
-            destinationRealDir,
-            run: async (stagingDir) => {
-                const stagingRealDir = realpathSync.native(stagingDir);
-                const acceptedEntries = [];
-                for (const entry of entries) {
-                    params.deadline.check();
-                    const output = resolveZipOutputPath({
-                        entryPath: entry.name,
-                        strip,
-                        destinationDir: stagingRealDir,
-                    });
-                    if (!output) {
-                        continue;
-                    }
-                    assertArchiveEntryPathComponentsWithinLimit(output.relPath, limits);
-                    trackOutputPath(output.relPath, entry.name);
-                    const isSymlink = isZipSymlinkEntry(entry);
-                    const entryKind = isSymlink ? "symlink" : entry.dir ? "directory" : "file";
-                    const entrySize = zipEntryDeclaredSize(entry);
-                    if (!shouldExtractArchiveEntry({
-                        filter: params.entryFilter,
-                        onFiltered: params.onFiltered,
-                        entry: { path: output.canonicalPath, kind: entryKind, size: entrySize },
-                    })) {
-                        continue;
-                    }
-                    if (isSymlink) {
-                        throw new ArchiveSecurityError("entry-link", `zip entry is a link: ${entry.name}`);
-                    }
-                    const mode = zipEntryMode(entry, params.entryModes);
-                    acceptedEntries.push({ path: output.relPath, kind: entry.dir ? "directory" : "file", mode });
-                    await preparePrivateArchiveOutputPath({
-                        destinationDir: stagingRealDir,
-                        destinationRealDir: stagingRealDir,
-                        relPath: output.relPath,
-                        outPath: output.outPath,
-                        originalPath: entry.name,
-                        isDirectory: entry.dir,
-                        deadline: params.deadline,
-                    });
-                    if (entry.dir) {
-                        continue;
-                    }
-                    await writeZipFileEntry({
-                        entry,
-                        outPath: output.outPath,
-                        budget,
-                        deadline: params.deadline,
-                    });
-                }
-                params.deadline.check();
-                await mergePlannedArchiveIntoDestination({
-                    entries: acceptedEntries,
-                    durable: params.durable,
-                    sourceDir: stagingRealDir,
-                    destinationGuard,
-                    deadline: params.deadline,
-                });
-                params.deadline.check();
-            },
-        });
-    }
-    finally {
-        await stagedArchive.cleanup();
-    }
 }
 export async function extractArchive(params) {
     const archivePath = params.archivePath;
     const destDir = params.destDir;
+    const { entryUmask = 0 } = params;
+    if (!Number.isInteger(entryUmask) || entryUmask < 0 || entryUmask > 0o777) {
+        throw new RangeError("archive entryUmask must be an integer between 0 and 0o777");
+    }
     const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
     const kind = params.kind ?? resolveArchiveKind(archivePath);
     if (!kind) {
@@ -223,65 +163,167 @@ export async function extractArchive(params) {
         archivePath, destDir,
         durable: params.durable,
         stripComponents: params.stripComponents, limits,
-        entryModes: params.entryModes, entryFilter: params.entryFilter, onFiltered,
+        entryModes: params.entryModes, entryUmask, entryFilter: params.entryFilter, onFiltered,
     };
-    if (native) {
-        await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractNativeArchive({ ...options, binding: native, kind, tarLimits, deadline }));
-        return;
-    }
-    assertPortableArchiveKind(kind);
-    if (kind === "tar") {
-        await withExtractionDeadline(params.timeoutMs, label, async (deadline) => {
-            const stagedArchive = await stageArchiveFileForExtraction({
-                archivePath: options.archivePath,
-                limits,
-                deadline,
-            });
-            try {
-                await extractWasmTar({ archivePath: stagedArchive.path, options, limits, tarLimits, deadline });
-            }
-            finally {
-                await stagedArchive.cleanup();
-            }
-        });
-        return;
-    }
-    await withExtractionDeadline(params.timeoutMs, label, async (deadline) => extractZip({ ...options, deadline }));
+    await withExtractionDeadline(params.timeoutMs, label, async (deadline) => {
+        const stagedArchive = await stageArchiveFileForExtraction({ archivePath, limits, deadline });
+        try {
+            deadline.check();
+            const stagedOptions = { ...options, archivePath: stagedArchive.path, deadline };
+            if (native)
+                await extractNativeArchive({ ...stagedOptions, binding: native, kind, tarLimits });
+            else if (kind === "zip")
+                await extractZip(stagedOptions);
+            else
+                await extractWasmTar({ ...stagedOptions, kind, tarLimits });
+        }
+        finally {
+            await stagedArchive.cleanup();
+        }
+    });
 }
 async function extractWasmTar(params) {
-    const { options, deadline, tarLimits } = params;
+    const { deadline, tarLimits } = params;
     const manifest = [];
-    await inspectTar({ archivePath: params.archivePath, limits: tarLimits, signal: deadline.signal,
+    await inspectTar({ archivePath: params.archivePath, kind: params.kind, limits: tarLimits, signal: deadline.signal,
         onMember: (entry) => { manifest.push(entry); } });
     deadline.check();
-    const destinationGuard = await prepareArchiveDestinationGuard(options.destDir);
-    const destinationRealDir = destinationGuard.realPath;
-    await withStagedArchiveDestination({ destinationRealDir, run: async (stagingPath) => {
-            const stagingDir = realpathSync.native(stagingPath);
-            const planEntry = createTarEntryPlanner({ ...options, rootDir: destinationRealDir, limits: params.limits });
-            const accepted = manifest.flatMap((entry) => {
+    const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
+    await withStagedArchivePublication({ ...params, destinationGuard }, async (stagingDir) => {
+        const planEntry = createTarEntryPlanner({ ...params, rootDir: destinationGuard.realPath });
+        const accepted = manifest.flatMap((entry) => {
+            deadline.check();
+            const planned = planEntry(entry);
+            return planned ? [{ ...entry, ...planned }] : [];
+        });
+        await replayTar({ archivePath: params.archivePath, kind: params.kind, limits: tarLimits, signal: deadline.signal, members: accepted,
+            async consume(member, payload) {
                 deadline.check();
-                const planned = planEntry(entry);
-                return planned ? [{ ...entry, ...planned }] : [];
-            });
-            await replayTar({ archivePath: params.archivePath, limits: tarLimits, signal: deadline.signal, members: accepted,
-                async consume(member, payload) {
+                await preparePrivateArchiveOutputPath({ destinationDir: stagingDir, destinationRealDir: stagingDir,
+                    relPath: member.path, outPath: path.join(stagingDir, member.path), originalPath: member.path,
+                    isDirectory: member.kind === "directory", deadline });
+                if (member.kind === "file") {
+                    await runPinnedWriteHelper({ rootPath: stagingDir, relativeParentPath: path.posix.dirname(member.path),
+                        basename: path.posix.basename(member.path), mkdir: false, mode: 0o600, overwrite: false,
+                        sync: false,
+                        maxBytes: member.size, input: { kind: "stream", stream: Readable.from(payload) } });
+                }
+                deadline.check();
+            },
+        });
+        return accepted;
+    });
+}
+function throwMappedNativeArchiveError(error) {
+    if (error instanceof Error) {
+        const mapped = classifyArchiveParserError(error.message, { cause: error });
+        if (mapped)
+            throw mapped;
+        if (isArchiveFormatErrorMessage(error.message)) {
+            throw new ArchiveFormatError(error.message, { cause: error });
+        }
+        if (error.code === "InvalidArg") {
+            throw new ArchiveFormatError(`invalid archive: ${error.message}`, { cause: error });
+        }
+    }
+    throw error;
+}
+async function extractNativeArchive(params) {
+    const { archivePath, limits, tarLimits, deadline } = params;
+    const zipEntries = [];
+    if (params.kind === "zip") {
+        await admitZipFile(archivePath, limits, deadline, (entry) => { zipEntries.push(entry); });
+    }
+    const destinationGuard = await prepareArchiveDestinationGuard(params.destDir);
+    await withStagedArchivePublication({ ...params, destinationGuard }, async (stagingDir) => {
+        deadline.check();
+        // N-API retains completed task state on its signal; each pass needs its own.
+        const manifest = await params.binding
+            .inspectArchiveNative(archivePath, params.kind, tarLimits, AbortSignal.any([deadline.signal]))
+            .catch(throwMappedNativeArchiveError);
+        deadline.check();
+        assertArchiveEntryCountWithinLimit(manifest.length, limits);
+        if (params.kind === "zip") {
+            validateNativeZipManifest(manifest, zipEntries);
+        }
+        // Recheck the native manifest before any caller callback observes an entry.
+        if (params.kind !== "zip") {
+            for (const entry of manifest)
+                validateArchiveEntryPath(entry.path);
+        }
+        const planEntry = createArchiveEntryPlanner({ ...params, rootDir: stagingDir }, params.kind);
+        const plan = [];
+        for (const entry of manifest) {
+            deadline.check();
+            const mode = params.kind === "zip"
+                ? zipEntries[entry.index].creatorSystem === 3
+                    ? zipEntries[entry.index].externalAttributes >>> 16
+                    : undefined
+                : entry.mode;
+            const accepted = planEntry({ ...entry, mode });
+            if (accepted)
+                plan.push({ ...accepted, index: entry.index });
+        }
+        const directory = await fs.open(stagingDir, fsConstants.O_RDONLY |
+            (typeof fsConstants.O_DIRECTORY === "number" ? fsConstants.O_DIRECTORY : 0));
+        try {
+            deadline.check();
+            await params.binding.extractArchiveNative(archivePath, params.kind, directory.fd, plan.map((entry) => ({ ...entry, mode: entry.kind === "directory" ? 0o700 : 0o600 })), tarLimits, AbortSignal.any([deadline.signal])).catch(throwMappedNativeArchiveError);
+        }
+        finally {
+            await directory.close().catch(() => undefined);
+        }
+        return plan;
+    });
+}
+/** Complete TAR/gzip admission and zero-strip extraction policy, without output writes. */
+export async function inspectTarArchive(params) {
+    const archivePath = params.archivePath;
+    const onFiltered = resolveArchiveFilteredEntryPolicy(params.onFiltered);
+    const limits = resolveExtractLimits(params.limits);
+    const tarLimits = resolveTarMeterLimits(limits);
+    const native = getNativeBinding();
+    assertNoWindowsPathAlias(archivePath, "filesystem", "archive source uses a Windows filesystem namespace alias");
+    return await withExtractionDeadline(params.timeoutMs, "inspect tar", async (deadline) => {
+        const staged = await stageArchiveFileForExtraction({ archivePath, limits, deadline });
+        try {
+            // Staging closes descriptors asynchronously; expiry there must not start a decoder.
+            deadline.check();
+            const entries = [];
+            const append = (entry) => {
+                if (entry)
+                    entries.push(Object.freeze({ path: entry.path, kind: entry.kind, size: entry.size }));
+            };
+            const policy = { limits, entryFilter: params.entryFilter, onFiltered };
+            if (native) {
+                const manifest = await native.inspectArchiveNative(staged.path, "tar", tarLimits, deadline.signal)
+                    .catch(throwMappedNativeArchiveError);
+                deadline.check();
+                // Match extraction's whole-manifest validation before caller policy runs.
+                for (const entry of manifest)
+                    validateArchiveEntryPath(entry.path);
+                const planEntry = createArchiveEntryPlanner(policy, "tar");
+                for (const entry of manifest) {
                     deadline.check();
-                    await preparePrivateArchiveOutputPath({ destinationDir: stagingDir, destinationRealDir: stagingDir,
-                        relPath: member.path, outPath: path.join(stagingDir, member.path), originalPath: member.path,
-                        isDirectory: member.kind === "directory", deadline });
-                    if (member.kind === "file") {
-                        await runPinnedWriteHelper({ rootPath: stagingDir, relativeParentPath: path.posix.dirname(member.path),
-                            basename: path.posix.basename(member.path), mkdir: false, mode: 0o600, overwrite: false,
-                            sync: false,
-                            maxBytes: member.size, input: { kind: "stream", stream: Readable.from(payload) } });
-                    }
+                    append(planEntry(entry));
+                }
+            }
+            else {
+                const manifest = [];
+                await inspectTar({ archivePath: staged.path, limits: tarLimits, signal: deadline.signal,
+                    onMember: (entry) => { manifest.push(entry); } });
+                const planEntry = createTarEntryPlanner(policy);
+                for (const entry of manifest) {
                     deadline.check();
-                },
-            });
-            deadline.check();
-            await mergePlannedArchiveIntoDestination({ entries: accepted, sourceDir: stagingDir, destinationGuard,
-                deadline, durable: options.durable });
+                    append(planEntry(entry));
+                }
+            }
             deadline.check();
-        } });
+            // This is bounded evidence about the staged bytes, not a reusable write plan.
+            return Object.freeze(entries);
+        }
+        finally {
+            await staged.cleanup();
+        }
+    });
 }

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

@@ -1,2 +1 @@
 export declare function createAsyncLock(): <T>(fn: () => Promise<T>) => Promise<T>;
-//# sourceMappingURL=async-lock.d.ts.map

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

@@ -1,5 +1,6 @@
-export { replaceFileAtomic, replaceFileAtomicSync, type RenameIdentityPolicy, type ReplaceFileAtomicFileSystem, type ReplaceFileAtomicOptions, type ReplaceFileAtomicRestoreCleanup, type ReplaceFileAtomicRestoreFailureDetails, type ReplaceFileAtomicResult, type ReplaceFileCopyFallbackRestorePolicy, type ReplaceFileDestinationHardlinkPolicy, type ReplaceFileAtomicSyncFileSystem, type ReplaceFileAtomicSyncOptions, } from "./replace-file.js";
+export { replaceFileAtomic, replaceFileAtomicSync, type ReplaceFileAtomicFileSystem, type ReplaceFileAtomicOptions, type ReplaceFileAtomicResult, type ReplaceFileAtomicSyncFileSystem, type ReplaceFileAtomicSyncOptions, } from "./replace-file.js";
+export type { RenameIdentityPolicy } from "./pinned-write-types.js";
+export type { ReplaceFileAtomicRestoreCleanup, ReplaceFileAtomicRestoreFailureDetails, ReplaceFileCopyFallbackRestorePolicy, ReplaceFileDestinationHardlinkPolicy, } from "./replace-file-copy-fallback.js";
 export { writeTextAtomic, type WriteTextAtomicOptions } from "./text-atomic.js";
 export { replaceDirectoryAtomic, type ReplaceDirectoryAtomicOptions } from "./replace-directory.js";
 export { movePathWithCopyFallback, type MovePathPublicationReceipt, type MovePathWithCopyFallbackOptions, } from "./move-path.js";
-//# sourceMappingURL=atomic.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/bounded-read-stream.d.ts

@@ -1,4 +1,2 @@
 import { Transform } from "node:stream";
-export declare function createMaxBytesTransform(maxBytes: number): Transform;
 export declare function createByteLimitTransform(maxBytes: number, overflowError: (bytes: number) => Error): Transform;
-//# sourceMappingURL=bounded-read-stream.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/bounded-read-stream.js

@@ -1,10 +1,4 @@
 import { Transform } from "node:stream";
-import { normalizeMaxBytes } from "./byte-budget.js";
-import { FsSafeError } from "./errors.js";
-export function createMaxBytesTransform(maxBytes) {
-    normalizeMaxBytes(maxBytes);
-    return createByteLimitTransform(maxBytes, (bytes) => new FsSafeError("too-large", `file exceeds limit of ${maxBytes} bytes (got at least ${bytes})`));
-}
 export function createByteLimitTransform(maxBytes, overflowError) {
     let bytes = 0;
     return new Transform({

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

@@ -23,4 +23,3 @@ export declare function readBoundedSync(maxBytes: number, readChunk: (scratch: B
 /** Sync bounded read from a numeric descriptor. The caller owns the descriptor. */
 export declare function readFileDescriptorBoundedSync(fd: number, maxBytes: number): Buffer;
 export {};
-//# sourceMappingURL=bounded-read.d.ts.map

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

@@ -1,4 +1,3 @@
 export declare function normalizeMaxBytes(value: number | undefined, options?: {
     defaultValue?: number;
 }): number | undefined;
-//# sourceMappingURL=byte-budget.d.ts.map

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

@@ -0,0 +1,2 @@
+/** Snapshot intrinsic view bounds without copying the borrowed payload. */
+export declare function snapshotByteView(bytes: Uint8Array): Uint8Array;

package/node_modules/@openclaw/fs-safe/dist/byte-view.js

@@ -0,0 +1,13 @@
+const ByteView = Uint8Array;
+const typedArray = Object.getPrototypeOf(ByteView.prototype);
+const viewLength = Object.getOwnPropertyDescriptor(typedArray, "byteLength").get;
+const viewOffset = Object.getOwnPropertyDescriptor(typedArray, "byteOffset").get;
+const viewBuffer = Object.getOwnPropertyDescriptor(typedArray, "buffer").get;
+/** Snapshot intrinsic view bounds without copying the borrowed payload. */
+export function snapshotByteView(bytes) {
+    const length = Reflect.apply(viewLength, bytes, []);
+    // Preserve empty, detached, and out-of-bounds views as zero-byte inputs.
+    if (length === 0)
+        return new ByteView(0);
+    return new ByteView(Reflect.apply(viewBuffer, bytes, []), Reflect.apply(viewOffset, bytes, []), length);
+}

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

@@ -13,7 +13,7 @@ export type CloneFileMetadata = {
     cloneId: bigint;
 };
 /** Batched APFS metadata snapshots; absent on unsupported files or filesystems.
+ * On macOS, these snapshots require the native helper.
  * These are point-in-time facts, not authorization or a guarantee against later edits.
  */
 export declare function readCloneFileMetadata(files: readonly string[]): Promise<(CloneFileMetadata | undefined)[]>;
-//# sourceMappingURL=clone-metadata.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/clone-metadata.js

@@ -1,11 +1,15 @@
 import { assertAbsolutePathInput } from "./absolute-path.js";
-import { requireNativeBinding } from "./native.js";
+import { getNativeBinding, requireNativeBinding } from "./native.js";
 /** Batched APFS metadata snapshots; absent on unsupported files or filesystems.
+ * On macOS, these snapshots require the native helper.
  * These are point-in-time facts, not authorization or a guarantee against later edits.
  */
 export async function readCloneFileMetadata(files) {
     const paths = files.map(assertAbsolutePathInput);
-    const results = await requireNativeBinding().readCloneFileMetadata(paths);
+    const native = process.platform === "darwin" ? requireNativeBinding() : getNativeBinding();
+    if (!native)
+        return paths.map(() => undefined);
+    const results = await native.readCloneFileMetadata(paths);
     return results.map((result) => {
         if (!result ||
             result.length !== 100 ||

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

@@ -1,3 +1,2 @@
 export { configureFsSafePython, configureFsSafeNative, getFsSafeNativeConfig, type FsSafePythonConfig, type FsSafeNativeConfig, type FsSafeNativeMode, } from "./native-config.js";
 export { configureFsSafeLocks, getFsSafeLockConfig, type FsSafeLockConfig, } from "./lock-config.js";
-//# sourceMappingURL=config.d.ts.map

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

@@ -1,2 +1 @@
 export type ContainmentGuarantee = "kernel-atomic" | "best-effort";
-//# sourceMappingURL=containment.d.ts.map

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

@@ -19,4 +19,3 @@ export declare function assertCopySourceCurrent(source: {
 export declare function writeCopyFileToFd(fd: number, input: CopyFileInput, maxBytes?: number, assertBeforeMutation?: () => void): Promise<void>;
 export declare function createNativeCopyFile(native: NativeBinding, input: CopyFileInput, parentFd: number, basename: string, maxBytes: number | undefined, sync: boolean): Promise<NativeFileCopyResult | undefined>;
 export declare function assertNativeCopyCompleted(input: CopyFileInput, copied?: NativeFileCopyResult): void;
-//# sourceMappingURL=copy-file-input.d.ts.map

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

@@ -1,3 +1,2 @@
 export type CopyCloneMode = "auto" | "always" | "never";
 export declare function resolveCopyCloneMode(mode: CopyCloneMode | undefined, defaultMode: CopyCloneMode): CopyCloneMode;
-//# sourceMappingURL=copy-policy.d.ts.map

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

@@ -1,4 +1,5 @@
-import type { PinnedWriteParams, PublishedWriteIdentity } from "./pinned-write.js";
+import type { BigIntStats } from "node:fs";
+import type { PinnedWriteParams, PublishedWriteIdentity } from "./pinned-write-types.js";
 export type RootCopyPublicationReceipt = Readonly<{
     path: string;
     dev: bigint;
@@ -9,7 +10,11 @@ export declare function createCopyPublicationObserver(path: string, notify?: (re
     rethrowObserverFailure(error: unknown): void;
 };
 export declare const onCopyPublication: unique symbol;
+export declare const onCopySourceAdmission: unique symbol;
 export type CopyPublicationOptions = {
     [onCopyPublication]?: PinnedWriteParams["verifyPublished"];
+    [onCopySourceAdmission]?: (identity: BigIntStats, realPath: string) => {
+        mode: number;
+        verify(): void;
+    };
 };
-//# sourceMappingURL=copy-publication.d.ts.map

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

@@ -28,3 +28,6 @@ export function createCopyPublicationObserver(path, notify) {
 // Internal composition hook; the descriptor is borrowed until the callback returns.
 // Kept off RootCopyOptions and all public package exports.
 export const onCopyPublication = Symbol("onCopyPublication");
+// Reuse the copy's admitted descriptor identity before any bytes are staged.
+// Internal callers can bind prior observations and select its publication mode.
+export const onCopySourceAdmission = Symbol("onCopySourceAdmission");

package/node_modules/@openclaw/fs-safe/dist/copy-tree-portable.d.ts

@@ -6,4 +6,3 @@ export declare function copyOwnedTree(source: ReturnType<typeof openStagedDirect
     concurrency: number;
     copyFileContents?: NativeBinding["copyFileContents"];
 }): Promise<void>;
-//# sourceMappingURL=copy-tree-portable.d.ts.map