@openclaw/openshell-sandbox 2026.9.1 → 2026.9.3

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

@@ -0,0 +1,228 @@
+import { assertArchiveEntryCountWithinLimit, } from "./archive-limits.js";
+import { admitZipNames, zipExtraFields, zipFormat, zipUInt64 } from "./archive-zip-names.js";
+function* read(offset, length, bound) {
+    if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || length > bound - offset) {
+        zipFormat("record outside archive bounds");
+    }
+    const bytes = yield { offset, length };
+    if (bytes.length !== length)
+        zipFormat("truncated record");
+    return bytes;
+}
+function endOffset(tail) {
+    let found = -1;
+    for (let offset = tail.length - 22; offset >= 0; offset--) {
+        if (tail.readUInt32LE(offset) === 0x06054b50 && offset + 22 + tail.readUInt16LE(offset + 20) === tail.length) {
+            if (found !== -1)
+                zipFormat("ambiguous end records");
+            found = offset;
+        }
+    }
+    if (found < 0)
+        zipFormat("end record missing");
+    return found;
+}
+function* zip64End(locator, locatorAt, size) {
+    const advertised = zipUInt64(locator, 8);
+    // Seek the advertised record, or the fixed ordinary record for a prefixed
+    // archive. Never hunt through payload bytes for a ZIP64 signature.
+    const candidates = new Set([advertised, locatorAt - 56]);
+    let found;
+    for (const at of candidates) {
+        if (at < 0 || at > locatorAt - 56)
+            continue;
+        const record = yield* read(at, 56, size);
+        if (record.readUInt32LE(0) !== 0x06064b50)
+            continue;
+        const bodySize = zipUInt64(record, 4);
+        if (bodySize < 44 || bodySize !== locatorAt - at - 12)
+            continue;
+        if (found)
+            zipFormat("ambiguous ZIP64 end records");
+        found = { at, record };
+    }
+    if (!found)
+        zipFormat("unsupported ZIP64 end record");
+    return found;
+}
+function* layout(size) {
+    const tailStart = Math.max(0, size - 65_557);
+    const tail = yield* read(tailStart, size - tailStart, size);
+    const at = endOffset(tail);
+    const end = tail.subarray(at, at + 22);
+    const physicalEnd = tailStart + at;
+    if (end.readUInt16LE(4) || end.readUInt16LE(6))
+        zipFormat("multi-disk archive");
+    let count = end.readUInt16LE(10);
+    let directorySize = end.readUInt32LE(12);
+    let offset = end.readUInt32LE(16);
+    let directoryEnd = physicalEnd;
+    const wide = count === 0xffff || end.readUInt16LE(8) === 0xffff || directorySize === 0xffffffff || offset === 0xffffffff;
+    if (wide) {
+        const locator = yield* read(physicalEnd - 20, 20, size);
+        if (locator.readUInt32LE(0) !== 0x07064b50 || locator.readUInt32LE(4) || locator.readUInt32LE(16) !== 1) {
+            zipFormat("invalid ZIP64 locator");
+        }
+        const wideEnd = yield* zip64End(locator, physicalEnd - 20, size);
+        directoryEnd = wideEnd.at;
+        const record = wideEnd.record;
+        if (record.readUInt32LE(16) || record.readUInt32LE(20))
+            zipFormat("multi-disk ZIP64 archive");
+        count = zipUInt64(record, 32);
+        directorySize = zipUInt64(record, 40);
+        offset = zipUInt64(record, 48);
+        if (zipUInt64(record, 24) !== count)
+            zipFormat("ZIP64 disk count mismatch");
+        for (const [ordinary, sentinel, value] of [
+            [end.readUInt16LE(8), 0xffff, count], [end.readUInt16LE(10), 0xffff, count],
+            [end.readUInt32LE(12), 0xffffffff, directorySize], [end.readUInt32LE(16), 0xffffffff, offset],
+        ]) {
+            if (ordinary !== sentinel && ordinary !== value)
+                zipFormat("conflicting ZIP64 end values");
+        }
+        const base = directoryEnd - directorySize - offset;
+        if (zipUInt64(locator, 8) !== directoryEnd - base)
+            zipFormat("ZIP64 locator offset mismatch");
+    }
+    else if (end.readUInt16LE(8) !== count)
+        zipFormat("disk count mismatch");
+    const start = directoryEnd - directorySize;
+    const base = start - offset;
+    if (base < 0 || start < 0 || !Number.isSafeInteger(base))
+        zipFormat("invalid central directory offset");
+    return { count, start, end: directoryEnd, base };
+}
+function wideValues(header, extra, central) {
+    let compressed = header.readUInt32LE(central ? 20 : 18);
+    let uncompressed = header.readUInt32LE(central ? 24 : 22);
+    let offset = central ? header.readUInt32LE(42) : 0;
+    let disk = central ? header.readUInt16LE(34) : 0;
+    const field = extra.get(1);
+    if (field?.length === 0)
+        zipFormat("empty ZIP64 extra field");
+    let cursor = 0;
+    const value = () => {
+        if (!field)
+            return zipFormat("ZIP64 extra field missing");
+        const result = zipUInt64(field, cursor);
+        cursor += 8;
+        return result;
+    };
+    const wide = compressed === 0xffffffff || uncompressed === 0xffffffff;
+    if (uncompressed === 0xffffffff)
+        uncompressed = value();
+    if (compressed === 0xffffffff)
+        compressed = value();
+    if (offset === 0xffffffff)
+        offset = value();
+    if (disk === 0xffff) {
+        if (!field || cursor + 4 > field.length)
+            zipFormat("ZIP64 disk field missing");
+        disk = field.readUInt32LE(cursor);
+        cursor += 4;
+    }
+    if (field && cursor !== field.length) {
+        // Some writers repeat both local sizes even when the 32-bit fields fit.
+        if (central || cursor !== 0 || field.length !== 16 ||
+            zipUInt64(field, 0) !== uncompressed || zipUInt64(field, 8) !== compressed) {
+            zipFormat("inconsistent ZIP64 extra field");
+        }
+    }
+    if (disk)
+        zipFormat("multi-disk entry");
+    return { compressed, uncompressed, offset, wide };
+}
+function* descriptorEnd(at, bound, crc, compressed, uncompressed, wide) {
+    const length = wide ? 20 : 12;
+    const bytes = yield* read(at, Math.min(length + 4, bound - at), bound);
+    const matches = [];
+    for (const skip of [0, 4]) {
+        if (skip && (bytes.length < 4 || bytes.readUInt32LE(0) !== 0x08074b50))
+            continue;
+        if (bytes.length < length + skip || bytes.readUInt32LE(skip) !== crc)
+            continue;
+        const c = wide ? zipUInt64(bytes, skip + 4) : bytes.readUInt32LE(skip + 4);
+        const u = wide ? zipUInt64(bytes, skip + 12) : bytes.readUInt32LE(skip + 8);
+        if (c === compressed && u === uncompressed)
+            matches.push(at + length + skip);
+    }
+    if (matches.length !== 1)
+        zipFormat("invalid or ambiguous data descriptor");
+    return matches[0];
+}
+export function* scanZipDirectory(size, limits, onEntry) {
+    const directory = yield* layout(size);
+    assertArchiveEntryCountWithinLimit(directory.count, limits);
+    const seen = new Set();
+    const spans = [];
+    let at = directory.start;
+    let count = 0;
+    while (at < directory.end) {
+        const central = yield* read(at, Math.min(46, directory.end - at), directory.end);
+        if (central.length >= 6 && central.readUInt32LE(0) === 0x05054b50) {
+            // The optional digital signature belongs to the directory size, not its
+            // entry count. It is opaque metadata, not an authenticity guarantee.
+            if (central.readUInt16LE(4) !== directory.end - at - 6)
+                zipFormat("invalid directory signature length");
+            at = directory.end;
+            break;
+        }
+        assertArchiveEntryCountWithinLimit(++count, limits);
+        if (central.length < 46 || central.readUInt32LE(0) !== 0x02014b50)
+            zipFormat("invalid central header");
+        const nameLength = central.readUInt16LE(28);
+        const extraLength = central.readUInt16LE(30);
+        const next = at + 46 + nameLength + extraLength + central.readUInt16LE(32);
+        if (next > directory.end)
+            zipFormat("central record exceeds directory");
+        const names = yield* read(at + 46, nameLength + extraLength, directory.end);
+        const centralName = names.subarray(0, nameLength);
+        const centralExtra = zipExtraFields(names.subarray(nameLength));
+        const values = wideValues(central, centralExtra, true);
+        const flags = central.readUInt16LE(8);
+        if (flags & ~0x080e)
+            zipFormat("unsupported entry flags");
+        const localAt = directory.base + values.offset;
+        if (localAt < directory.base)
+            zipFormat("local offset precedes archive base");
+        const local = yield* read(localAt, 30, directory.start);
+        if (local.readUInt32LE(0) !== 0x04034b50 || local.readUInt16LE(6) !== flags || local.readUInt16LE(8) !== central.readUInt16LE(10)) {
+            zipFormat("local and central framing disagree");
+        }
+        const localNameLength = local.readUInt16LE(26);
+        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 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)) {
+            zipFormat("local and central sizes or CRC disagree");
+        }
+        if ((flags & 8) && ((local.readUInt32LE(14) !== 0 && local.readUInt32LE(14) !== crc) ||
+            (localValues.compressed !== 0 && localValues.compressed !== values.compressed) ||
+            (localValues.uncompressed !== 0 && localValues.uncompressed !== values.uncompressed))) {
+            zipFormat("data descriptor placeholders disagree");
+        }
+        const dataStart = localAt + 30 + localNameLength + localExtraLength;
+        if (values.compressed > directory.start - dataStart)
+            zipFormat("entry data exceeds local area");
+        let dataEnd = dataStart + values.compressed;
+        if (flags & 8)
+            dataEnd = yield* descriptorEnd(dataEnd, directory.start, crc, values.compressed, values.uncompressed, values.wide || localValues.wide);
+        spans.push({ start: localAt, end: dataEnd });
+        onEntry?.({
+            index: count - 1, creatorSystem: central[5], externalAttributes: central.readUInt32LE(38),
+            size: values.uncompressed, path: entryPath,
+        });
+        at = next;
+    }
+    if (count !== directory.count)
+        zipFormat("physical and declared entry counts disagree");
+    spans.sort((a, b) => a.start - b.start);
+    for (let i = 1; i < spans.length; i++) {
+        if (spans[i].start < spans[i - 1].end)
+            zipFormat("overlapping local entries");
+    }
+    return count;
+}

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

