@openclaw/fs-safe 0.8.0 → 0.8.2

package/dist/archive-tar-header.js

@@ -1,47 +0,0 @@
-import { ArchiveFormatError, ArchiveSecurityError } from "./archive-errors.js";
-const utf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
-export function validateTarChecksum(header) {
-    const field = header.subarray(148, 156);
-    const end = field.indexOf(0);
-    const digits = field.subarray(0, end < 0 ? field.length : end).toString("latin1").replace(/^ +| +$/g, "");
-    const sum = header.reduce((total, byte, index) => total + (index >= 148 && index < 156 ? 32 : byte), 0);
-    // Require an in-field delimiter: node-tar otherwise reads into the typeflag.
-    if (!/^[0-7]+$/.test(digits) || ![0, 32].includes(field[7]) ||
-        (end >= 0 && field.subarray(end).some((byte) => byte !== 0 && byte !== 32)) ||
-        Number.parseInt(digits, 8) !== sum) {
-        throw new ArchiveFormatError("invalid TAR header: checksum failure");
-    }
-}
-function fixedField(field) {
-    const zero = field.indexOf(0);
-    if (zero >= 0 && field.subarray(zero).some((byte) => byte !== 0)) {
-        throw new ArchiveSecurityError("entry-path", "tar entry path contains bytes after NUL");
-    }
-    try {
-        return utf8.decode(field.subarray(0, zero < 0 ? field.length : zero));
-    }
-    catch {
-        throw new ArchiveSecurityError("entry-path", "tar entry path is not valid UTF-8");
-    }
-}
-export function readTarHeaderPaths(header) {
-    // node-tar's star layout uses a 130-byte prefix followed by atime/ctime.
-    const prefixEnd = header[475] === 0 ? 475 : 500;
-    return {
-        name: fixedField(header.subarray(0, 100)),
-        prefix: header.subarray(257, 265).equals(Buffer.from("ustar\0" + "00"))
-            ? fixedField(header.subarray(345, prefixEnd)) : "",
-        linkname: fixedField(header.subarray(157, 257)),
-    };
-}
-export function validateTarHeader(header) {
-    validateTarChecksum(header);
-    const { linkname } = readTarHeaderPaths(header);
-    const isLink = header[156] === 0x31 || header[156] === 0x32;
-    if (isLink && !linkname) {
-        throw new ArchiveFormatError("invalid TAR header: linkname required on a link header");
-    }
-    if (!isLink && linkname) {
-        throw new ArchiveFormatError("invalid TAR header: linkname forbidden on a non-link header");
-    }
-}

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

@@ -1,34 +0,0 @@
-import { Transform } from "node:stream";
-import { type TarMeterLimits } from "./archive-limits.js";
-import type { TarEntryInfo } from "./archive-tar.js";
-export declare class TarMetadataMeter extends Transform {
-    private readonly limits;
-    private readonly onMember?;
-    private readonly block;
-    private blockLength;
-    private state;
-    private pendingPax;
-    private readonly pendingGnu;
-    private pendingGnuPath;
-    private zeroBlocks;
-    private entries;
-    private remainingDecodedBytes;
-    private manifestBytes;
-    constructor(limits: TarMeterLimits, onMember?: ((entry: TarEntryInfo) => void) | undefined);
-    private countMember;
-    private invalid;
-    private paddedSize;
-    private parseSize;
-    private finishHeader;
-    private finishSparseHeader;
-    private meter;
-    _transform(chunk: Buffer, _encoding: BufferEncoding, callback: (error?: Error | null, data?: Buffer) => void): void;
-    _flush(callback: (error?: Error | null) => void): void;
-}
-export declare function preflightTarMetadata(params: {
-    archivePath: string;
-    limits: TarMeterLimits;
-    signal?: AbortSignal;
-    onMember?: (entry: TarEntryInfo) => void;
-}): Promise<void>;
-//# sourceMappingURL=archive-tar-meta.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"archive-tar-meta.d.ts","sourceRoot":"","sources":["../src/archive-tar-meta.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAY,MAAM,aAAa,CAAC;AAIlD,OAAO,EAAqE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAI7H,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAWrD,qBAAa,gBAAiB,SAAQ,SAAS;IAYjC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAAkB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC;IAX/E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,KAAK,CAAkC;IAC/C,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAwB;IACnD,OAAO,CAAC,cAAc,CAAqB;IAC3C,OAAO,CAAC,UAAU,CAAK;IACvB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,aAAa,CAAK;IAE1B,YAA6B,MAAM,EAAE,cAAc,EAAmB,QAAQ,CAAC,GAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,aAAA,EAM7G;IAED,OAAO,CAAC,WAAW;IAOnB,OAAO,CAAC,OAAO;IAIf,OAAO,CAAC,UAAU;IAMlB,OAAO,CAAC,SAAS;IA4BjB,OAAO,CAAC,YAAY;IA6EpB,OAAO,CAAC,kBAAkB;IAgB1B,OAAO,CAAC,KAAK;IAyCJ,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,cAAc,EAAE,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAc3H;IAEQ,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,EAAE,KAAK,GAAG,IAAI,KAAK,IAAI,GAAG,IAAI,CAM9D;CACF;AAaD,wBAAsB,oBAAoB,CAAC,MAAM,EAAE;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,cAAc,CAAC;IACvB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;CAC1C,GAAG,OAAO,CAAC,IAAI,CAAC,CAahB"}

package/dist/archive-tar-meta.js

