@openclaw/fs-safe 0.5.6 → 0.7.0

package/dist/archive-tar-meta.js

@@ -3,19 +3,49 @@ import { Transform, Writable } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createGunzip } from "node:zlib";
 import { ArchiveFormatError } from "./archive-errors.js";
-import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError } from "./archive-limits.js";
-class TarMetadataMeter extends Transform {
-    maxMetaEntryBytes;
+import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError, tarManifestEntryCost } from "./archive-limits.js";
+import { parseLocalPax, paxMemberSize } from "./archive-tar-pax.js";
+import { validateGnuMetadata } from "./archive-tar-gnu.js";
+import { rawTarMember } from "./archive-tar-admission.js";
+import { validateTarHeader } from "./archive-tar-header.js";
+// Keep raw framing aligned with native/src/tar_meter.rs, before either parser.
+export class TarMetadataMeter extends Transform {
+    limits;
+    onMember;
     block = Buffer.alloc(512);
     blockLength = 0;
     state = { kind: "header" };
-    constructor(maxMetaEntryBytes) {
+    pendingPax;
+    pendingGnu = new Set();
+    pendingGnuPath;
+    zeroBlocks = 0;
+    entries = 0;
+    remainingDecodedBytes;
+    manifestBytes = 0;
+    constructor(limits, onMember) {
         super();
-        this.maxMetaEntryBytes = maxMetaEntryBytes;
+        this.limits = limits;
+        this.onMember = onMember;
+        if (!Number.isSafeInteger(limits.maxDecodedBytes) || limits.maxDecodedBytes < 0) {
+            throw new RangeError("maxDecodedBytes must be a non-negative safe integer");
+        }
+        this.remainingDecodedBytes = limits.maxDecodedBytes;
+    }
+    countMember() {
+        if (this.entries >= this.limits.maxEntries) {
+            throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ENTRY_COUNT_EXCEEDS_LIMIT);
+        }
+        this.entries += 1;
     }
     invalid(message) {
         return new ArchiveFormatError(`invalid TAR header: ${message}`);
     }
+    paddedSize(size) {
+        const padded = Math.ceil(size / 512) * 512;
+        if (!Number.isSafeInteger(padded))
+            throw this.invalid("entry padding exceeds the safe integer range");
+        return padded;
+    }
     parseSize() {
         const field = this.block.subarray(124, 136);
         if ((field[0] ?? 0) & 0x80) {
@@ -32,7 +62,13 @@ class TarMetadataMeter extends Transform {
             return Number(value);
         }
         const zero = field.indexOf(0);
-        const text = field.subarray(0, zero < 0 ? field.length : zero).toString("ascii").trim();
+        if (zero >= 0 && field.subarray(zero).some((byte) => byte !== 0 && byte !== 0x20)) {
+            throw this.invalid("size has non-padding bytes after NUL");
+        }
+        const bytes = field.subarray(0, zero < 0 ? field.length : zero);
+        if (bytes.some((byte) => byte > 0x7f))
+            throw this.invalid("size is not ASCII octal");
+        const text = bytes.toString("ascii").replace(/^ +| +$/g, "");
         if (!text || !/^[0-7]+$/.test(text))
             throw this.invalid("size is not valid octal");
         const value = Number.parseInt(text, 8);
@@ -42,29 +78,58 @@ class TarMetadataMeter extends Transform {
     }
     finishHeader() {
         if (this.block.every((byte) => byte === 0)) {
+            if (this.pendingPax)
+                throw this.invalid("dangling PAX metadata");
+            if (this.pendingGnu.size)
+                throw this.invalid("dangling GNU metadata");
             this.blockLength = 0;
-            this.state = { kind: "header" };
+            this.zeroBlocks += 1;
+            this.state = { kind: this.zeroBlocks === 2 ? "eof" : "header" };
             return;
         }
+        if (this.zeroBlocks !== 0)
+            throw this.invalid("nonzero header after one TAR zero block");
+        validateTarHeader(this.block);
         const nameEnd = this.block.subarray(0, 100).indexOf(0);
         const name = this.block.subarray(0, nameEnd < 0 ? 100 : nameEnd);
         if (name.length === 0) {
             throw this.invalid("entry path is empty");
         }
-        if (this.block[156] !== 0x35 && name.at(-1) === 0x2f) {
+        if (![0x35, 0x44].includes(this.block[156]) && name.at(-1) === 0x2f) {
             throw this.invalid("non-directory entry path ends with a separator");
         }
-        const size = this.parseSize();
+        let size = this.parseSize();
+        let padded = this.paddedSize(size);
         const type = this.block[156];
-        if ([0x78, 0x67, 0x4c, 0x4b, 0x58].includes(type ?? -1) && size > this.maxMetaEntryBytes) {
+        // Directory/link headers cannot carry bodies; PAX/GNU metadata can.
+        if ([0x31, 0x32, 0x35].includes(type) && size !== 0) {
+            throw this.invalid("directory or link has a nonzero body size");
+        }
+        if ([0x78, 0x67, 0x4c, 0x4b, 0x58, 0x4e].includes(type) && size > this.limits.maxMetaEntryBytes) {
             throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.META_ENTRY_SIZE_EXCEEDS_LIMIT);
         }
-        if (type === 0x78 || type === 0x67 || type === 0x58) {
-            throw this.invalid("PAX metadata is unmeterable without interpreting content");
+        if (type === 0x67 || type === 0x58 || type === 0x4e) {
+            throw this.invalid("global/old PAX and old GNU metadata are not supported");
         }
-        const padded = Math.ceil(size / 512) * 512;
-        if (!Number.isSafeInteger(padded))
-            throw this.invalid("entry padding exceeds the safe integer range");
+        if (type === 0x78 || type === 0x4c || type === 0x4b) {
+            const metadataType = type === 0x78 ? "pax" : type === 0x4c ? "L" : "K";
+            if (this.pendingPax || size === 0 || (metadataType === "pax" ? this.pendingGnu.size : this.pendingGnu.has(metadataType))) {
+                throw this.invalid("empty, repeated or mixed PAX/GNU metadata");
+            }
+            const magic = this.block.subarray(257, 265).toString("latin1");
+            if (magic !== "ustar\0" + "00" && magic !== "ustar  \0")
+                throw this.invalid("unrecognized PAX/GNU header format");
+            if (metadataType !== "pax")
+                this.pendingGnu.add(metadataType);
+            this.state = { kind: "metadata", type: metadataType, body: Buffer.alloc(size), used: 0, padding: padded - size };
+            this.blockLength = 0;
+            return;
+        }
+        // Sparse headers retain their metadata-limit-before-format-error ordering.
+        if (this.pendingPax && type !== 0x53) {
+            size = paxMemberSize(this.pendingPax, type, size, this.block);
+        }
+        padded = this.paddedSize(size);
         if (type === 0x53) {
             if (this.block[482] !== 0 && this.block[482] !== 1) {
                 throw this.invalid("GNU sparse extension flag is not 0 or 1");
@@ -75,13 +140,27 @@ class TarMetadataMeter extends Transform {
             this.state = { kind: "sparse", dataRemaining: padded, metaBytes: 0 };
         }
         else {
+            this.countMember();
+            if (this.pendingGnuPath && /[\\/]$/.test(this.pendingGnuPath) && ![0x35, 0x44].includes(type)) {
+                throw this.invalid("GNU effective non-directory path ends with a separator");
+            }
+            const entry = rawTarMember(this.block, size, this.pendingPax?.path ?? this.pendingGnuPath);
+            const cost = tarManifestEntryCost(entry.path);
+            if (cost > this.limits.maxManifestBytes - this.manifestBytes) {
+                throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.MANIFEST_SIZE_EXCEEDS_LIMIT);
+            }
+            this.manifestBytes += cost;
+            this.onMember?.(entry);
+            this.pendingPax = undefined;
+            this.pendingGnu.clear();
+            this.pendingGnuPath = undefined;
             this.state = padded === 0 ? { kind: "header" } : { kind: "data", remaining: padded };
         }
         this.blockLength = 0;
     }
     finishSparseHeader(state) {
         const metaBytes = state.metaBytes + 512;
-        if (metaBytes > this.maxMetaEntryBytes) {
+        if (metaBytes > this.limits.maxMetaEntryBytes) {
             throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.META_ENTRY_SIZE_EXCEEDS_LIMIT);
         }
         if (this.block[504] !== 0 && this.block[504] !== 1) {
@@ -98,6 +177,29 @@ class TarMetadataMeter extends Transform {
     meter(chunk) {
         let offset = 0;
         while (offset < chunk.length) {
+            if (this.state.kind === "eof") {
+                if (chunk.subarray(offset).some((byte) => byte !== 0))
+                    throw this.invalid("nonzero data after TAR EOF");
+                return;
+            }
+            if (this.state.kind === "metadata") {
+                const state = this.state;
+                const take = Math.min(state.body.length - state.used, chunk.length - offset);
+                chunk.copy(state.body, state.used, offset, offset + take);
+                state.used += take;
+                offset += take;
+                if (state.used === state.body.length) {
+                    if (state.type === "pax")
+                        this.pendingPax = parseLocalPax(state.body);
+                    else {
+                        const name = validateGnuMetadata(state.body, state.type);
+                        if (state.type === "L")
+                            this.pendingGnuPath = name;
+                    }
+                    this.state = state.padding === 0 ? { kind: "header" } : { kind: "data", remaining: state.padding };
+                }
+                continue;
+            }
             if (this.state.kind === "data") {
                 const take = Math.min(this.state.remaining, chunk.length - offset);
                 offset += take;
@@ -119,7 +221,15 @@ class TarMetadataMeter extends Transform {
     }
     _transform(chunk, _encoding, callback) {
         try {
-            this.meter(chunk);
+            const admitted = Math.min(chunk.length, this.remainingDecodedBytes);
+            this.meter(chunk.subarray(0, admitted));
+            this.remainingDecodedBytes -= admitted;
+            if (admitted < chunk.length) {
+                // Inspect only the overflow probe, never scan an unbounded tail.
+                if (this.state.kind === "eof" && chunk[admitted] !== 0)
+                    throw this.invalid("nonzero data after TAR EOF");
+                throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.DECODED_SIZE_EXCEEDS_LIMIT);
+            }
             callback(null, chunk);
         }
         catch (error) {
@@ -127,8 +237,14 @@ class TarMetadataMeter extends Transform {
         }
     }
     _flush(callback) {
-        if (this.state.kind === "header" && this.blockLength === 0)
+        if (this.pendingPax)
+            callback(this.invalid("dangling PAX metadata"));
+        else if (this.pendingGnu.size)
+            callback(this.invalid("dangling GNU metadata"));
+        else if (this.state.kind === "eof")
             callback();
+        else if (this.state.kind === "header" && this.blockLength === 0)
+            callback(this.invalid("missing two-block TAR EOF"));
         else
             callback(this.invalid(this.state.kind === "header" ? "truncated TAR header" : "truncated TAR entry"));
     }
@@ -146,7 +262,7 @@ async function isGzip(filePath) {
 }
 export async function preflightTarMetadata(params) {
     const input = fs.createReadStream(params.archivePath);
-    const meter = new TarMetadataMeter(params.maxMetaEntryBytes);
+    const meter = new TarMetadataMeter(params.limits, params.onMember);
     const sink = new Writable({ write(_chunk, _encoding, callback) { callback(); } });
     if (await isGzip(params.archivePath)) {
         await pipeline(input, createGunzip(), meter, sink, { signal: params.signal });

package/dist/archive-tar-pax.d.ts

@@ -0,0 +1,8 @@
+export type LocalPax = {
+    path?: string;
+    linkpath?: string;
+    size?: number;
+};
+export declare function parseLocalPax(body: Buffer): LocalPax;
+export declare function paxMemberSize(pax: LocalPax, type: number, rawSize: number, header: Buffer): number;
+//# sourceMappingURL=archive-tar-pax.d.ts.map

package/dist/archive-tar-pax.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-tar-pax.d.ts","sourceRoot":"","sources":["../src/archive-tar-pax.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,QAAQ,GAAG;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAqB3E,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,QAAQ,CAwCpD;AAQD,wBAAgB,aAAa,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAclG"}

package/dist/archive-tar-pax.js

@@ -0,0 +1,100 @@
+import { ArchiveFormatError } from "./archive-errors.js";
+function invalid() {
+    throw new ArchiveFormatError("invalid TAR header: unsupported or malformed PAX metadata");
+}
+function decimal(bytes) {
+    const text = bytes.toString("latin1");
+    if (!/^(0|[1-9][0-9]*)$/.test(text))
+        invalid();
+    const value = Number(text);
+    if (!Number.isSafeInteger(value))
+        invalid();
+    return value;
+}
+function ascii(bytes) {
+    if (bytes.length === 0 || bytes.some((byte) => byte < 0x20 || byte > 0x7e))
+        invalid();
+    return bytes.toString("ascii");
+}
+// Keep this grammar aligned with native/src/tar_pax.rs. Downstream parsers
+// disagree on duplicates, coercions and UTF-8 chunk boundaries.
+export function parseLocalPax(body) {
+    if (body.length === 0)
+        invalid();
+    const result = {};
+    const keys = new Set();
+    let offset = 0;
+    while (offset < body.length) {
+        const space = body.indexOf(0x20, offset);
+        if (space < 0)
+            invalid();
+        const length = decimal(body.subarray(offset, space));
+        if (length > body.length - offset || length <= space - offset + 3)
+            invalid();
+        const end = offset + length;
+        if (body[end - 1] !== 0x0a)
+            invalid();
+        const record = body.subarray(space + 1, end - 1);
+        if (record.includes(0x0a))
+            invalid();
+        const equals = record.indexOf(0x3d);
+        if (equals <= 0)
+            invalid();
+        const key = ascii(record.subarray(0, equals));
+        if (!/^[A-Za-z0-9_.-]+$/.test(key) || keys.has(key))
+            invalid();
+        keys.add(key);
+        const value = record.subarray(equals + 1);
+        if (/^(LIBARCHIVE|SCHILY)\.xattr\..+$/.test(key)) {
+            // Inert bytes, never restored. Newlines would corrupt Rust's subsequent
+            // record lookup; NUL and non-UTF8 bytes in these values are harmless.
+        }
+        else if (key === "path" || key === "linkpath") {
+            result[key] = ascii(value);
+        }
+        else if (key === "size") {
+            result.size = decimal(value);
+        }
+        else if (key === "uid" || key === "gid") {
+            decimal(value);
+        }
+        else if (key === "uname" || key === "gname") {
+            ascii(value);
+        }
+        else if (key === "mtime" || key === "atime" || key === "ctime") {
+            const text = ascii(value);
+            if (!/^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/.test(text) || Math.abs(Number(text)) > 8_640_000_000_000)
+                invalid();
+        }
+        else {
+            invalid();
+        }
+        offset = end;
+    }
+    return result;
+}
+function rawText(field) {
+    const zero = field.indexOf(0);
+    const value = field.subarray(0, zero < 0 ? field.length : zero);
+    return value.length === 0 ? "" : ascii(value);
+}
+export function paxMemberSize(pax, type, rawSize, header) {
+    if (![0, 0x30, 0x31, 0x32, 0x35, 0x37].includes(type))
+        invalid();
+    const rawName = rawText(header.subarray(0, 100));
+    const rawLink = rawText(header.subarray(157, 257));
+    if (header.subarray(257, 265).equals(Buffer.from("ustar\0" + "00"))) {
+        rawText(header.subarray(345, 500));
+    }
+    const isLink = type === 0x31 || type === 0x32;
+    if (isLink !== (rawLink.length > 0))
+        invalid();
+    const size = pax.size ?? rawSize;
+    if ([0x31, 0x32, 0x35].includes(type) && (rawSize !== 0 || size !== 0))
+        invalid();
+    if (type !== 0x35 && (pax.path?.endsWith("/") || pax.path?.endsWith("\\") || rawName.endsWith("\\")))
+        invalid();
+    if (pax.linkpath !== undefined && !isLink)
+        invalid();
+    return size;
+}

package/dist/archive-tar-runtime.d.ts

@@ -12,6 +12,7 @@ export type TarParser = NodeJS.WritableStream & {
     on(event: "error", listener: (error: Error) => void): TarParser;
     on(event: "end", listener: () => void): TarParser;
 };
+export declare const NODE_TAR_RATIO_DISABLED: number;
 export type TarModule = {
     Parser: new (options: {
         strict: true;
@@ -25,8 +26,10 @@ export type TarModule = {
         preservePaths: false;
         noChmod: true;
         preserveOwner: false;
+        noMtime: true;
         strict: true;
         maxMetaEntrySize: number;
+        maxDecompressionRatio: number;
         filter?(this: TarParser, entryPath: string, entry: unknown): boolean;
         onReadEntry(this: unknown, entry: unknown): void;
     }): TarParser;
@@ -34,6 +37,7 @@ export type TarModule = {
         file: string;
         strict: true;
         maxMetaEntrySize: number;
+        maxDecompressionRatio: number;
         onReadEntry(entry: AsyncIterable<unknown> & {
             resume(): void;
         }): void;

package/dist/archive-tar-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-tar-runtime.d.ts","sourceRoot":"","sources":["../src/archive-tar-runtime.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,GAAG;IAC9C,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC1B,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,SAAS,CAAC;IAChF,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,SAAS,CAAC;IACzE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,SAAS,CAAC;IACnE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,SAAS,CAAC;IAChE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,SAAS,CAAC;CACnD,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,KAAK,OAAO,EAAE;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,KAAK,SAAS,CAAC;IAC/E,CAAC,CAAC,OAAO,EAAE;QACT,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,aAAa,EAAE,KAAK,CAAC;QACrB,OAAO,EAAE,IAAI,CAAC;QACd,aAAa,EAAE,KAAK,CAAC;QACrB,MAAM,EAAE,IAAI,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;QACzB,MAAM,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;QACrE,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KAClD,GAAG,SAAS,CAAC;IACd,CAAC,CAAC,OAAO,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,IAAI,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;QACzB,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG;YAAE,MAAM,IAAI,IAAI,CAAA;SAAE,GAAG,IAAI,CAAC;KACvE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB,CAAC;AAEF,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,SAAS,CAAC,CAS5D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAS/D"}
+{"version":3,"file":"archive-tar-runtime.d.ts","sourceRoot":"","sources":["../src/archive-tar-runtime.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,IAAI,IAAI,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG,MAAM,CAAC,cAAc,GAAG;IAC9C,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IAC1B,EAAE,CAAC,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,SAAS,CAAC;IAChF,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GAAG,SAAS,CAAC;IACzE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,SAAS,CAAC;IACnE,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,GAAG,SAAS,CAAC;IAChE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,GAAG,SAAS,CAAC;CACnD,CAAC;AAIF,eAAO,MAAM,uBAAuB,QAA2B,CAAC;AAEhE,MAAM,MAAM,SAAS,GAAG;IACtB,MAAM,EAAE,KAAK,OAAO,EAAE;QAAE,MAAM,EAAE,IAAI,CAAC;QAAC,gBAAgB,EAAE,MAAM,CAAA;KAAE,KAAK,SAAS,CAAC;IAC/E,CAAC,CAAC,OAAO,EAAE;QACT,GAAG,EAAE,MAAM,CAAC;QACZ,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,OAAO,CAAC;QACf,MAAM,CAAC,EAAE,WAAW,CAAC;QACrB,aAAa,EAAE,KAAK,CAAC;QACrB,OAAO,EAAE,IAAI,CAAC;QACd,aAAa,EAAE,KAAK,CAAC;QACrB,OAAO,EAAE,IAAI,CAAC;QACd,MAAM,EAAE,IAAI,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;QACzB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,MAAM,CAAC,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC;QACrE,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAC;KAClD,GAAG,SAAS,CAAC;IACd,CAAC,CAAC,OAAO,EAAE;QACT,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,IAAI,CAAC;QACb,gBAAgB,EAAE,MAAM,CAAC;QACzB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,WAAW,CAAC,KAAK,EAAE,aAAa,CAAC,OAAO,CAAC,GAAG;YAAE,MAAM,IAAI,IAAI,CAAA;SAAE,GAAG,IAAI,CAAC;KACvE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtB,CAAC;AAEF,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,SAAS,CAAC,CAS5D;AAED,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAS/D"}

package/dist/archive-tar-runtime.js

@@ -1,4 +1,7 @@
 import { ArchiveFormatError } from "./archive-errors.js";
+// Both callers parse an immutable staged stream only after fs-safe's complete
+// decoded-byte admission, so node-tar must not add backend-specific policy.
+export const NODE_TAR_RATIO_DISABLED = Number.POSITIVE_INFINITY;
 export async function importOptionalTar() {
     try {
         return await import("tar");

package/dist/archive-tar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"archive-tar.d.ts","sourceRoot":"","sources":["../src/archive-tar.ts"],"names":[],"mappings":"AAMA,OAAO,EAKL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAChC,MAAM,qBAAqB,CAAC;AAI7B,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAWvF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAyB7D;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAgDnC"}
+{"version":3,"file":"archive-tar.d.ts","sourceRoot":"","sources":["../src/archive-tar.ts"],"names":[],"mappings":"AAMA,OAAO,EAKL,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAGL,KAAK,kBAAkB,EACvB,KAAK,0BAA0B,EAChC,MAAM,qBAAqB,CAAC;AAI7B,MAAM,MAAM,YAAY,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAWvF,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,YAAY,CAyB7D;AAED,wBAAgB,8BAA8B,CAAC,MAAM,EAAE;IACrD,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,MAAM,CAAC,EAAE,oBAAoB,CAAC;IAC9B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,UAAU,CAAC,EAAE,0BAA0B,CAAC;CACzC,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,OAAO,CAqDnC"}

package/dist/archive-tar.js

@@ -43,7 +43,10 @@ export function createTarEntryPreflightChecker(params) {
         entryCount += 1;
         assertArchiveEntryCountWithinLimit(entryCount, limits);
         validateArchiveEntryPath(entry.path, { escapeLabel: params.escapeLabel });
-        const relPath = stripArchivePath(entry.path, strip);
+        const canonicalPath = stripArchivePath(entry.path, 0);
+        if (!canonicalPath)
+            return false;
+        const relPath = stripArchivePath(canonicalPath, strip);
         if (!relPath) {
             return false;
         }
@@ -60,13 +63,16 @@ export function createTarEntryPreflightChecker(params) {
         if (!shouldExtractArchiveEntry({
             filter: params.entryFilter,
             onFiltered: params.onFiltered,
-            entry: { path: entry.path, kind, size: entry.size },
+            entry: { path: canonicalPath, kind, size: entry.size },
         })) {
             return false;
         }
         if (BLOCKED_TAR_ENTRY_TYPES.has(entry.type)) {
             throw new ArchiveSecurityError("entry-link", `tar entry is a link: ${formatErrorDetail(entry.path)}`);
         }
+        // Accepted unsupported records remain omitted, as in the native plan.
+        if (kind === "other")
+            return false;
         budget.startEntry();
         budget.addEntrySize(entry.size);
         return true;

package/dist/archive-zip-admission.d.ts

@@ -0,0 +1,7 @@
+import type { ExtractionDeadline } from "./archive-deadline.js";
+import { type ResolvedArchiveExtractLimits } from "./archive-limits.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 admitZipFile(archivePath: string, limits: ResolvedArchiveExtractLimits, deadline: ExtractionDeadline): Promise<number>;
+//# sourceMappingURL=archive-zip-admission.d.ts.map

package/dist/archive-zip-admission.d.ts.map

@@ -0,0 +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;AAYrH,+EAA+E;AAC/E,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,4BAA4B,GAAG,MAAM,CAU9F;AAED,sFAAsF;AACtF,wBAAsB,YAAY,CAAC,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,EAAE,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CA+B3I"}

package/dist/archive-zip-admission.js

@@ -0,0 +1,60 @@
+import fs from "node:fs";
+import path from "node:path";
+import { ARCHIVE_LIMIT_ERROR_CODE, ArchiveLimitError } from "./archive-limits.js";
+import { openRootFile } from "./root-file.js";
+import { scanZipDirectory } from "./archive-zip-directory.js";
+import { zipFormat } from "./archive-zip-names.js";
+function checkSize(size, limits) {
+    if (size > limits.maxArchiveBytes) {
+        throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.ARCHIVE_SIZE_EXCEEDS_LIMIT);
+    }
+    if (!Number.isSafeInteger(size) || size < 0)
+        zipFormat("invalid archive size");
+}
+/** Admit physical records before a decoder can normalize or collapse names. */
+export function admitZipBuffer(input, limits) {
+    checkSize(input.byteLength, limits);
+    const buffer = Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+    const scan = scanZipDirectory(buffer.length, limits);
+    let step = scan.next();
+    while (!step.done) {
+        const { offset, length } = step.value;
+        step = scan.next(buffer.subarray(offset, offset + length));
+    }
+    return step.value;
+}
+/** The extraction input is already private and staged; read only bounded metadata. */
+export async function admitZipFile(archivePath, limits, deadline) {
+    deadline.check();
+    const opened = await openRootFile({
+        absolutePath: archivePath, rootPath: path.dirname(archivePath),
+        boundaryLabel: "staged ZIP archive", rejectSymlinks: true, rejectHardlinks: true,
+    });
+    if (!opened.ok)
+        throw opened.error ?? new Error("cannot open staged ZIP archive");
+    try {
+        checkSize(opened.stat.size, limits);
+        const scan = scanZipDirectory(opened.stat.size, limits);
+        let step = scan.next();
+        while (!step.done) {
+            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;
+            }
+            step = scan.next(bytes);
+        }
+        return step.value;
+    }
+    finally {
+        fs.closeSync(opened.fd);
+    }
+}

package/dist/archive-zip-count.d.ts

@@ -0,0 +1,2 @@
+export declare function readZipCentralDirectoryEntryCount(buffer: Buffer | Uint8Array): number | null;
+//# sourceMappingURL=archive-zip-count.d.ts.map

package/dist/archive-zip-count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive-zip-count.d.ts","sourceRoot":"","sources":["../src/archive-zip-count.ts"],"names":[],"mappings":"AA4KA,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,GAAG,IAAI,CAU5F"}

package/dist/archive-zip-count.js

@@ -0,0 +1,140 @@
+// Conservative public count hint; strict admission must not rely on its fallback.
+const ZIP_EOCD_SIGNATURE = 0x06054b50;
+const ZIP64_EOCD_SIGNATURE = 0x06064b50;
+const ZIP64_EOCD_LOCATOR_SIGNATURE = 0x07064b50;
+const ZIP_EOCD_MIN_BYTES = 22;
+const ZIP_EOCD_MAX_COMMENT_BYTES = 0xffff;
+const ZIP64_ENTRY_COUNT_SENTINEL = 0xffff;
+const ZIP64_UINT32_SENTINEL = 0xffffffff;
+const ZIP_CENTRAL_FILE_HEADER_SIGNATURE = 0x02014b50;
+const ZIP_CENTRAL_FILE_HEADER_MIN_BYTES = 46;
+const ZIP_CENTRAL_FILE_HEADER_NAME_LENGTH_OFFSET = 28;
+const ZIP_CENTRAL_FILE_HEADER_EXTRA_LENGTH_OFFSET = 30;
+const ZIP_CENTRAL_FILE_HEADER_COMMENT_LENGTH_OFFSET = 32;
+const ZIP_EOCD_TOTAL_ENTRIES_OFFSET = 10;
+const ZIP_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET = 12;
+const ZIP_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET = 16;
+const ZIP_EOCD_COMMENT_LENGTH_OFFSET = 20;
+const ZIP64_EOCD_LOCATOR_BYTES = 20;
+const ZIP64_EOCD_OFFSET_OFFSET = 8;
+const ZIP64_EOCD_TOTAL_ENTRIES_OFFSET = 32;
+const ZIP64_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET = 40;
+const ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET = 48;
+function asBufferView(buffer) {
+    if (Buffer.isBuffer(buffer)) {
+        return buffer;
+    }
+    return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+}
+function readSafeUInt64LE(buffer, offset) {
+    const value = buffer.readBigUInt64LE(offset);
+    if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return Number.MAX_SAFE_INTEGER;
+    }
+    return Number(value);
+}
+function findZipEndOfCentralDirectory(buffer) {
+    if (buffer.byteLength < ZIP_EOCD_MIN_BYTES) {
+        return -1;
+    }
+    const minOffset = Math.max(0, buffer.byteLength - ZIP_EOCD_MIN_BYTES - ZIP_EOCD_MAX_COMMENT_BYTES);
+    for (let offset = buffer.byteLength - ZIP_EOCD_MIN_BYTES; offset >= minOffset; offset -= 1) {
+        if (buffer.readUInt32LE(offset) !== ZIP_EOCD_SIGNATURE) {
+            continue;
+        }
+        const commentLength = buffer.readUInt16LE(offset + ZIP_EOCD_COMMENT_LENGTH_OFFSET);
+        if (offset + ZIP_EOCD_MIN_BYTES + commentLength === buffer.byteLength) {
+            return offset;
+        }
+    }
+    return -1;
+}
+function readZip64CentralDirectoryInfo(buffer, eocdOffset) {
+    const locatorOffset = eocdOffset - ZIP64_EOCD_LOCATOR_BYTES;
+    if (locatorOffset < 0 || buffer.readUInt32LE(locatorOffset) !== ZIP64_EOCD_LOCATOR_SIGNATURE) {
+        return null;
+    }
+    const zip64EocdOffset = readSafeUInt64LE(buffer, locatorOffset + ZIP64_EOCD_OFFSET_OFFSET);
+    if (zip64EocdOffset < 0 ||
+        zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET + 8 > buffer.byteLength ||
+        buffer.readUInt32LE(zip64EocdOffset) !== ZIP64_EOCD_SIGNATURE) {
+        return null;
+    }
+    return {
+        declaredEntryCount: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_TOTAL_ENTRIES_OFFSET),
+        centralDirectorySize: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET),
+        centralDirectoryOffset: readSafeUInt64LE(buffer, zip64EocdOffset + ZIP64_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET),
+        endOfCentralDirectoryOffset: eocdOffset,
+    };
+}
+function readZipCentralDirectoryInfo(buffer) {
+    const eocdOffset = findZipEndOfCentralDirectory(buffer);
+    if (eocdOffset < 0) {
+        return null;
+    }
+    const declaredEntryCount = buffer.readUInt16LE(eocdOffset + ZIP_EOCD_TOTAL_ENTRIES_OFFSET);
+    const centralDirectorySize = buffer.readUInt32LE(eocdOffset + ZIP_EOCD_CENTRAL_DIRECTORY_SIZE_OFFSET);
+    const centralDirectoryOffset = buffer.readUInt32LE(eocdOffset + ZIP_EOCD_CENTRAL_DIRECTORY_OFFSET_OFFSET);
+    const usesZip64 = declaredEntryCount === ZIP64_ENTRY_COUNT_SENTINEL ||
+        centralDirectorySize === ZIP64_UINT32_SENTINEL ||
+        centralDirectoryOffset === ZIP64_UINT32_SENTINEL;
+    if (usesZip64) {
+        return (readZip64CentralDirectoryInfo(buffer, eocdOffset) ?? {
+            declaredEntryCount,
+            centralDirectoryOffset,
+            centralDirectorySize,
+            endOfCentralDirectoryOffset: eocdOffset,
+        });
+    }
+    return {
+        declaredEntryCount,
+        centralDirectoryOffset,
+        centralDirectorySize,
+        endOfCentralDirectoryOffset: eocdOffset,
+    };
+}
+function countZipCentralDirectoryHeaders(buffer, info) {
+    const start = info.centralDirectoryOffset;
+    const declaredEnd = start + info.centralDirectorySize;
+    const scanEnd = info.endOfCentralDirectoryOffset;
+    if (!Number.isSafeInteger(start) ||
+        !Number.isSafeInteger(declaredEnd) ||
+        !Number.isSafeInteger(scanEnd) ||
+        start < 0 ||
+        declaredEnd < start ||
+        scanEnd < start ||
+        scanEnd > buffer.byteLength) {
+        return null;
+    }
+    let offset = start;
+    let count = 0;
+    while (offset < scanEnd) {
+        if (scanEnd - offset < ZIP_CENTRAL_FILE_HEADER_MIN_BYTES) {
+            break;
+        }
+        if (buffer.readUInt32LE(offset) !== ZIP_CENTRAL_FILE_HEADER_SIGNATURE) {
+            break;
+        }
+        const nameLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_NAME_LENGTH_OFFSET);
+        const extraLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_EXTRA_LENGTH_OFFSET);
+        const commentLength = buffer.readUInt16LE(offset + ZIP_CENTRAL_FILE_HEADER_COMMENT_LENGTH_OFFSET);
+        const nextOffset = offset + ZIP_CENTRAL_FILE_HEADER_MIN_BYTES + nameLength + extraLength + commentLength;
+        if (nextOffset <= offset || nextOffset > scanEnd) {
+            return null;
+        }
+        count += 1;
+        offset = nextOffset;
+    }
+    return count > 0 || info.declaredEntryCount === 0 ? count : null;
+}
+export function readZipCentralDirectoryEntryCount(buffer) {
+    const view = asBufferView(buffer);
+    const info = readZipCentralDirectoryInfo(view);
+    if (!info) {
+        return null;
+    }
+    const countedEntryCount = countZipCentralDirectoryHeaders(view, info);
+    return countedEntryCount === null
+        ? info.declaredEntryCount
+        : Math.max(info.declaredEntryCount, countedEntryCount);
+}