@@ -0,0 +1,21 @@
+import { type ArchiveEntryModePolicy } from "./archive-policy.js";
+export type ZipEntry = {
+    name: string;
+    dir: boolean;
+    unixPermissions?: number | null;
+    _data?: {
+        crc32?: number;
+        uncompressedSize?: number;
+    } | PromiseLike<unknown>;
+    nodeStream?: () => NodeJS.ReadableStream;
+    async: (type: "nodebuffer") => Promise<Buffer>;
+};
+export declare function zipEntryIntegrityMetadata(entry: ZipEntry): {
+    crc32?: number;
+    uncompressedSize?: number;
+} | undefined;
+export declare function hasDeferredEmptyZipData(entry: ZipEntry): boolean;
+export declare function isZipSymlinkEntry(entry: ZipEntry): boolean;
+export declare function zipEntryMode(entry: ZipEntry, policy: ArchiveEntryModePolicy | undefined): number;
+export declare function zipEntryDeclaredSize(entry: ZipEntry): number;
+//# sourceMappingURL=archive-zip-entry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-entry.d.ts","sourceRoot":"","sources":["../src/archive-zip-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,sBAAsB,EAC5B,MAAM,qBAAqB,CAAC;AAE7B,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,OAAO,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,KAAK,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;IAC7E,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC,cAAc,CAAC;IACzC,KAAK,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CAChD,CAAC;AAEF,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,QAAQ,GACd;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAI3D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAGhE;AAKD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAK1D;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,sBAAsB,GAAG,SAAS,GACzC,MAAM,CAMR;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,GAAG,MAAM,CAE5D"}

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

