@poe-platform/safe-bash 0.1.799 → 0.1.801

package/dist/safe-bash/commands/archive/zip/options.js

@@ -1,125 +1,2 @@
-export class ZipFailure extends Error {
-    status;
-    label;
-    constructor(status, label, detail) {
-        super(detail);
-        this.status = status;
-        this.label = label;
-    }
-}
-// Native two-character switches take precedence over grouped one-character
-// flags. These collisions must fail before enabling delete, move or test.
-export const reservedZipShortOptions = new Set(["mm"]);
-export const zipLongOptions = {
-    "adjust-sfx": "A", fix: "F", fixfix: "FF",
-    "split-size": "s", "split-pause": "sp", "split-verbose": "sv", "split-bell": "sb",
-    fifo: "FI", "DOS-names": "k", regex: "RE",
-    password: "P", encrypt: "e",
-    "difference-archive": "DF", grow: "g", "temp-path": "b", "junk-sfx": "J",
-    "logfile-path": "lf", "log-append": "la", "log-info": "li", "unzip-command": "TT",
-    verbose: "v", version: "version", license: "L", "show-command": "sc", "show-debug": "sd", "show-files": "sf", "show-options": "so",
-    "display-bytes": "db", "display-counts": "dc", "display-dots": "dd", "display-globaldots": "dg", "dot-size": "ds", "display-usize": "du", "display-volume": "dv",
-    "recurse-paths": "r", quiet: "q", "junk-paths": "j", paths: "p", help: "h", "more-help": "h2", "no-dir-entries": "D",
-    symlinks: "y", test: "T", "names-stdin": "@", update: "u", freshen: "f", filesync: "FS", "archive-comment": "z", "entry-comments": "c", "latest-time": "o", move: "m", "to-crlf": "l",
-    "from-crlf": "ll", delete: "d", include: "i", exclude: "x", suffixes: "n", store: "0", "compression-method": "Z",
-    "compress-1": "1", "compress-2": "2", "compress-3": "3", "compress-4": "4",
-    "compress-5": "5", "compress-6": "6", "compress-7": "7", "compress-8": "8",
-    "compress-9": "9", "force-zip64": "fz", "strip-extra": "X", "force-descriptors": "fd", "no-wild": "nw", "wild-stop-dirs": "ws", "recurse-patterns": "R", "from-date": "t", "before-date": "tt", "copy-entries": "U", "output-file": "O", "must-match": "MM",
-};
-// Include unimplemented Unix options when resolving abbreviations: a partial
-// implementation must not make native-ambiguous prefixes uniquely resolvable.
-const reservedOptions = [
-    "show-unicode", "show-just-unicode",
-];
-export function normalizeZipOption(argument) {
-    if (!argument.startsWith("--") || argument === "--")
-        return argument;
-    const equal = argument.indexOf("=");
-    const rawName = argument.slice(2, equal < 0 ? undefined : equal);
-    const negate = rawName.endsWith("-");
-    const name = negate ? rawName.slice(0, -1) : rawName;
-    const names = [...Object.keys(zipLongOptions), ...reservedOptions];
-    const matches = names.includes(name) ? [name] : names.filter(option => option.startsWith(name));
-    if (matches.length > 1)
-        throw new ZipFailure(16, "Invalid command arguments", `long option '${name}' ambiguous`);
-    const matched = matches[0];
-    const short = matched === undefined ? undefined : zipLongOptions[matched];
-    if (!short)
-        throw new ZipFailure(16, "Invalid command arguments", `unsupported option: --${name}`);
-    if (negate && !zipNegatableOptions.has(short))
-        throw new ZipFailure(16, "Invalid command arguments", `option ${matched} is not negatable`);
-    if (equal >= 0 && short !== "s" && short !== "P" && short !== "i" && short !== "x" && short !== "n" && short !== "Z" && short !== "t" && short !== "tt" && short !== "O" && short !== "ds" && short !== "b" && short !== "lf" && short !== "TT") {
-        throw new ZipFailure(16, "Invalid command arguments", `option '${matched}' does not allow a value`);
-    }
-    if (short === "version")
-        return "--version";
-    return `-${short}${negate ? "-" : ""}${equal < 0 ? "" : argument.slice(equal)}`;
-}
-export const zipNegatableOptions = new Set(["FI", "fz", "X", "db", "dc", "dd", "dg", "du", "dv", "sf"]);
-export function parseZipDotSize(value) {
-    if (!value)
-        return 10 * 1024 * 1024;
-    let end = 0;
-    while (end < value.length && value[end] >= "0" && value[end] <= "9")
-        end++;
-    const unit = value.slice(end).toLowerCase();
-    const multiplier = { "": 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3, t: 1024 ** 4 }[unit];
-    const size = Number(value.slice(0, end)) * (multiplier ?? 0);
-    if (!end || value.length > 8 || multiplier === undefined || !Number.isSafeInteger(size)) {
-        throw new ZipFailure(16, "Invalid command arguments", "option -ds (--dot-size) has bad size");
-    }
-    if (size >= 1024 && size < 32 * 1024)
-        throw new ZipFailure(16, "Invalid command arguments", "dot size must be at least 32 KB");
-    return size < 1024 ? size * 1024 ** 2 : size;
-}
-export function zipDisplaySize(size) {
-    let unit = 0;
-    while (size >= 10240) {
-        size = Math.floor(size / 1024);
-        unit++;
-    }
-    const number = size >= 1000 ? (Math.floor(size * 10 / 1024) / 10).toFixed(1) : String(size);
-    if (size >= 1000)
-        unit++;
-    return `${number}${["", "K", "M", "G", "T"][unit] ?? "T"}`;
-}
-// Diagnostic arguments can be literal paths as well as options. Never expose
-// credentials merely because an option-shaped path follows the -- terminator.
-export function zipPasswordArgument(value) {
-    if (value.startsWith("--")) {
-        const equal = value.indexOf("=");
-        const name = value.slice(2, equal < 0 ? undefined : equal);
-        if (name.length >= 3 && "password".startsWith(name))
-            return equal < 0 ? "separate" : "attached";
-    }
-    else if (value.startsWith("-")) {
-        const password = value.indexOf("P", 1);
-        if (password >= 0)
-            return password === value.length - 1 ? "separate" : "attached";
-    }
-    return undefined;
-}
-export function zipPublicText(value) {
-    const lower = value.toLowerCase();
-    if (zipPasswordArgument(value) || lower.includes("password") || lower.includes("token=") || lower.includes("secret="))
-        return "[redacted]";
-    // Special URL schemes can carry credentials even with omitted authority
-    // slashes. Refuse those noncanonical forms before displaying path text.
-    if (value.includes("://") || ["http:", "https:", "ftp:", "ws:", "wss:"].some(scheme => lower.includes(scheme))) {
-        try {
-            const url = new URL(value);
-            if (!value.startsWith(`${url.protocol}//`))
-                return "[redacted URL]";
-            url.username = "";
-            url.password = "";
-            url.search = "";
-            url.hash = "";
-            return url.toString();
-        }
-        catch {
-            return "[redacted URL]";
-        }
-    }
-    return value;
-}
+export * from "../../../../safe-bash-zip-engine/zip/options.js";
 //# sourceMappingURL=options.js.map

