@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

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

@@ -1,18 +1,25 @@
 import type { TarMeterLimits } from "./archive-limits.js";
 import { type AdmittedTarMember } from "./archive-tar-wasm.js";
-export declare function inspectTar(params: {
+/** Buffers are private immutable snapshots, just like the staged file route. */
+type TarInput = {
     archivePath: string;
+    archiveBuffer?: never;
+} | {
+    archiveBuffer: Buffer;
+    archivePath?: never;
+};
+export declare function inspectTar(params: TarInput & {
     limits: TarMeterLimits;
     signal?: AbortSignal;
     onMember?: (entry: AdmittedTarMember) => void;
 }): Promise<void>;
 /** Replay in physical order, retaining at most one decoded chunk. Every range
- * comes from complete admission of the immutable staged input. */
-export declare function replayTar<T extends AdmittedTarMember>(params: {
-    archivePath: string;
+ * comes from complete admission of the immutable input. */
+export declare function replayTar<T extends AdmittedTarMember>(params: TarInput & {
     limits: TarMeterLimits;
     signal?: AbortSignal;
     members: readonly T[];
     consume(member: T, payload: AsyncIterable<Buffer>): Promise<void>;
 }): Promise<void>;
+export {};
 //# sourceMappingURL=archive-tar-stream.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"archive-tar-stream.d.ts","sourceRoot":"","sources":["../src/archive-tar-stream.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AA4ChF,wBAAsB,UAAU,CAAC,MAAM,EAAE;IACvC,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAClE,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC/C,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhB;AAED;kEACkE;AAClE,wBAAsB,SAAS,CAAC,CAAC,SAAS,iBAAiB,EAAE,MAAM,EAAE;IACnE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAClE,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;IACtB,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB"}
+{"version":3,"file":"archive-tar-stream.d.ts","sourceRoot":"","sources":["../src/archive-tar-stream.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAAmB,KAAK,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAGhF,gFAAgF;AAChF,KAAK,QAAQ,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,KAAK,CAAA;CAAE,GAAG;IAAE,aAAa,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,KAAK,CAAA;CAAE,CAAC;AAuDhH,wBAAsB,UAAU,CAAC,MAAM,EAAE,QAAQ,GAAG;IAClD,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC7C,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAC/C,GAAG,OAAO,CAAC,IAAI,CAAC,CAIhB;AAED;2DAC2D;AAC3D,wBAAsB,SAAS,CAAC,CAAC,SAAS,iBAAiB,EAAE,MAAM,EAAE,QAAQ,GAAG;IAC9E,MAAM,EAAE,cAAc,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC7C,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;IACtB,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB"}

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

@@ -1,26 +1,35 @@
 import fs from "node:fs";
-import { Writable } from "node:stream";
+import { Readable, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
-import { GzipInput, validateGzipContainerTail } from "./archive-gzip-tail.js";
+import { GzipInput, isGzipBuffer, validateGzipBufferTail, validateGzipContainerTail } from "./archive-gzip-tail.js";
 import { ArchiveFormatError } from "./archive-errors.js";
 import { TarParserStream } from "./archive-tar-wasm.js";
+import { readFileWindowFully } from "./positional-read.js";
+function* bufferChunks(buffer) {
+    for (let offset = 0; offset < buffer.length; offset += 65536)
+        yield buffer.subarray(offset, offset + 65536);
+}
 async function gzipFile(filePath) {
     const handle = await fs.promises.open(filePath, "r");
     try {
         const magic = Buffer.alloc(2);
-        const { bytesRead } = await handle.read(magic, 0, 2, 0);
-        return bytesRead === 2 && magic[0] === 31 && magic[1] === 139;
+        const bytesRead = await readFileWindowFully(handle, magic, 0);
+        return bytesRead === 2 && isGzipBuffer(magic);
     }
     finally {
         await handle.close();
     }
 }
 async function withTarStream(params, consume) {
-    const gzip = await gzipFile(params.archivePath);
+    const buffer = params.archiveBuffer;
+    const gzip = buffer !== undefined ? isGzipBuffer(buffer) : await gzipFile(params.archivePath);
     const parser = new TarParserStream(params.limits, params.onMember);
-    const input = fs.createReadStream(params.archivePath, { highWaterMark: 65536 });
-    const decoder = gzip ? createGunzip() : undefined;
+    const input = buffer !== undefined
+        ? Readable.from(bufferChunks(buffer), { objectMode: false, highWaterMark: 65536 })
+        : fs.createReadStream(params.archivePath, { highWaterMark: 65536 });
+    // Match the WASM input window for both staged files and buffered reads.
+    const decoder = gzip ? createGunzip({ chunkSize: 65536 }) : undefined;
     const gzipInput = decoder ? new GzipInput(decoder) : undefined;
     const destroy = (error) => {
         input.destroy(error);
@@ -42,8 +51,12 @@ async function withTarStream(params, consume) {
         const error = await settled;
         if (error)
             throw error;
-        if (gzipInput)
-            await validateGzipContainerTail(params.archivePath, gzipInput.tailOffset, params.signal);
+        if (gzipInput) {
+            if (buffer !== undefined)
+                await validateGzipBufferTail(buffer, gzipInput.tailOffset, params.signal);
+            else
+                await validateGzipContainerTail(params.archivePath, gzipInput.tailOffset, params.signal);
+        }
         return result;
     }
     finally {
@@ -57,7 +70,7 @@ export async function inspectTar(params) {
     });
 }
 /** Replay in physical order, retaining at most one decoded chunk. Every range
- * comes from complete admission of the immutable staged input. */
+ * comes from complete admission of the immutable input. */
 export async function replayTar(params) {
     await withTarStream(params, async (parser) => {
         const iterator = parser[Symbol.asyncIterator]();

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

@@ -1 +1 @@
-{"version":3,"file":"archive-tar-wasm.d.ts","sourceRoot":"","sources":["../src/archive-tar-wasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAuClE,kFAAkF;AAClF,qBAAa,eAAgB,SAAQ,SAAS;IAER,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAD9D,OAAO,CAAC,GAAG,CAAkB;IAC7B,YAAY,MAAM,EAAE,cAAc,EAAmB,QAAQ,CAAC,GAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,aAAA,EAQjG;IACD,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,IAAI;IAIH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAkB/F;IACQ,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAKjD;IACQ,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAKpF;CACF"}
+{"version":3,"file":"archive-tar-wasm.d.ts","sourceRoot":"","sources":["../src/archive-tar-wasm.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,KAAK,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAyClE,kFAAkF;AAClF,qBAAa,eAAgB,SAAQ,SAAS;IAER,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAD9D,OAAO,CAAC,GAAG,CAAkB;IAC7B,YAAY,MAAM,EAAE,cAAc,EAAmB,QAAQ,CAAC,GAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,aAAA,EAQjG;IACD,OAAO,CAAC,KAAK;IAQb,OAAO,CAAC,IAAI;IAIH,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAqB/F;IACQ,MAAM,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAKjD;IACQ,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAKpF;CACF"}

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

@@ -17,6 +17,7 @@ const types = new Map([
     [51, "CharacterDevice"], [52, "BlockDevice"], [53, "Directory"],
     [54, "FIFO"], [55, "ContiguousFile"], [68, "GNUDumpDir"],
 ]);
+const utf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 function parserError(message) {
     const mapped = classifyArchiveParserError(message);
     if (mapped)
@@ -47,26 +48,29 @@ export class TarParserStream extends Transform {
     }
     text() {
         const abi = this.abi;
-        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(this.bytes(abi.text_ptr(), abi.text_len()));
+        return utf8Decoder.decode(this.bytes(abi.text_ptr(), abi.text_len()));
     }
     _transform(chunk, _encoding, callback) {
         try {
             const abi = this.abi;
-            for (let offset = 0; offset < chunk.length;) {
+            for (let offset = 0; offset < chunk.length; offset += 65536) {
                 const length = Math.min(65536, chunk.length - offset);
                 this.bytes(abi.input_ptr(), length).set(chunk.subarray(offset, offset + length));
-                const used = abi.push(length);
-                if (used < 0)
-                    throw parserError(this.text());
-                if (used === 0 || used > length)
-                    throw new ArchiveFormatError("TAR WASM made no progress");
-                offset += used;
-                const type = abi.member_type();
-                if (type >= 0)
-                    this.onMember?.({
-                        path: this.text(), type: types.get(type) ?? "Unsupported", size: abi.member_size(),
-                        mode: abi.member_mode(), offset: abi.member_offset(),
-                    });
+                // A member event can stop before the end of this already-copied inbox.
+                for (let consumed = 0; consumed < length;) {
+                    const used = abi.push(consumed, length - consumed);
+                    if (used < 0)
+                        throw parserError(this.text());
+                    if (used === 0 || used > length - consumed)
+                        throw new ArchiveFormatError("TAR WASM made no progress");
+                    consumed += used;
+                    const type = abi.member_type();
+                    if (type >= 0)
+                        this.onMember?.({
+                            path: this.text(), type: types.get(type) ?? "Unsupported", size: abi.member_size(),
+                            mode: abi.member_mode(), offset: abi.member_offset(),
+                        });
+                }
             }
             callback(null, chunk);
         }

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

@@ -2,7 +2,7 @@ import type { ExtractionDeadline } from "./archive-deadline.js";
 import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
 import { type ZipDirectoryEntry } from "./archive-zip-directory.js";
 /** Admit physical records before a decoder can normalize or collapse names. */
-export declare function admitZipBuffer(input: Uint8Array, limits: ResolvedArchiveExtractLimits): number;
-/** The extraction input is already private and staged; read only bounded metadata. */
+export declare function admitZipBuffer(input: Uint8Array, limits: ResolvedArchiveExtractLimits, onEntry?: (entry: ZipDirectoryEntry) => void): number;
+/** The extraction input is private and immutable; read bounded metadata windows. */
 export declare function admitZipFile(archivePath: string, limits: ResolvedArchiveExtractLimits, deadline: ExtractionDeadline, onEntry?: (entry: ZipDirectoryEntry) => void): Promise<number>;
 //# sourceMappingURL=archive-zip-admission.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-admission.d.ts","sourceRoot":"","sources":["../src/archive-zip-admission.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAA+C,KAAK,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAErH,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAUtF,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,4BAA4B,GAAG,MAAM,CAU9F;AAED,sFAAsF;AACtF,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,QAAQ,EAAE,kBAAkB,EACvF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,OAAO,CAAC,MAAM,CAAC,CA+BjB"}
+{"version":3,"file":"archive-zip-admission.d.ts","sourceRoot":"","sources":["../src/archive-zip-admission.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,EAA+C,KAAK,4BAA4B,EAAE,MAAM,qBAAqB,CAAC;AAErH,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAUtF,+EAA+E;AAC/E,wBAAgB,cAAc,CAC5B,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GACpG,MAAM,CAUR;AAMD,oFAAoF;AACpF,wBAAsB,YAAY,CAChC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,QAAQ,EAAE,kBAAkB,EACvF,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,OAAO,CAAC,MAAM,CAAC,CA8DjB"}

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

@@ -12,10 +12,10 @@ function checkSize(size, limits) {
         zipFormat("invalid archive size");
 }
 /** Admit physical records before a decoder can normalize or collapse names. */
-export function admitZipBuffer(input, limits) {
+export function admitZipBuffer(input, limits, onEntry) {
     checkSize(input.byteLength, limits);
     const buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
-    const scan = scanZipDirectory(buffer.length, limits);
+    const scan = scanZipDirectory(buffer.length, limits, onEntry);
     let step = scan.next();
     while (!step.done) {
         const { offset, length } = step.value;
@@ -23,7 +23,9 @@ export function admitZipBuffer(input, limits) {
     }
     return step.value;
 }
-/** The extraction input is already private and staged; read only bounded metadata. */
+const METADATA_WINDOW_BYTES = 4096;
+const CACHED_READS_PER_YIELD = 32;
+/** The extraction input is private and immutable; read bounded metadata windows. */
 export async function admitZipFile(archivePath, limits, deadline, onEntry) {
     deadline.check();
     const opened = await openRootFile({
@@ -35,20 +37,54 @@ export async function admitZipFile(archivePath, limits, deadline, onEntry) {
     try {
         checkSize(opened.stat.size, limits);
         const scan = scanZipDirectory(opened.stat.size, limits, onEntry);
+        // Separate windows keep alternating central and local records hot. Never
+        // refill a buffer: the scanner can retain its views after cache eviction.
+        const windows = [];
+        let cachedReads = 0;
         let step = scan.next();
         while (!step.done) {
+            deadline.check();
             const { offset, length } = step.value;
-            const bytes = Buffer.alloc(length);
-            let received = 0;
-            while (received < length) {
-                deadline.check();
-                const count = await new Promise((resolve, reject) => {
-                    fs.read(opened.fd, bytes, received, length - received, offset + received, (error, count) => error ? reject(error) : resolve(count));
-                });
-                deadline.check();
-                if (!count)
-                    zipFormat("truncated staged record");
-                received += count;
+            const cached = windows.findIndex(window => offset >= window.offset &&
+                length <= window.bytes.length - (offset - window.offset));
+            let bytes;
+            if (cached !== -1) {
+                if (++cachedReads >= CACHED_READS_PER_YIELD) {
+                    cachedReads = 0;
+                    await new Promise(resolve => setImmediate(resolve));
+                    deadline.check();
+                }
+                const window = windows[cached];
+                if (cached === 1)
+                    windows.reverse();
+                bytes = window.bytes.subarray(offset - window.offset, offset - window.offset + length);
+            }
+            else {
+                const cacheable = length > 0 && length <= METADATA_WINDOW_BYTES;
+                const capacity = cacheable ? Math.min(METADATA_WINDOW_BYTES, opened.stat.size - offset) : length;
+                const buffer = Buffer.alloc(capacity);
+                let received = 0;
+                while (received < capacity) {
+                    deadline.check();
+                    const count = await new Promise((resolve, reject) => {
+                        fs.read(opened.fd, buffer, received, capacity - received, offset + received, (error, count) => error ? reject(error) : resolve(count));
+                    });
+                    cachedReads = 0;
+                    deadline.check();
+                    if (!count) {
+                        if (received < length)
+                            zipFormat("truncated staged record");
+                        break;
+                    }
+                    received += count;
+                }
+                const filled = buffer.subarray(0, received);
+                bytes = filled.subarray(0, length);
+                if (cacheable) {
+                    windows.unshift({ offset, bytes: filled });
+                    if (windows.length > 2)
+                        windows.pop();
+                }
             }
             step = scan.next(bytes);
         }

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

@@ -1,4 +1,5 @@
 import { type ResolvedArchiveExtractLimits } from "./archive-limits.js";
+import type { ArchiveEntryKind } from "./archive-policy.js";
 export type ZipRead = {
     offset: number;
     length: number;
@@ -10,6 +11,8 @@ export type ZipDirectoryEntry = {
     externalAttributes: number;
     size: number;
     path?: string;
+    portableKey: string;
+    kind: ArchiveEntryKind;
 };
 export declare function scanZipDirectory(size: number, limits: ResolvedArchiveExtractLimits, onEntry?: (entry: ZipDirectoryEntry) => void): ZipScan;
 //# sourceMappingURL=archive-zip-directory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-directory.d.ts","sourceRoot":"","sources":["../src/archive-zip-directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,qBAAqB,CAAC;AAG7B,MAAM,MAAM,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACzD,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAmIF,wBAAiB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC/F,OAAO,CAkET"}
+{"version":3,"file":"archive-zip-directory.d.ts","sourceRoot":"","sources":["../src/archive-zip-directory.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,4BAA4B,EAClC,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAE5D,MAAM,MAAM,OAAO,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AACzD,MAAM,MAAM,OAAO,GAAG,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AACzD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,gBAAgB,CAAC;CACxB,CAAC;AA4IF,wBAAiB,gBAAgB,CAC/B,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC/F,OAAO,CAmET"}

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

@@ -1,5 +1,15 @@
 import { assertArchiveEntryCountWithinLimit, } from "./archive-limits.js";
 import { admitZipNames, zipExtraFields, zipFormat, zipUInt64 } from "./archive-zip-names.js";
+function entryKind(attributes, directory) {
+    const type = (attributes >>> 16) & 0o170000;
+    // High-word symlinks remain links regardless of the creator or directory bits.
+    if (type === 0o120000)
+        return "symlink";
+    if ((attributes & 0x10) || type === 0o040000 || directory)
+        return "directory";
+    // Preserve the native decoder's rejection of unrecognized link-like types.
+    return (type & 0o120000) === 0o120000 ? "other" : "file";
+}
 function* read(offset, length, bound) {
     if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || length > bound - offset) {
         zipFormat("record outside archive bounds");
@@ -193,7 +203,7 @@ export function* scanZipDirectory(size, limits, onEntry) {
         const localExtraLength = local.readUInt16LE(28);
         const localNames = yield* read(localAt + 30, localNameLength + localExtraLength, directory.start);
         const localExtra = zipExtraFields(localNames.subarray(localNameLength));
-        const entryPath = admitZipNames({ central: centralName, local: localNames.subarray(0, localNameLength), flags, centralExtra, localExtra, seen });
+        const admittedName = admitZipNames({ central: centralName, local: localNames.subarray(0, localNameLength), flags, centralExtra, localExtra, seen });
         const localValues = wideValues(local, localExtra, false);
         const crc = central.readUInt32LE(16);
         if (!(flags & 8) && (local.readUInt32LE(14) !== crc || localValues.compressed !== values.compressed || localValues.uncompressed !== values.uncompressed)) {
@@ -213,7 +223,8 @@ export function* scanZipDirectory(size, limits, onEntry) {
         spans.push({ start: localAt, end: dataEnd });
         onEntry?.({
             index: count - 1, creatorSystem: central[5], externalAttributes: central.readUInt32LE(38),
-            size: values.uncompressed, path: entryPath,
+            size: values.uncompressed, path: admittedName.path, portableKey: admittedName.portableKey,
+            kind: entryKind(central.readUInt32LE(38), admittedName.directory),
         });
         at = next;
     }

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

@@ -0,0 +1,7 @@
+import type { ZipDirectoryEntry } from "./archive-zip-directory.js";
+export type ZipArchiveWithFiles = {
+    files: Record<string, unknown>;
+};
+/** Internal: the caller has admitted these unchanged bytes and their metadata. */
+export declare function loadAdmittedZipArchive(buffer: Buffer | Uint8Array, admitted: ZipDirectoryEntry[]): Promise<ZipArchiveWithFiles>;
+//# sourceMappingURL=archive-zip-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-loader.d.ts","sourceRoot":"","sources":["../src/archive-zip-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAIpE,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAMF,kFAAkF;AAClF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,QAAQ,EAAE,iBAAiB,EAAE,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CA6C9B"}

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

@@ -0,0 +1,64 @@
+import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
+import { validateArchiveEntryPath } from "./archive-entry.js";
+import { isZipSymlinkEntry } from "./archive-zip-entry.js";
+import { zipPathKey } from "./archive-zip-names.js";
+/** Internal: the caller has admitted these unchanged bytes and their metadata. */
+export async function loadAdmittedZipArchive(buffer, admitted) {
+    const JSZip = await importOptionalJsZip();
+    let archive;
+    try {
+        archive = await JSZip.loadAsync(buffer);
+    }
+    catch (error) {
+        throw new ArchiveFormatError(`invalid ZIP archive: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : undefined });
+    }
+    const names = Object.keys(archive.files);
+    if (names.length !== admitted.length) {
+        throw new ArchiveSecurityError("entry-path", "zip archive contains duplicate or colliding entry names");
+    }
+    // Object key order is not central-directory order (numeric names reorder).
+    // Use the admitted portable interpretation, including legacy UTF-8 decoding.
+    const physicalByPath = new Map();
+    for (const entry of admitted) {
+        physicalByPath.set(entry.portableKey, entry);
+    }
+    for (const name of names) {
+        validateArchiveEntryPath(name);
+        const key = zipPathKey(name);
+        const physical = physicalByPath.get(key);
+        const entry = archive.files[name];
+        const entryName = entry.name;
+        let entryKey = key;
+        if (entryName !== name) {
+            validateArchiveEntryPath(entryName);
+            entryKey = zipPathKey(entryName);
+        }
+        const kind = isZipSymlinkEntry(entry) ? "symlink" : entry.dir ? "directory" : "file";
+        if (!physical || entryKey !== key || kind !== physical.kind) {
+            throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
+        }
+        physicalByPath.delete(key);
+    }
+    if (physicalByPath.size) {
+        throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
+    }
+    return archive;
+}
+async function importOptionalJsZip() {
+    try {
+        const module = await import("jszip");
+        const candidate = typeof module === "function" ? module : module.default;
+        if ((typeof candidate !== "object" && typeof candidate !== "function") ||
+            candidate === null ||
+            typeof candidate.loadAsync !== "function") {
+            throw new Error('Optional archive dependency "jszip" does not expose loadAsync().');
+        }
+        return candidate;
+    }
+    catch (err) {
+        throw missingOptionalArchiveDependencyError("jszip", err);
+    }
+}
+function missingOptionalArchiveDependencyError(packageName, cause) {
+    return new Error(`Optional archive dependency "${packageName}" is not installed. Install it to use ZIP archive helpers from @openclaw/fs-safe/archive.`, { cause });
+}

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

@@ -0,0 +1,5 @@
+import type { NativeArchiveEntry } from "./native-binding.js";
+import type { ZipDirectoryEntry } from "./archive-zip-directory.js";
+/** Associate all native entries with physical admission before exposing any. */
+export declare function validateNativeZipManifest(manifest: NativeArchiveEntry[], admitted: ZipDirectoryEntry[]): void;
+//# sourceMappingURL=archive-zip-manifest.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-manifest.d.ts","sourceRoot":"","sources":["../src/archive-zip-manifest.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAEpE,gFAAgF;AAChF,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,kBAAkB,EAAE,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAC5D,IAAI,CAkBN"}

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

@@ -0,0 +1,22 @@
+import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
+import { stripArchivePath } from "./archive-entry.js";
+/** Associate all native entries with physical admission before exposing any. */
+export function validateNativeZipManifest(manifest, admitted) {
+    if (manifest.length !== admitted.length) {
+        throw new ArchiveSecurityError("entry-path", "zip decoder collapsed entry names");
+    }
+    for (const [ordinal, entry] of manifest.entries()) {
+        const physical = admitted[ordinal];
+        const physicalPath = physical?.path;
+        const pathMatches = physicalPath === undefined || entry.path === physicalPath ||
+            stripArchivePath(entry.path, 0) === stripArchivePath(physicalPath, 0);
+        // Native indices are physical central-directory ordinals. Legacy name
+        // decoding remains native-selected; compare names when admission knows them.
+        if (!physical || physical.index !== ordinal || entry.index !== ordinal ||
+            entry.size !== physical.size || entry.kind !== physical.kind ||
+            !pathMatches ||
+            (physical.creatorSystem === 3 && entry.mode !== physical.externalAttributes >>> 16)) {
+            throw new ArchiveFormatError("ZIP decoder disagrees with admitted directory metadata");
+        }
+    }
+}

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

@@ -1,6 +1,7 @@
 export declare function zipFormat(message: string): never;
 export declare function zipUInt64(bytes: Buffer, offset: number): number;
 export declare function zipExtraFields(bytes: Buffer): Map<number, Buffer>;
+export declare function zipPathKey(name: string): string;
 export declare function admitZipNames(params: {
     central: Buffer;
     local: Buffer;
@@ -8,5 +9,9 @@ export declare function admitZipNames(params: {
     centralExtra: Map<number, Buffer>;
     localExtra: Map<number, Buffer>;
     seen: Set<string>;
-}): string | undefined;
+}): {
+    path?: string;
+    portableKey: string;
+    directory: boolean;
+};
 //# sourceMappingURL=archive-zip-names.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-names.d.ts","sourceRoot":"","sources":["../src/archive-zip-names.ts"],"names":[],"mappings":"AAIA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEhD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcjE;AA6BD,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAC9C,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnB,GAAG,MAAM,GAAG,SAAS,CA8BrB"}
+{"version":3,"file":"archive-zip-names.d.ts","sourceRoot":"","sources":["../src/archive-zip-names.ts"],"names":[],"mappings":"AAKA,wBAAgB,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAEhD;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAK/D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAcjE;AAUD,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG/C;AAoBD,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACpC,OAAO,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAC9C,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACnB,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAE,CAiE7D"}

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

@@ -1,3 +1,4 @@
+import { types } from "node:util";
 import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
 import { stripArchivePath, validateArchiveEntryPath } from "./archive-entry.js";
 import { updateCrc32 } from "./archive-crc32.js";
@@ -31,21 +32,25 @@ export function zipExtraFields(bytes) {
     }
     return critical;
 }
+const utf8Decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
 function utf8(bytes) {
     try {
-        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+        return utf8Decoder.decode(bytes);
     }
     catch {
         return zipFormat("invalid UTF-8 name");
     }
 }
-function key(name) {
+// Canonical identity only; this does not replace raw path validation.
+export function zipPathKey(name) {
+    if (name && name !== "." && !name.includes("/") && !name.includes("\\"))
+        return name;
     return stripArchivePath(name, 0) ?? "";
 }
-function originalName(name, flags) {
+function originalName(name, rawName, flags) {
     // ASCII path syntax is encoding-independent. Do not reinterpret legacy bytes
     // as UTF-8 (native ZIP uses CP437); the selected decoder still validates its name.
-    validateArchiveEntryPath(Array.from(name, (byte) => byte < 128 ? String.fromCharCode(byte) : "_").join(""));
+    validateArchiveEntryPath(rawName.replace(/[\x80-\xff]/g, "_"));
     if (!(flags & 0x800))
         return undefined;
     const decoded = utf8(name);
@@ -68,33 +73,66 @@ export function admitZipNames(params) {
     const { central, local, flags, centralExtra, localExtra, seen } = params;
     if (!central.length || !local.length)
         zipFormat("empty entry name");
-    const centralUtf8 = originalName(central, flags);
-    const localUtf8 = originalName(local, flags);
+    // Reuse only within this synchronous call; shared backing bytes can change
+    // concurrently even though admission does not yield while checking names.
+    const sameName = !types.isSharedArrayBuffer(central.buffer) &&
+        !types.isSharedArrayBuffer(local.buffer) && central.equals(local);
+    const centralRaw = central.toString("latin1");
+    const localRaw = sameName ? centralRaw : local.toString("latin1");
+    const centralUtf8 = originalName(central, centralRaw, flags);
+    const localUtf8 = sameName ? centralUtf8 : originalName(local, localRaw, flags);
     const centralUnicode = unicodeName(central, centralExtra);
-    const localUnicode = unicodeName(local, localExtra);
-    if (key(central.toString("latin1")) !== key(local.toString("latin1"))) {
+    const centralField = centralExtra.get(0x7075);
+    const localField = localExtra.get(0x7075);
+    // Only immutable identical fields share their CRC-bound name admission.
+    const sameUnicode = (!centralField || !types.isSharedArrayBuffer(centralField.buffer)) &&
+        (!localField || !types.isSharedArrayBuffer(localField.buffer)) &&
+        (centralField === localField ||
+            (centralField !== undefined && localField !== undefined && centralField.equals(localField)));
+    const localUnicode = sameName && sameUnicode ? centralUnicode : unicodeName(local, localExtra);
+    const centralKey = zipPathKey(centralRaw);
+    if (!sameName && centralKey !== zipPathKey(localRaw)) {
         zipFormat("central and local names disagree");
     }
     const interpretations = [centralUtf8, localUtf8, centralUnicode, localUnicode].filter((value) => value !== undefined);
-    if (interpretations.some((value) => key(value) !== key(interpretations[0]))) {
+    // Canonical paths erase terminal separators. Preserve their kind meaning in
+    // every interpretation, including Unicode overrides of legacy-encoded names.
+    const directory = /[/\\]$/.test(centralRaw);
+    if (/[/\\]$/.test(localRaw) !== directory ||
+        interpretations.some((value) => /[/\\]$/.test(value) !== directory)) {
+        zipFormat("conflicting terminal directory markers");
+    }
+    const interpretationKey = interpretations.length ? zipPathKey(interpretations[0]) : undefined;
+    if (interpretations.some((value) => value !== interpretations[0] && zipPathKey(value) !== interpretationKey)) {
         zipFormat("conflicting Unicode name interpretations");
     }
     // JSZip checks the central Unicode field against the local name. A slash-only
     // spelling difference must not make one decoder ignore a meaningful override.
     if (centralUnicode && !central.equals(local) &&
-        key(centralUnicode) !== key(local.toString("utf8"))) {
+        zipPathKey(centralUnicode) !== zipPathKey(local.toString("utf8"))) {
         zipFormat("Unicode override disagrees with local decoder name");
     }
-    if (!centralUnicode && localUnicode && key(localUnicode) !== key(local.toString("utf8"))) {
+    if (!centralUnicode && localUnicode && zipPathKey(localUnicode) !== zipPathKey(local.toString("utf8"))) {
         zipFormat("local-only Unicode override changes the name");
     }
-    const identities = new Set([key(central.toString("latin1"))]);
-    if (centralUnicode !== undefined)
-        identities.add(key(Buffer.from(centralUnicode).toString("latin1")));
-    if ([...identities].some((identity) => seen.has(identity))) {
+    const unicodeKey = centralUnicode === undefined
+        ? undefined : zipPathKey(Buffer.from(centralUnicode).toString("latin1"));
+    if (seen.has(centralKey) ||
+        (unicodeKey !== undefined && unicodeKey !== centralKey && seen.has(unicodeKey))) {
         throw new ArchiveSecurityError("entry-path", "zip archive contains duplicate or colliding entry names");
     }
-    for (const identity of identities)
-        seen.add(identity);
-    return centralUnicode ?? centralUtf8 ?? (central.every((byte) => byte < 128) ? central.toString("ascii") : undefined);
+    seen.add(centralKey);
+    if (unicodeKey !== undefined && unicodeKey !== centralKey)
+        seen.add(unicodeKey);
+    const path = centralUnicode ?? centralUtf8 ?? (central.every((byte) => byte < 128) ? central.toString("ascii") : undefined);
+    const portablePath = centralUnicode ?? localUtf8 ?? (sameName && path !== undefined ? path : local.toString("utf8"));
+    // Reuse the admitted interpretation, never the Latin-1 Unicode collision key.
+    // Unflagged legacy names can decode differently and need their own key.
+    const portableKey = portablePath === centralRaw ? centralKey
+        : interpretations.includes(portablePath) ? interpretationKey : zipPathKey(portablePath);
+    return {
+        path,
+        portableKey,
+        directory,
+    };
 }

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

@@ -1,7 +1,6 @@
 import { type ArchiveExtractLimits } from "./archive-limits.js";
+import { type ZipArchiveWithFiles } from "./archive-zip-loader.js";
 export { readZipCentralDirectoryEntryCount } from "./archive-zip-count.js";
-export type ZipArchiveWithFiles = {
-    files: Record<string, unknown>;
-};
+export type { ZipArchiveWithFiles } from "./archive-zip-loader.js";
 export declare function loadZipArchiveWithPreflight(buffer: Buffer | Uint8Array, limits?: ArchiveExtractLimits): Promise<ZipArchiveWithFiles>;
 //# sourceMappingURL=archive-zip-preflight.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"archive-zip-preflight.d.ts","sourceRoot":"","sources":["../src/archive-zip-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAE3E,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC,CAAC;AAMF,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAwB9B"}
+{"version":3,"file":"archive-zip-preflight.d.ts","sourceRoot":"","sources":["../src/archive-zip-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE3F,OAAO,EAAE,iCAAiC,EAAE,MAAM,wBAAwB,CAAC;AAC3E,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,wBAAsB,2BAA2B,CAC/C,MAAM,EAAE,MAAM,GAAG,UAAU,EAC3B,MAAM,CAAC,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAQ9B"}