@openclaw/openshell-sandbox 2026.9.5 → 2026.9.7

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,15 +1,18 @@
-import type { PinnedWriteParams, PublishedWriteIdentity } from "./pinned-write.js";
-export type RootCopyPublicationReceipt = Readonly<{
+import type { BigIntStats } from "node:fs";
+import type { PinnedWriteParams, PublishedWriteIdentity } from "./pinned-write-types.js";
+export type RootCopyPublicationReceipt = Readonly<PublishedWriteIdentity & {
     path: string;
-    dev: bigint;
-    ino: bigint;
 }>;
 export declare function createCopyPublicationObserver(path: string, notify?: (receipt: RootCopyPublicationReceipt) => void): {
     onPublished(identity: PublishedWriteIdentity): void;
     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

@@ -1,16 +1,12 @@
 import { FsSafeError } from "./errors.js";
+import { assertSynchronousCallbackResult } from "./mutation-authority.js";
 export function createCopyPublicationObserver(path, notify) {
     let rejected;
     return {
         onPublished(identity) {
             const receipt = Object.freeze({ path, dev: identity.dev, ino: identity.ino });
             try {
-                const result = notify?.(receipt);
-                if (result !== null && (typeof result === "object" || typeof result === "function") &&
-                    "then" in result && typeof result.then === "function") {
-                    void Promise.resolve(result).catch(() => undefined);
-                    throw new TypeError("onDestinationPublished must be synchronous");
-                }
+                assertSynchronousCallbackResult(notify?.(receipt), "onDestinationPublished");
             }
             catch (error) {
                 rejected = { error };
@@ -28,3 +24,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

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

@@ -11,20 +11,25 @@ function timestampSeconds(nanoseconds) {
 }
 /** Byte-copy adapter for the shared immutable-source, caller-owned namespace contract. */
 export async function copyOwnedTree(source, destination, options) {
-    options.signal?.throwIfAborted();
+    const callerSignal = options.signal ? AbortSignal.any([options.signal]) : undefined;
     const cancellation = new AbortController();
     const signal = cancellation.signal;
     setMaxListeners(options.concurrency, signal);
-    const abort = () => cancellation.abort(options.signal?.reason);
-    options.signal?.addEventListener("abort", abort, { once: true });
     const pending = new Set();
     const finishing = new Set();
     const buffers = [];
+    let failure = undefined;
+    function recordFailure(value) {
+        failure ??= { value };
+        cancellation.abort(failure);
+    }
+    if (callerSignal)
+        callerSignal.onabort = () => recordFailure(callerSignal.reason);
     async function schedule(operation, children) {
         signal.throwIfAborted();
         const task = operation()
             .catch((error) => {
-            cancellation.abort(error);
+            recordFailure(error);
         })
             .finally(() => {
             pending.delete(task);
@@ -46,8 +51,8 @@ export async function copyOwnedTree(source, destination, options) {
             }
             output = await fsp.open(to, "wx", 0o600);
             if (options.copyFileContents) {
-                // napi-rs owns onabort. Each admitted file gets a separate signal so
-                // concurrent native copies cannot replace one another's cancellation.
+                // napi-rs owns onabort. Each admitted file gets a separate signal; the
+                // shared failure signal is private, so callers cannot intercept its relay.
                 const fileCancellation = new AbortController();
                 const abortFile = () => fileCancellation.abort();
                 signal.addEventListener("abort", abortFile, { once: true });
@@ -57,6 +62,7 @@ export async function copyOwnedTree(source, destination, options) {
                 }
                 finally {
                     signal.removeEventListener("abort", abortFile);
+                    fileCancellation.signal.onabort = null;
                 }
             }
             else {
@@ -65,13 +71,13 @@ export async function copyOwnedTree(source, destination, options) {
                 try {
                     let position = 0;
                     while (true) {
-                        signal?.throwIfAborted();
+                        signal.throwIfAborted();
                         const { bytesRead } = await input.read(buffer, 0, buffer.length, position);
                         if (bytesRead === 0)
                             break;
                         let written = 0;
                         while (written < bytesRead) {
-                            signal?.throwIfAborted();
+                            signal.throwIfAborted();
                             const { bytesWritten } = await output.write(buffer, written, bytesRead - written, position + written);
                             if (bytesWritten === 0)
                                 throw new Error("copy write made no progress");
@@ -90,20 +96,25 @@ export async function copyOwnedTree(source, destination, options) {
             await output.utimes(timestampSeconds(stat.atimeNs), timestampSeconds(stat.mtimeNs));
         }
         catch (error) {
-            cancellation.abort(error);
-            throw error;
+            recordFailure(error);
         }
-        finally {
+        if (output) {
             try {
-                await output?.close();
+                await output.close();
             }
-            finally {
-                await input.close();
+            catch (error) {
+                recordFailure(error);
             }
         }
+        try {
+            await input.close();
+        }
+        catch (error) {
+            recordFailure(error);
+        }
     }
     async function copyDirectory(from, to, parentChildren) {
-        signal?.throwIfAborted();
+        signal.throwIfAborted();
         const stat = await fsp.lstat(from, { bigint: true });
         // Exclusive admission prevents merging a pre-existing directory, including
         // any destination left by an unsuccessful native clone.
@@ -117,7 +128,7 @@ export async function copyOwnedTree(source, destination, options) {
                 throw new FsSafeError("path-mismatch", "copy source directory changed while opening");
             }
             for (const entry of await fsp.readdir(from, { withFileTypes: true })) {
-                signal?.throwIfAborted();
+                signal.throwIfAborted();
                 assertStagedDirectoryCurrent(target.receipt);
                 assertStagedDirectoryCurrent(original.receipt);
                 const childSource = path.join(from, entry.name);
@@ -151,7 +162,7 @@ export async function copyOwnedTree(source, destination, options) {
                             throw error;
                         }
                     }
-                    signal?.throwIfAborted();
+                    signal.throwIfAborted();
                     await fsp.symlink(link, childTarget, type);
                 }
                 else {
@@ -160,7 +171,7 @@ export async function copyOwnedTree(source, destination, options) {
             }
         }
         catch (error) {
-            cancellation.abort(error);
+            recordFailure(error);
             throw error;
         }
         finally {
@@ -179,18 +190,26 @@ export async function copyOwnedTree(source, destination, options) {
                         assertStagedDirectoryCurrent(target.receipt);
                     }
                 }
-                finally {
+                catch (error) {
+                    recordFailure(error);
+                }
+                if (original) {
                     try {
-                        if (original)
-                            fs.closeSync(original.fd);
+                        fs.closeSync(original.fd);
                     }
-                    finally {
-                        fs.closeSync(target.fd);
+                    catch (error) {
+                        recordFailure(error);
                     }
                 }
+                try {
+                    fs.closeSync(target.fd);
+                }
+                catch (error) {
+                    recordFailure(error);
+                }
             })()
                 .catch((error) => {
-                cancellation.abort(error);
+                recordFailure(error);
             })
                 .finally(() => {
                 finishing.delete(completion);
@@ -206,17 +225,21 @@ export async function copyOwnedTree(source, destination, options) {
         signal.throwIfAborted();
     }
     try {
+        callerSignal?.throwIfAborted();
         await copyDirectory(source.receipt.realPath, destination);
         await Promise.all(finishing);
         signal.throwIfAborted();
     }
     catch (error) {
-        await Promise.all(finishing);
-        options.signal?.throwIfAborted();
-        throw error;
+        recordFailure(error);
     }
     finally {
         await Promise.all(finishing);
-        options.signal?.removeEventListener("abort", abort);
+        if (callerSignal)
+            callerSignal.onabort = null;
     }
+    if (failure)
+        throw failure.value;
+    options.signal?.throwIfAborted();
+    signal.throwIfAborted();
 }

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

@@ -13,4 +13,3 @@ export declare function probeTreeClone(parentPath: string): TreeCloneBackend | u
 export declare function createCloneSource(destination: string, options?: Pick<CopyTreeOptions, "signal">): Promise<void>;
 /** Copy an immutable, caller-owned tree, preferring native cloning unless configured otherwise. */
 export declare function copyTree(source: string, destination: string, options?: CopyTreeOptions): Promise<void>;
-//# sourceMappingURL=copy.d.ts.map

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

@@ -7,18 +7,36 @@ import { FsSafeError } from "./errors.js";
 import { getNativeBinding, requireNativeBinding } from "./native.js";
 import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
 export { readCloneFileMetadata } from "./clone-metadata.js";
+function firstFailure(current, value) {
+    return current ?? { value };
+}
+function closeDescriptor(fd, failure) {
+    try {
+        fs.closeSync(fd);
+        return failure;
+    }
+    catch (error) {
+        return firstFailure(failure, error);
+    }
+}
 /** Inspect an existing real directory without creating probe files. */
 export function probeTreeClone(parentPath) {
     const native = getNativeBinding();
     if (!native)
         return undefined;
     const parent = openStagedDirectory(assertAbsolutePathInput(parentPath));
+    let backend;
+    let failure;
     try {
-        return native.probeTreeClone(parent.fd) ?? undefined;
+        backend = native.probeTreeClone(parent.fd) ?? undefined;
     }
-    finally {
-        fs.closeSync(parent.fd);
+    catch (error) {
+        failure = firstFailure(failure, error);
     }
+    failure = closeDescriptor(parent.fd, failure);
+    if (failure)
+        throw failure.value;
+    return backend;
 }
 /** Create an empty clone source: a Btrfs subvolume or an ordinary supported directory. */
 export async function createCloneSource(destination, options = {}) {
@@ -56,6 +74,7 @@ async function materializeTree(source, destination, options, policy) {
         throw new FsSafeError("invalid-path", "clone destination must name a child directory");
     const parent = openStagedDirectory(path.dirname(target));
     let original;
+    let failure;
     try {
         const supported = native?.probeTreeClone(parent.fd);
         if (!supported && policy === "always") {
@@ -75,12 +94,11 @@ async function materializeTree(source, destination, options, policy) {
         let cloned = false;
         // napi-rs uses the supplied signal's onabort property. Give it a private
         // signal so caller handlers and other admitted native operations stay intact.
-        const cancellation = options.signal && supported ? new AbortController() : undefined;
-        const abort = () => cancellation?.abort();
-        options.signal?.addEventListener("abort", abort, { once: true });
+        const nativeSignal = options.signal && supported ? AbortSignal.any([options.signal]) : undefined;
         try {
             if (native && supported) {
-                await native.cloneTree(original?.fd ?? null, parent.fd, name, concurrency, cancellation?.signal);
+                nativeSignal?.throwIfAborted();
+                await native.cloneTree(original?.fd ?? null, parent.fd, name, concurrency, nativeSignal);
                 cloned = true;
             }
         }
@@ -94,7 +112,8 @@ async function materializeTree(source, destination, options, policy) {
             }
         }
         finally {
-            options.signal?.removeEventListener("abort", abort);
+            if (nativeSignal)
+                nativeSignal.onabort = null;
         }
         options.signal?.throwIfAborted();
         assertStagedDirectoryCurrent(parent.receipt);
@@ -113,13 +132,12 @@ async function materializeTree(source, destination, options, policy) {
             assertStagedDirectoryCurrent(original.receipt);
         }
     }
-    finally {
-        try {
-            if (original)
-                fs.closeSync(original.fd);
-        }
-        finally {
-            fs.closeSync(parent.fd);
-        }
+    catch (error) {
+        failure = firstFailure(failure, error);
     }
+    if (original)
+        failure = closeDescriptor(original.fd, failure);
+    failure = closeDescriptor(parent.fd, failure);
+    if (failure)
+        throw failure.value;
 }

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

@@ -0,0 +1,7 @@
+export type OwnedFileDescriptorSync = {
+    readonly fd: number;
+    close(): void;
+    [Symbol.dispose](): void;
+};
+/** Capture the descriptor's creator-owned closer before it can be reused. */
+export declare function ownFileDescriptorSync(fd: number, closeFd?: (fd: number) => void): OwnedFileDescriptorSync;

package/node_modules/@openclaw/fs-safe/dist/create-owned-file.js

@@ -0,0 +1,16 @@
+import fs from "node:fs";
+/** Capture the descriptor's creator-owned closer before it can be reused. */
+export function ownFileDescriptorSync(fd, closeFd = fs.closeSync) {
+    let open = true;
+    const owner = {
+        fd,
+        close() {
+            if (!open)
+                return;
+            open = false;
+            closeFd(fd);
+        },
+        [Symbol.dispose]() { owner.close(); },
+    };
+    return Object.freeze(owner);
+}

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

@@ -0,0 +1,17 @@
+import { type FileHandle } from "node:fs/promises";
+import { type OwnedFileDescriptorSync } from "./create-owned-file.js";
+import { type CreationPermissions, type CreationParentIdentity } from "./creation-boundary.js";
+export type { OwnedFileDescriptorSync } from "./create-owned-file.js";
+export type CreateFileOptions = CreateDirectoryOptions;
+export declare function createFileSync(targetPath: string, options?: CreateFileOptions): OwnedFileDescriptorSync;
+/** Internal async writer; Windows preparation uses the nonblocking stage owner. */
+export declare function createFileHandle(targetPath: string, options?: CreateFileOptions, admission?: CreationAdmission): Promise<FileHandle>;
+export type CreateDirectoryOptions = CreationPermissions & {
+    assertBeforeMutation?: () => void;
+};
+export type CreationAdmission = {
+    expectedParentIdentity?: CreationParentIdentity;
+};
+export declare function createDirectory(targetPath: string, options?: CreateDirectoryOptions): Promise<void>;
+export declare function createDirectoryWithAdmission(targetPath: string, options?: CreateDirectoryOptions, admission?: CreationAdmission): Promise<void>;
+export declare function createDirectorySync(targetPath: string, options?: CreateDirectoryOptions): void;