@@ -0,0 +1,27 @@
+import { resolveArchiveEntryMode, } from "./archive-policy.js";
+export function zipEntryIntegrityMetadata(entry) {
+    const data = entry._data;
+    if (!data || "then" in data)
+        return undefined;
+    return data;
+}
+export function hasDeferredEmptyZipData(entry) {
+    const data = entry._data;
+    return Boolean(data && "then" in data);
+}
+const ZIP_UNIX_FILE_TYPE_MASK = 0o170000;
+const ZIP_UNIX_SYMLINK_TYPE = 0o120000;
+export function isZipSymlinkEntry(entry) {
+    return (typeof entry.unixPermissions === "number" &&
+        (entry.unixPermissions & ZIP_UNIX_FILE_TYPE_MASK) === ZIP_UNIX_SYMLINK_TYPE);
+}
+export function zipEntryMode(entry, policy) {
+    return resolveArchiveEntryMode({
+        kind: entry.dir ? "directory" : "file",
+        archivedMode: entry.unixPermissions,
+        policy,
+    });
+}
+export function zipEntryDeclaredSize(entry) {
+    return Math.max(0, Math.floor(zipEntryIntegrityMetadata(entry)?.uncompressedSize ?? 0));
+}

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

@@ -0,0 +1,5 @@
+import { Transform } from "node:stream";
+import { type ZipEntry } from "./archive-zip-entry.js";
+export declare function normalizeZipIntegrityError(error: unknown): Error;
+export declare function createZipIntegrityTransform(entry: ZipEntry): Transform;
+//# sourceMappingURL=archive-zip-integrity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-integrity.d.ts","sourceRoot":"","sources":["../src/archive-zip-integrity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAGL,KAAK,QAAQ,EACd,MAAM,wBAAwB,CAAC;AAIhC,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,CAQhE;AAED,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,QAAQ,GAAG,SAAS,CAgCtE"}

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