package/dist/safe-bash/commands/archive/zip/repair.d.ts

@@ -1,11 +1,2 @@
-import { type ArchiveLimits } from "../internal.js";
-import { type ZipArchive } from "../zip-format.js";
-/** Recovery is opt-in. Signatures nominate records; the normal reader and
- * codecs validate metadata, descriptors, names, sizes and CRC before retention. */
-export declare function repairZip(bytes: Uint8Array, mode: "F" | "FF", limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): Promise<{
-    archive: ZipArchive;
-    partial: boolean;
-}>;
-/** Adjust a validated SFX using owned bytes; prefix bytes are inert. */
-export declare function adjustZipSfx(bytes: Uint8Array, archive: ZipArchive, limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): Promise<Uint8Array>;
+export * from "../../../../safe-bash-zip-engine/zip/repair.js";
 //# sourceMappingURL=repair.d.ts.map

package/dist/safe-bash/commands/archive/zip/repair.js

@@ -1,393 +1,2 @@
-import { concatBytes } from "../../../byte-encoding.js";
-import { yieldTurn } from "../../../contracts/yield.js";
-import { fail } from "../internal.js";
-import { decodeZipEntry, readZipArchive } from "../zip-format.js";
-import { zipEnd, zip64Fields, stripZip64 } from "./zip64.js";
-import { ZipFailure } from "./options.js";
-function zip64Payload(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    let result;
-    for (let offset = 0; offset < bytes.length;) {
-        if (offset + 4 > bytes.length)
-            fail("ZIP truncated extra field");
-        const next = offset + 4 + view.getUint16(offset + 2, true);
-        if (next > bytes.length)
-            fail("ZIP truncated extra field");
-        if (view.getUint16(offset, true) === 1) {
-            if (result)
-                fail("ZIP duplicate ZIP64 extra field");
-            result = bytes.subarray(offset + 4, next);
-        }
-        offset = next;
-    }
-    return result;
-}
-/** Recovery is opt-in. Signatures nominate records; the normal reader and
- * codecs validate metadata, descriptors, names, sizes and CRC before retention. */
-export async function repairZip(bytes, mode, limits, signal, password) {
-    signal.throwIfAborted();
-    if (bytes.length > limits.maxArchiveBytes)
-        fail("ZIP archive byte limit exceeded");
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    let work = 0, candidates = 0, decoded = 0;
-    const charge = (amount) => {
-        signal.throwIfAborted();
-        if (amount > limits.maxPatternSteps - work)
-            throw new ZipFailure(4, "Out of memory", "ZIP recovery work limit exceeded");
-        work += amount;
-    };
-    const verify = async (archive) => {
-        for (const entry of archive.entries) {
-            for await (const chunk of decodeZipEntry(entry, limits, signal, password)) {
-                charge(chunk.length);
-                if (chunk.length > limits.maxTotalBytes - decoded)
-                    throw new ZipFailure(4, "Out of memory", "ZIP recovery total byte limit exceeded");
-                decoded += chunk.length;
-            }
-        }
-    };
-    const recoverCentral = async (archive) => {
-        const entries = [];
-        let partial = false;
-        for (const entry of archive.entries) {
-            try {
-                await verify({ entries: [entry], comment: new Uint8Array() });
-                entries.push(entry);
-            }
-            catch (error) {
-                signal.throwIfAborted();
-                if (error instanceof ZipFailure)
-                    throw error;
-                if (mode === "F")
-                    throw new ZipFailure(3, "Zip file structure invalid", "entry payload could not be verified; try -FF with a separate --out file");
-                partial = true;
-            }
-        }
-        if (partial && !entries.length)
-            throw new ZipFailure(3, "Zip file structure invalid", "no verified members recovered");
-        return { archive: { ...archive, entries }, partial };
-    };
-    const admitCandidate = (length) => {
-        if (++candidates > limits.maxMembers)
-            fail("ZIP recovery candidate limit exceeded");
-        charge(length);
-        if (length > limits.maxArchiveBytes)
-            fail("ZIP recovery archive byte limit exceeded");
-    };
-    charge(bytes.length);
-    let complete;
-    try {
-        complete = await readZipArchive(bytes, limits, signal, { prefix: true });
-    }
-    catch {
-        signal.throwIfAborted();
-    }
-    if (complete?.prefix?.length) {
-        // A complete ZIP at EOF can itself be a bounded outer member's payload.
-        // Recovery must not reinterpret that preceding local record as an SFX stub.
-        const prefixLength = complete.prefix.length;
-        for (let offset = 0; offset + 30 <= prefixLength; offset++) {
-            charge(1);
-            if (offset % 4096 === 0)
-                await yieldTurn(signal);
-            if (view.getUint32(offset, true) !== 0x04034b50)
-                continue;
-            const payload = offset + 30 + view.getUint16(offset + 26, true) + view.getUint16(offset + 28, true);
-            if (view.getUint16(offset + 26, true) && payload <= prefixLength) {
-                complete = undefined;
-                break;
-            }
-        }
-    }
-    if (complete)
-        return recoverCentral(complete);
-    // -F uses existing central metadata. It never invents attributes or guesses
-    // missing members. A synthetic EOCD must pass the complete strict reader.
-    {
-        let firstLocal = -1;
-        for (let start = 0; start + 46 <= bytes.length; start++) {
-            charge(1);
-            if (start % 4096 === 0)
-                await yieldTurn(signal);
-            if (start + 30 <= bytes.length && view.getUint32(start, true) === 0x04034b50) {
-                if (firstLocal < 0)
-                    firstLocal = start;
-                const payload = start + 30 + view.getUint16(start + 26, true) + view.getUint16(start + 28, true);
-                let compressed = view.getUint32(start + 18, true);
-                if (compressed === 0xffffffff && payload <= bytes.length) {
-                    try {
-                        const extra = bytes.subarray(start + 30 + view.getUint16(start + 26, true), payload);
-                        compressed = zip64Fields(zip64Payload(extra), [view.getUint32(start + 22, true), compressed])[1];
-                    }
-                    catch {
-                        signal.throwIfAborted();
-                    }
-                }
-                const end = payload + compressed;
-                if (compressed !== 0xffffffff && compressed && end <= bytes.length) {
-                    start = end - 1;
-                    continue;
-                }
-            }
-            if (view.getUint32(start, true) !== 0x02014b50)
-                continue;
-            let end = start, members = 0, minimumLocal = Infinity;
-            while (end + 46 <= bytes.length && view.getUint32(end, true) === 0x02014b50) {
-                charge(46);
-                if (++members > limits.maxMembers)
-                    fail("ZIP recovery member limit exceeded");
-                const next = end + 46 + view.getUint16(end + 28, true) + view.getUint16(end + 30, true) + view.getUint16(end + 32, true);
-                if (next > bytes.length)
-                    break;
-                try {
-                    const extra = end + 46 + view.getUint16(end + 28, true);
-                    const values = zip64Fields(zip64Payload(bytes.subarray(extra, extra + view.getUint16(end + 30, true))), [view.getUint32(end + 24, true), view.getUint32(end + 20, true), view.getUint32(end + 42, true)]);
-                    minimumLocal = Math.min(minimumLocal, values[2]);
-                }
-                catch {
-                    signal.throwIfAborted();
-                }
-                end = next;
-            }
-            const displacement = firstLocal >= 0 && minimumLocal !== Infinity ? Math.max(0, firstLocal - minimumLocal) : 0;
-            const tail = zipEnd(members, end - start, start - displacement, new Uint8Array());
-            admitCandidate(end + tail.length);
-            const candidate = new Uint8Array(end + tail.length);
-            candidate.set(bytes.subarray(0, end));
-            candidate.set(tail, end);
-            let archive;
-            try {
-                archive = await readZipArchive(candidate, limits, signal, { prefix: true });
-            }
-            catch {
-                signal.throwIfAborted();
-                continue;
-            }
-            if (firstLocal >= 0 && archive.prefix?.length !== firstLocal)
-                continue;
-            return recoverCentral(archive);
-        }
-        if (mode === "F")
-            throw new ZipFailure(3, "Zip file structure invalid", "central directory could not be verified; try -FF with a separate --out file");
-    }
-    const entries = [];
-    const names = new Set();
-    let partial = false, total = 0;
-    for (let start = 0; start + 4 <= bytes.length; start++) {
-        charge(1);
-        if (start % 4096 === 0)
-            await yieldTurn(signal);
-        if (view.getUint32(start, true) !== 0x04034b50)
-            continue;
-        if (start + 30 > bytes.length) {
-            partial = true;
-            break;
-        }
-        const flags = view.getUint16(start + 6, true);
-        const nameLength = view.getUint16(start + 26, true), extraLength = view.getUint16(start + 28, true);
-        const payload = start + 30 + nameLength + extraLength;
-        if (payload > bytes.length || nameLength > limits.maxPathBytes || extraLength > limits.maxPaxBytes) {
-            partial = true;
-            break;
-        }
-        const rawCompressed = view.getUint32(start + 18, true), rawSize = view.getUint32(start + 22, true);
-        const checksum = view.getUint32(start + 14, true);
-        const wide = rawCompressed === 0xffffffff || rawSize === 0xffffffff;
-        const localExtra = bytes.subarray(start + 30 + nameLength, payload);
-        let compressed = rawCompressed, size = rawSize;
-        let centralExtra;
-        try {
-            [size, compressed] = zip64Fields(zip64Payload(localExtra), [rawSize, rawCompressed]);
-            centralExtra = stripZip64(localExtra);
-            // Local UT fields may contain access/creation times; central UT contains
-            // only mtime. Retain opaque fields and the existing name codecs.
-            const fields = [];
-            const centralView = new DataView(centralExtra.buffer);
-            for (let offset = 0; offset < centralExtra.length;) {
-                const next = offset + 4 + centralView.getUint16(offset + 2, true);
-                if (centralView.getUint16(offset, true) === 0x5455 && next - offset >= 5) {
-                    const mtime = centralExtra[offset + 4] & 1;
-                    const stamp = new Uint8Array(centralExtra.subarray(offset, offset + (mtime ? 9 : 5)));
-                    new DataView(stamp.buffer).setUint16(2, mtime ? 5 : 1, true);
-                    stamp[4] = mtime;
-                    fields.push(stamp);
-                }
-                else
-                    fields.push(centralExtra.subarray(offset, next));
-                offset = next;
-            }
-            centralExtra = new Uint8Array(concatBytes(fields));
-        }
-        catch {
-            signal.throwIfAborted();
-            partial = true;
-            // A non-descriptor classic header still bounds the rejected record.
-            // Skip its entire payload, including apparent embedded members. ZIP64
-            // and descriptor records need verified metadata to establish that end.
-            if (!(flags & 8) && !wide && payload + rawCompressed <= bytes.length) {
-                start = payload + rawCompressed - 1;
-                continue;
-            }
-            break;
-        }
-        const attempt = async (end, compressedSize, expanded, crc) => {
-            if (expanded > limits.maxTotalBytes - total)
-                throw new ZipFailure(4, "Out of memory", "ZIP recovery total byte limit exceeded");
-            if (expanded > limits.maxEntryBytes || compressedSize > limits.maxArchiveBytes || expanded >= 0xffffffff)
-                return undefined;
-            const localLength = end - start, centralLength = 46 + nameLength + centralExtra.length;
-            const tail = zipEnd(1, centralLength, localLength, new Uint8Array());
-            admitCandidate(localLength + centralLength + tail.length);
-            const candidate = new Uint8Array(localLength + centralLength + tail.length);
-            candidate.set(bytes.subarray(start, end));
-            const central = new DataView(candidate.buffer, localLength, centralLength);
-            central.setUint32(0, 0x02014b50, true);
-            central.setUint16(4, 20, true);
-            candidate.set(bytes.subarray(start + 4, start + 14), localLength + 6);
-            central.setUint32(16, crc, true);
-            central.setUint32(20, compressedSize, true);
-            central.setUint32(24, expanded, true);
-            central.setUint16(28, nameLength, true);
-            central.setUint16(30, centralExtra.length, true);
-            candidate.set(bytes.subarray(start + 30, start + 30 + nameLength), localLength + 46);
-            candidate.set(centralExtra, localLength + 46 + nameLength);
-            candidate.set(tail, localLength + centralLength);
-            try {
-                const archive = await readZipArchive(candidate, limits, signal);
-                await verify(archive);
-                return archive.entries[0];
-            }
-            catch (error) {
-                signal.throwIfAborted();
-                if (error instanceof ZipFailure)
-                    throw error;
-                return undefined;
-            }
-        };
-        let end = payload + compressed, entry;
-        if (flags & 8) {
-            const length = wide ? 20 : 12;
-            let matches = 0;
-            for (let offset = payload; offset + length <= bytes.length; offset++) {
-                charge(1);
-                if ((offset - payload) % 4096 === 0)
-                    await yieldTurn(signal);
-                const signed = view.getUint32(offset, true) === 0x08074b50;
-                const base = offset + (signed ? 4 : 0), next = base + length;
-                if (next > bytes.length)
-                    continue;
-                const packed = wide ? view.getBigUint64(base + 4, true) : BigInt(view.getUint32(base + 4, true));
-                const expanded = wide ? view.getBigUint64(base + 12, true) : BigInt(view.getUint32(base + 8, true));
-                if (packed !== BigInt(offset - payload) || Number.isFinite(limits.maxEntryBytes) && expanded > BigInt(limits.maxEntryBytes))
-                    continue;
-                if (compressed && packed !== BigInt(compressed) || size && expanded !== BigInt(size) || checksum && checksum !== view.getUint32(base, true))
-                    continue;
-                // An unknown-size descriptor needs a record boundary, not arbitrary
-                // matching integers embedded in a payload.
-                if (next !== bytes.length && (next + 4 > bytes.length || ![0x04034b50, 0x02014b50, 0x06054b50, 0x06064b50].includes(view.getUint32(next, true))))
-                    continue;
-                const candidateEntry = await attempt(next, Number(packed), Number(expanded), view.getUint32(base, true));
-                if (!candidateEntry)
-                    continue;
-                entry = candidateEntry;
-                end = next;
-                if (++matches > 1) {
-                    partial = true;
-                    entry = undefined;
-                    break;
-                }
-                if (compressed)
-                    break;
-            }
-            // No safe end is known: do not scan that payload for apparent members.
-            if (!entry) {
-                partial = true;
-                if (matches > 1) {
-                    start = end - 1;
-                    continue;
-                }
-                break;
-            }
-        }
-        else {
-            if (end > bytes.length) {
-                partial = true;
-                break;
-            }
-            entry = await attempt(end, compressed, size, checksum);
-        }
-        start = end - 1;
-        if (!entry || names.has(entry.name)) {
-            partial = true;
-            continue;
-        }
-        if (entry.size > limits.maxTotalBytes - total)
-            fail("ZIP recovery total byte limit exceeded");
-        names.add(entry.name);
-        total += entry.size;
-        entries.push(entry);
-    }
-    if (!entries.length)
-        throw new ZipFailure(3, "Zip file structure invalid", "no verified members recovered");
-    return { archive: { entries, comment: new Uint8Array() }, partial };
-}
-/** Adjust a validated SFX using owned bytes; prefix bytes are inert. */
-export async function adjustZipSfx(bytes, archive, limits, signal, password) {
-    const prefix = archive.prefix?.length ?? 0;
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const end = bytes.length - 22 - archive.comment.length;
-    let centralEnd = end, central = end - view.getUint32(end + 12, true);
-    let displacement = central - view.getUint32(end + 16, true);
-    const wide = end >= 20 && view.getUint32(end - 20, true) === 0x07064b50;
-    if (wide) {
-        const declared = Number(view.getBigUint64(end - 12, true));
-        centralEnd = declared;
-        if (declared + 12 > end - 20 || view.getUint32(declared, true) !== 0x06064b50)
-            centralEnd += prefix;
-        displacement = centralEnd - declared;
-        central = Number(view.getBigUint64(centralEnd + 48, true)) + displacement;
-    }
-    if (displacement !== 0 && displacement !== prefix)
-        fail("ZIP inconsistent SFX offsets");
-    for (const entry of archive.entries)
-        for await (const chunk of decodeZipEntry(entry, limits, signal, password)) {
-            void chunk;
-        }
-    const result = new Uint8Array(bytes);
-    const output = new DataView(result.buffer);
-    for (let offset = central; offset < centralEnd;) {
-        await yieldTurn(signal);
-        const local = view.getUint32(offset + 42, true);
-        if (local === 0xffffffff) {
-            const extraStart = offset + 46 + view.getUint16(offset + 28, true);
-            const extraEnd = extraStart + view.getUint16(offset + 30, true);
-            for (let extra = extraStart; extra < extraEnd; extra += 4 + view.getUint16(extra + 2, true)) {
-                if (view.getUint16(extra, true) !== 1)
-                    continue;
-                const position = extra + 4 + (view.getUint32(offset + 24, true) === 0xffffffff ? 8 : 0) + (view.getUint32(offset + 20, true) === 0xffffffff ? 8 : 0);
-                const adjusted = view.getBigUint64(position, true) + BigInt(displacement);
-                if (adjusted > BigInt(Number.MAX_SAFE_INTEGER))
-                    fail("ZIP64 unsafe adjusted offset");
-                output.setBigUint64(position, adjusted, true);
-            }
-        }
-        else {
-            if (local + displacement >= 0xffffffff)
-                fail("ZIP SFX adjusted offset requires ZIP64 promotion");
-            output.setUint32(offset + 42, local + displacement, true);
-        }
-        offset += 46 + view.getUint16(offset + 28, true) + view.getUint16(offset + 30, true) + view.getUint16(offset + 32, true);
-    }
-    if (view.getUint32(end + 16, true) !== 0xffffffff) {
-        if (central >= 0xffffffff)
-            fail("ZIP SFX adjusted directory requires ZIP64 promotion");
-        output.setUint32(end + 16, central, true);
-    }
-    if (wide) {
-        output.setBigUint64(centralEnd + 48, BigInt(central), true);
-        output.setBigUint64(end - 12, BigInt(centralEnd), true);
-    }
-    await readZipArchive(result, limits, signal, { prefix: true });
-    return result;
-}
+export * from "../../../../safe-bash-zip-engine/zip/repair.js";
 //# sourceMappingURL=repair.js.map