@@ -1,277 +0,0 @@
-import fs from "node:fs";
-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, 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" };
-    pendingPax;
-    pendingGnu = new Set();
-    pendingGnuPath;
-    zeroBlocks = 0;
-    entries = 0;
-    remainingDecodedBytes;
-    manifestBytes = 0;
-    constructor(limits, onMember) {
-        super();
-        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) {
-            if (field[0] !== 0x80) {
-                throw this.invalid("base-256 size is negative or malformed");
-            }
-            let value = 0n;
-            for (const byte of field.subarray(1)) {
-                value = (value << 8n) | BigInt(byte);
-            }
-            if (value > BigInt(Number.MAX_SAFE_INTEGER)) {
-                throw this.invalid("base-256 size exceeds the safe integer range");
-            }
-            return Number(value);
-        }
-        const zero = field.indexOf(0);
-        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);
-        if (!Number.isSafeInteger(value))
-            throw this.invalid("octal size exceeds the safe integer range");
-        return value;
-    }
-    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.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 (![0x35, 0x44].includes(this.block[156]) && name.at(-1) === 0x2f) {
-            throw this.invalid("non-directory entry path ends with a separator");
-        }
-        let size = this.parseSize();
-        let padded = this.paddedSize(size);
-        const type = this.block[156];
-        // 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 === 0x67 || type === 0x58 || type === 0x4e) {
-            throw this.invalid("global/old PAX and old GNU metadata are not supported");
-        }
-        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");
-            }
-            if (this.block[482] === 0) {
-                throw this.invalid("GNU sparse entries are not supported");
-            }
-            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.limits.maxMetaEntryBytes) {
-            throw new ArchiveLimitError(ARCHIVE_LIMIT_ERROR_CODE.META_ENTRY_SIZE_EXCEEDS_LIMIT);
-        }
-        if (this.block[504] !== 0 && this.block[504] !== 1) {
-            throw this.invalid("GNU sparse extension flag is not 0 or 1");
-        }
-        if (this.block[504] === 1) {
-            this.state = { ...state, metaBytes };
-        }
-        else {
-            throw this.invalid("GNU sparse entries are not supported");
-        }
-        this.blockLength = 0;
-    }
-    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;
-                const remaining = this.state.remaining - take;
-                this.state = remaining === 0 ? { kind: "header" } : { kind: "data", remaining };
-                continue;
-            }
-            const take = Math.min(512 - this.blockLength, chunk.length - offset);
-            chunk.copy(this.block, this.blockLength, offset, offset + take);
-            this.blockLength += take;
-            offset += take;
-            if (this.blockLength === 512) {
-                if (this.state.kind === "sparse")
-                    this.finishSparseHeader(this.state);
-                else
-                    this.finishHeader();
-            }
-        }
-    }
-    _transform(chunk, _encoding, callback) {
-        try {
-            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) {
-            callback(error instanceof Error ? error : new Error(String(error)));
-        }
-    }
-    _flush(callback) {
-        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"));
-    }
-}
-async function isGzip(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] === 0x1f && magic[1] === 0x8b;
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function preflightTarMetadata(params) {
-    const meter = new TarMetadataMeter(params.limits, params.onMember);
-    const sink = new Writable({ write(_chunk, _encoding, callback) { callback(); } });
-    const gzip = await isGzip(params.archivePath);
-    const decoder = gzip ? createGunzip() : undefined;
-    const input = fs.createReadStream(params.archivePath);
-    try {
-        await (decoder
-            ? pipeline(input, decoder, meter, sink, { signal: params.signal })
-            : pipeline(input, meter, sink, { signal: params.signal }));
-    }
-    finally {
-        input.destroy();
-    }
-}

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

@@ -1,8 +0,0 @@
-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

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

@@ -1,100 +0,0 @@
-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

@@ -1,49 +0,0 @@
-export type TarParserEntry = {
-    meta?: boolean;
-    size: number;
-    type?: string;
-    resume(): void;
-};
-export type TarParser = NodeJS.WritableStream & {
-    abort(error: Error): void;
-    on(event: "ignoredEntry", listener: (entry: TarParserEntry) => void): TarParser;
-    on(event: "entry", listener: (entry: TarParserEntry) => void): TarParser;
-    on(event: "meta", listener: (metadata: string) => void): TarParser;
-    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;
-        maxMetaEntrySize: number;
-    }) => TarParser;
-    x(options: {
-        cwd: string;
-        strip: number;
-        gzip?: boolean;
-        signal?: AbortSignal;
-        preservePaths: false;
-        noChmod: true;
-        preserveOwner: false;
-        noMtime: true;
-        dmode: number;
-        strict: true;
-        maxMetaEntrySize: number;
-        maxDecompressionRatio: number;
-        filter?(this: TarParser, entryPath: string, entry: unknown): boolean;
-        onReadEntry(this: unknown, entry: unknown): void;
-    }): TarParser;
-    t(options: {
-        file: string;
-        strict: true;
-        maxMetaEntrySize: number;
-        maxDecompressionRatio: number;
-        onReadEntry(entry: AsyncIterable<unknown> & {
-            resume(): void;
-        }): void;
-    }): Promise<unknown>;
-};
-export declare function importOptionalTar(): Promise<TarModule>;
-export declare function normalizeTarParserError(error: unknown): unknown;
-//# sourceMappingURL=archive-tar-runtime.d.ts.map

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

@@ -1 +0,0 @@
-{"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,KAAK,EAAE,MAAM,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,22 +0,0 @@
-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");
-    }
-    catch (cause) {
-        throw new Error('Optional archive dependency "tar" is not installed. Install it to use TAR archive helpers from @openclaw/fs-safe/archive.', { cause });
-    }
-}
-export function normalizeTarParserError(error) {
-    const code = error?.code;
-    if (typeof code !== "string" || !code.startsWith("TAR_")) {
-        return error;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    return new ArchiveFormatError(`invalid TAR archive: ${message}`, {
-        cause: error instanceof Error ? error : undefined,
-    });
-}