@@ -0,0 +1,41 @@
+import { Transform } from "node:stream";
+import { ArchiveFormatError } from "./archive-errors.js";
+import { hasDeferredEmptyZipData, zipEntryIntegrityMetadata, } from "./archive-zip-entry.js";
+import { updateCrc32 } from "./archive-crc32.js";
+export function normalizeZipIntegrityError(error) {
+    if (error instanceof Error &&
+        error.message.includes("uncompressed data size mismatch")) {
+        return new ArchiveFormatError(`invalid ZIP entry data: ${error.message}`, { cause: error });
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+export function createZipIntegrityTransform(entry) {
+    const metadata = zipEntryIntegrityMetadata(entry);
+    const deferredEmpty = hasDeferredEmptyZipData(entry);
+    const expectedCrc32 = deferredEmpty ? 0 : metadata?.crc32;
+    const expectedSize = deferredEmpty ? 0 : metadata?.uncompressedSize;
+    if (typeof expectedCrc32 !== "number" ||
+        !Number.isInteger(expectedCrc32) ||
+        typeof expectedSize !== "number" ||
+        !Number.isSafeInteger(expectedSize) ||
+        expectedSize < 0) {
+        throw new ArchiveFormatError(`zip entry has invalid integrity metadata: ${entry.name}`);
+    }
+    let actualCrc32 = 0;
+    let actualSize = 0;
+    return new Transform({
+        transform(chunk, _encoding, callback) {
+            const buffer = chunk instanceof Buffer ? chunk : Buffer.from(chunk);
+            actualCrc32 = updateCrc32(actualCrc32, buffer);
+            actualSize += buffer.byteLength;
+            callback(null, buffer);
+        },
+        flush(callback) {
+            if (actualSize !== expectedSize || actualCrc32 !== (expectedCrc32 >>> 0)) {
+                callback(new ArchiveFormatError(`zip entry integrity check failed: ${entry.name}`));
+                return;
+            }
+            callback();
+        },
+    });
+}

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

@@ -0,0 +1,12 @@
+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 admitZipNames(params: {
+    central: Buffer;
+    local: Buffer;
+    flags: number;
+    centralExtra: Map<number, Buffer>;
+    localExtra: Map<number, Buffer>;
+    seen: Set<string>;
+}): string | undefined;
+//# sourceMappingURL=archive-zip-names.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,100 @@
+import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
+import { stripArchivePath, validateArchiveEntryPath } from "./archive-entry.js";
+import { updateCrc32 } from "./archive-crc32.js";
+export function zipFormat(message) {
+    throw new ArchiveFormatError(`invalid ZIP metadata: ${message}`);
+}
+export function zipUInt64(bytes, offset) {
+    if (offset + 8 > bytes.length)
+        zipFormat("truncated ZIP64 field");
+    const value = bytes.readBigUInt64LE(offset);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER))
+        zipFormat("ZIP64 integer exceeds safe range");
+    return Number(value);
+}
+export function zipExtraFields(bytes) {
+    const critical = new Map();
+    for (let offset = 0; offset < bytes.length;) {
+        if (offset + 4 > bytes.length)
+            zipFormat("truncated extra field header");
+        const id = bytes.readUInt16LE(offset);
+        const length = bytes.readUInt16LE(offset + 2);
+        offset += 4;
+        if (length > bytes.length - offset)
+            zipFormat("truncated extra field value");
+        if (id === 1 || id === 0x7075) {
+            if (critical.has(id))
+                zipFormat("duplicate critical extra field");
+            critical.set(id, bytes.subarray(offset, offset + length));
+        }
+        offset += length;
+    }
+    return critical;
+}
+function utf8(bytes) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch {
+        return zipFormat("invalid UTF-8 name");
+    }
+}
+function key(name) {
+    return stripArchivePath(name, 0) ?? "";
+}
+function originalName(name, 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(""));
+    if (!(flags & 0x800))
+        return undefined;
+    const decoded = utf8(name);
+    validateArchiveEntryPath(decoded);
+    return decoded;
+}
+function unicodeName(name, extra) {
+    const field = extra.get(0x7075);
+    if (!field)
+        return undefined;
+    if (field.length < 6 || field[0] !== 1)
+        zipFormat("invalid Unicode Path field");
+    if (field.readUInt32LE(1) !== updateCrc32(0, name))
+        zipFormat("Unicode Path CRC mismatch");
+    const decoded = utf8(field.subarray(5));
+    validateArchiveEntryPath(decoded);
+    return decoded;
+}
+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);
+    const centralUnicode = unicodeName(central, centralExtra);
+    const localUnicode = unicodeName(local, localExtra);
+    if (key(central.toString("latin1")) !== key(local.toString("latin1"))) {
+        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]))) {
+        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"))) {
+        zipFormat("Unicode override disagrees with local decoder name");
+    }
+    if (!centralUnicode && localUnicode && key(localUnicode) !== key(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))) {
+        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);
+}

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