package/dist/safe-bash/commands/archive/zip/safety.d.ts

@@ -1,55 +1,2 @@
-import { type ByteSource, type CommandContext, type FileStat, type FileStaging } from "../../../contracts/index.js";
-import { type ArchiveLimits } from "../internal.js";
-export declare function hasZipIdentity(stat: FileStat): boolean;
-export declare function sameZipIdentity(first: FileStat, second: FileStat): boolean;
-export declare function unchangedZipSource(before: FileStat, after: FileStat): boolean;
-export declare function safeZipFile(scope: ZipScope, path: string, stat: FileStat, allowHardlinked?: boolean): Promise<boolean>;
-export declare class ZipScope {
-    private readonly original;
-    readonly limits: ArchiveLimits;
-    readonly context: CommandContext;
-    private readonly controller;
-    private readonly pending;
-    private readonly readers;
-    private readonly closedReason;
-    private drain;
-    private inputDrain;
-    private work;
-    private stdinSource;
-    constructor(original: CommandContext, limits: ArchiveLimits);
-    readonly close: () => Promise<void>;
-    closeInputs(): Promise<void>;
-    operation<Value>(action: () => Value | PromiseLike<Value>): Promise<Value>;
-    stat(path: string): Promise<FileStat | undefined>;
-    get stdin(): ByteSource;
-    source(source: ByteSource, controller?: AbortController): ByteSource;
-    input(path: string, fifo?: boolean, expected?: FileStat): ByteSource;
-}
-export interface ZipPublication {
-    readonly output: string;
-    readonly parent: string;
-    readonly parentName: string;
-    readonly existing: FileStat | undefined;
-    readonly parentStat: FileStat;
-    readonly bytes?: Uint8Array;
-    readonly source?: ByteSource;
-    readonly mtimeMs?: number;
-    readonly stagingName?: string;
-    readonly stagingParent?: string;
-    readonly stagingParentStat?: FileStat;
-    readonly validate?: (path: string) => Promise<void>;
-}
-export interface ZipStaging {
-    readonly stagingPrefix?: string;
-    readonly reservedPath?: string;
-    readonly parent: string;
-    readonly parentStat: FileStat;
-    readonly existing?: FileStat | undefined;
-    readonly bytes?: Uint8Array;
-    readonly source?: ByteSource;
-    readonly mtimeMs?: number;
-}
-/** Own a temporary archive through acquisition, writing, consumption and cleanup. */
-export declare function stageZip(scope: ZipScope, prepared: ZipStaging, consume: (staging: FileStaging) => Promise<void>): Promise<void>;
-export declare function publishZip(scope: ZipScope, prepared: ZipPublication): Promise<void>;
+export * from "../../../../safe-bash-zip-engine/zip/safety.js";
 //# sourceMappingURL=safety.d.ts.map