@@ -0,0 +1,7 @@
+import { type ArchiveExtractLimits } from "./archive-limits.js";
+export { readZipCentralDirectoryEntryCount } from "./archive-zip-count.js";
+export type ZipArchiveWithFiles = {
+    files: Record<string, unknown>;
+};
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,44 @@
+import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, resolveExtractLimits, } from "./archive-limits.js";
+import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
+import { admitZipBuffer } from "./archive-zip-admission.js";
+import { validateArchiveEntryPath } from "./archive-entry.js";
+export { readZipCentralDirectoryEntryCount } from "./archive-zip-count.js";
+export async function loadZipArchiveWithPreflight(buffer, limits) {
+    const resolvedLimits = resolveExtractLimits(limits);
+    if (buffer.byteLength > resolvedLimits.maxArchiveBytes) {
+        throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
+    }
+    const entryCount = admitZipBuffer(buffer, resolvedLimits);
+    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 });
+    }
+    if (Object.keys(archive.files).length !== entryCount) {
+        throw new ArchiveSecurityError("entry-path", "zip archive contains duplicate or colliding entry names");
+    }
+    for (const name of Object.keys(archive.files))
+        validateArchiveEntryPath(name);
+    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.d.ts

@@ -0,0 +1,15 @@
+import type { ExtractArchiveOptions } from "./archive-options.js";
+export type { ArchiveLogger, ExtractArchiveOptions } from "./archive-options.js";
+export type { ArchiveEntryFilter, ArchiveEntryKind, ArchiveEntryModePolicy, ArchiveFilteredEntryPolicy, } from "./archive-policy.js";
+export { isWindowsDrivePath, normalizeArchiveEntryPath, resolveArchiveOutputPath, stripArchivePath, validateArchiveEntryPath, } from "./archive-entry.js";
+export { resolveArchiveKind, resolvePackedRootDir, type ArchiveKind } from "./archive-kind.js";
+export { readArchiveEntry } from "./archive-read.js";
+export { inspectTarArchive, type InspectTarArchiveOptions, type InspectedTarEntry } 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, type ArchiveExtractLimits, type ArchiveLimitErrorCode, } from "./archive-limits.js";
+export { ArchiveFormatError, type ArchiveFormatErrorCode } from "./archive-errors.js";
+export { ArchiveSecurityError, type ArchiveSecurityErrorCode } from "./archive-staging.js";
+export { createArchiveSymlinkTraversalError, mergeExtractedTreeIntoDestination, prepareArchiveDestinationDir, prepareArchiveOutputPath, withStagedArchiveDestination, } from "./archive-staging.js";
+export { createTarEntryPreflightChecker, type TarEntryInfo } from "./archive-tar.js";
+export { loadZipArchiveWithPreflight, readZipCentralDirectoryEntryCount, type ZipArchiveWithFiles, } from "./archive-zip-preflight.js";
+export declare function extractArchive(params: ExtractArchiveOptions): Promise<void>;
+//# sourceMappingURL=archive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"archive.d.ts","sourceRoot":"","sources":["../src/archive.ts"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAElE,YAAY,EAAE,aAAa,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AACjF,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,wBAAwB,EACxB,gBAAgB,EAChB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC/F,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,KAAK,wBAAwB,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AACpH,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,6BAA6B,EAC7B,mBAAmB,EACnB,2BAA2B,EAC3B,uBAAuB,EACvB,4BAA4B,EAC5B,iCAAiC,EACjC,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,kBAAkB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAE,oBAAoB,EAAE,KAAK,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAC3F,OAAO,EACL,kCAAkC,EAClC,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,4BAA4B,GAC7B,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,8BAA8B,EAAE,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrF,OAAO,EACL,2BAA2B,EAC3B,iCAAiC,EACjC,KAAK,mBAAmB,GACzB,MAAM,4BAA4B,CAAC;AA6MpC,wBAAsB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA4CjF"}