@poe-platform/safe-bash 0.1.799 → 0.1.801

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

@@ -1,282 +1,2 @@
-import { readBytes } from "../../../contracts/index.js";
-import { yieldTurn } from "../../../contracts/yield.js";
-import { writeFileOutput } from "../../../contracts/filesystem-output.js";
-import { checkPath, fail, hasIdentity, sameIdentity, vfsPath } from "../internal.js";
-import { ZipFailure } from "./options.js";
-import { stageZip } from "./safety.js";
-import { zip64Directory, zip64Fields } from "./zip64.js";
-export function splitSize(value) {
-    if (value === "-")
-        return 0;
-    let end = 0;
-    while (end < value.length && value[end] >= "0" && value[end] <= "9")
-        end++;
-    const unit = value.slice(end).toLowerCase();
-    const factor = { "": 1, k: 1024, m: 1024 ** 2, g: 1024 ** 3, t: 1024 ** 4 }[unit];
-    const raw = Number(value.slice(0, end)) * (factor ?? 0);
-    const size = raw < 1024 ? raw * 1024 ** 2 : raw;
-    if (!end || factor === undefined || !Number.isSafeInteger(size) || size !== 0 && size < 65536)
-        throw new ZipFailure(16, "Invalid command arguments", "split size must be zero or at least 64 KB");
-    return size;
-}
-export function volumeName(archive, disk, disks) {
-    if (!archive.toLowerCase().endsWith(".zip"))
-        fail("split output requires a .zip filename");
-    return disk === disks - 1 ? archive : `${archive.slice(0, -4)}.z${String(disk + 1).padStart(2, "0")}`;
-}
-export function zipEndOffset(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    let found = -1;
-    for (let offset = bytes.length - 22; offset >= Math.max(0, bytes.length - 65557); offset--) {
-        if (view.getUint32(offset, true) === 0x06054b50 && offset + 22 + view.getUint16(offset + 20, true) === bytes.length) {
-            if (found !== -1)
-                fail("ZIP ambiguous end records");
-            found = offset;
-        }
-    }
-    if (found < 0)
-        fail("ZIP missing end record");
-    return found;
-}
-/** Input disks are supplied by the host, then read solely through the invocation VFS. */
-export async function resolveZipVolumes(scope, archive, final, host) {
-    const { fs, signal, cwd } = scope.context;
-    const end = zipEndOffset(final);
-    const view = new DataView(final.buffer, final.byteOffset, final.byteLength);
-    const disk = view.getUint16(end + 4, true);
-    const locator = end >= 20 && view.getUint32(end - 20, true) === 0x07064b50;
-    const count = locator ? view.getUint32(end - 4, true) : disk + 1;
-    if (count === 1 && !disk && !view.getUint16(end + 6, true))
-        return { bytes: final, paths: [archive], ...(view.getUint32(0, true) === 0x08074b50 ? { disks: { starts: [0], lengths: [final.length] } } : {}) };
-    if (!host?.volume)
-        fail("ZIP multi-disk archive requires an explicit VFS volume resolver");
-    if (count < 2 || count > scope.limits.maxMembers || disk !== count - 1)
-        fail("ZIP invalid volume count");
-    const starts = [], lengths = [], paths = [];
-    const stats = [];
-    const finalPath = await scope.operation(() => fs.realpath(archive, { signal }));
-    const finalStat = await scope.stat(finalPath);
-    let total = 0;
-    for (let index = 0; index < count; index++) {
-        const name = index === count - 1 ? finalPath : await scope.operation(() => host.volume({ archive, disk: index, disks: count, signal }));
-        if (!name)
-            fail("ZIP missing input volume");
-        checkPath(name, scope.limits);
-        const path = await scope.operation(() => fs.realpath(vfsPath(cwd, name), { signal }));
-        const stat = index === count - 1 ? finalStat : await scope.stat(path);
-        if (!stat || stat.type !== "file" || !hasIdentity(stat) || stat.nlink !== 1)
-            fail("ZIP volume requires a regular single-link file with known identity");
-        if (index !== count - 1 && path === finalPath || paths.includes(path) || stats.some(other => sameIdentity(stat, other)))
-            fail("ZIP repeated or aliased input volume");
-        if (!Number.isSafeInteger(stat.size) || stat.size < 1 || stat.size > scope.limits.maxArchiveBytes - total)
-            fail("ZIP volume byte limit exceeded");
-        if (index === count - 1 && final.length !== stat.size)
-            fail("ZIP input volume changed while reading");
-        starts.push(total);
-        lengths.push(stat.size);
-        paths.push(path);
-        stats.push(stat);
-        total += stat.size;
-    }
-    // Admit every disk before retaining additional payload, then copy each stream directly
-    // into one owned allocation instead of keeping all disks plus their assembly.
-    if (total > scope.limits.maxInputMemoryBytes - final.buffer.byteLength)
-        fail("ZIP input memory budget exceeded");
-    signal.throwIfAborted();
-    const bytes = new Uint8Array(total);
-    for (let index = 0; index < paths.length; index++) {
-        if (index === count - 1) {
-            bytes.set(final, starts[index]);
-        }
-        else {
-            let size = 0;
-            for await (const chunk of readBytes(scope.input(paths[index]), signal)) {
-                if (chunk.length > lengths[index] - size)
-                    fail("ZIP input volume changed while reading");
-                if (chunk.buffer.byteLength > scope.limits.maxInputMemoryBytes - bytes.byteLength - final.buffer.byteLength)
-                    fail("ZIP input memory budget exceeded");
-                bytes.set(chunk, starts[index] + size);
-                size += chunk.length;
-                await yieldTurn(signal);
-            }
-            if (size !== lengths[index])
-                fail("ZIP input volume changed while reading");
-        }
-        const before = stats[index], after = await scope.stat(paths[index]);
-        if (!after || !sameIdentity(before, after) || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
-            fail("ZIP input volume changed while reading");
-    }
-    // Resolver callbacks and reads may change an earlier disk or the final disk.
-    for (let index = 0; index < paths.length; index++) {
-        const before = stats[index], after = await scope.stat(paths[index]);
-        if (!after || !sameIdentity(before, after) || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
-            fail("ZIP input volume changed while reading");
-    }
-    return { bytes, disks: { starts, lengths }, paths, volumes: paths.map((path, index) => ({ path, stat: stats[index] })) };
-}
-/** Partition a validated single-disk encoding, preserving record boundaries and ciphertext. */
-export async function splitZipVolumes(input, size, limits, signal) {
-    signal.throwIfAborted();
-    if (!Number.isSafeInteger(size) || size < 65536)
-        fail("ZIP invalid split size");
-    if (input.length > limits.maxArchiveBytes - 4)
-        fail("ZIP split archive byte limit exceeded");
-    const view = new DataView(input.buffer, input.byteOffset, input.byteLength);
-    const end = zipEndOffset(input);
-    const directory = zip64Directory(view, end, limits);
-    const records = [], central = [];
-    let offset = directory.centralStart;
-    for (let index = 0; index < directory.members; index++) {
-        signal.throwIfAborted();
-        if (offset + 46 > directory.centralEnd || view.getUint32(offset, true) !== 0x02014b50)
-            fail("ZIP invalid central record");
-        const name = view.getUint16(offset + 28, true), extra = view.getUint16(offset + 30, true), comment = view.getUint16(offset + 32, true);
-        const next = offset + 46 + name + extra + comment;
-        if (next > directory.centralEnd)
-            fail("ZIP truncated central record");
-        let zip64, extraOffset;
-        for (let field = offset + 46 + name; field < next - comment;) {
-            if (field + 4 > next - comment)
-                fail("ZIP truncated extra field");
-            const finish = field + 4 + view.getUint16(field + 2, true);
-            if (finish > next - comment)
-                fail("ZIP truncated extra field");
-            if (view.getUint16(field, true) === 1) {
-                zip64 = input.subarray(field + 4, finish);
-                extraOffset = field + 4;
-            }
-            field = finish;
-        }
-        const raw = [view.getUint32(offset + 24, true), view.getUint32(offset + 20, true), view.getUint32(offset + 42, true)];
-        const values = zip64Fields(zip64, raw);
-        const local = values[2];
-        if (local + 30 > directory.centralStart || view.getUint32(local, true) !== 0x04034b50)
-            fail("ZIP invalid local record");
-        const payload = local + 30 + view.getUint16(local + 26, true) + view.getUint16(local + 28, true);
-        records.push({ start: local, end: payload }, { start: offset, end: next });
-        if (view.getUint16(local + 6, true) & 8) {
-            const descriptor = payload + values[1];
-            const wide = view.getUint32(local + 18, true) === 0xffffffff || view.getUint32(local + 22, true) === 0xffffffff;
-            records.push({ start: descriptor, end: descriptor + (view.getUint32(descriptor, true) === 0x08074b50 ? 4 : 0) + (wide ? 20 : 12) });
-        }
-        central.push({ start: offset, local, ...(raw[2] === 0xffffffff && extraOffset !== undefined ? { extraOffset: extraOffset + (raw[0] === 0xffffffff ? 8 : 0) + (raw[1] === 0xffffffff ? 8 : 0) } : {}) });
-        offset = next;
-        await yieldTurn(signal);
-    }
-    if (directory.centralEnd !== end)
-        records.push({ start: directory.centralEnd, end: end - 20 }, { start: end - 20, end });
-    records.push({ start: end, end: input.length });
-    records.sort((a, b) => a.start - b.start);
-    const starts = [0];
-    let source = 0, used = 4;
-    for (const record of records) {
-        if (record.start < source || record.end > input.length || record.end - record.start > size)
-            fail("ZIP record cannot fit in split volume");
-        while (record.start - source >= size - used && record.start > source) {
-            source += size - used;
-            starts.push(source);
-            used = 0;
-        }
-        used += record.start - source;
-        source = record.start;
-        if (record.end - record.start > size - used) {
-            starts.push(source);
-            used = 0;
-        }
-        used += record.end - source;
-        source = record.end;
-    }
-    if (starts.length > limits.maxMembers || starts.length >= 65535)
-        fail("ZIP split volume count limit exceeded");
-    const parts = starts.map((start, index) => new Uint8Array((starts[index + 1] ?? input.length) - start + (index === 0 ? 4 : 0)));
-    new DataView(parts[0].buffer).setUint32(0, 0x08074b50, true);
-    for (let index = 0; index < parts.length; index++) {
-        const finish = starts[index + 1] ?? input.length;
-        for (let pos = starts[index]; pos < finish; pos += limits.chunkSize) {
-            signal.throwIfAborted();
-            parts[index].set(input.subarray(pos, Math.min(finish, pos + limits.chunkSize)), pos - starts[index] + (index === 0 ? 4 : 0));
-            await yieldTurn(signal);
-        }
-    }
-    const location = (position) => {
-        let disk = starts.length - 1;
-        while (starts[disk] > position)
-            disk--;
-        return { disk, relative: position - starts[disk] + (disk === 0 ? 4 : 0) };
-    };
-    for (const record of central) {
-        const here = location(record.start), local = location(record.local);
-        const header = new DataView(parts[here.disk].buffer);
-        header.setUint16(here.relative + 34, local.disk, true);
-        if (record.extraOffset === undefined)
-            header.setUint32(here.relative + 42, local.relative, true);
-        else
-            header.setBigUint64(here.relative + record.extraOffset - record.start, BigInt(local.relative), true);
-    }
-    const last = parts.length - 1, finish = location(end), centralStart = location(directory.centralStart);
-    const header = new DataView(parts[last].buffer);
-    const onLast = central.filter(record => location(record.start).disk === last).length;
-    header.setUint16(finish.relative + 4, last, true);
-    header.setUint16(finish.relative + 6, centralStart.disk, true);
-    header.setUint16(finish.relative + 8, Math.min(onLast, 65535), true);
-    if (view.getUint32(end + 16, true) !== 0xffffffff)
-        header.setUint32(finish.relative + 16, centralStart.relative, true);
-    if (directory.centralEnd !== end) {
-        const wide = location(directory.centralEnd);
-        const wideHeader = new DataView(parts[wide.disk].buffer);
-        const onWide = central.filter(record => location(record.start).disk === wide.disk).length;
-        wideHeader.setUint32(wide.relative + 16, wide.disk, true);
-        wideHeader.setUint32(wide.relative + 20, centralStart.disk, true);
-        wideHeader.setBigUint64(wide.relative + 24, BigInt(onWide), true);
-        wideHeader.setBigUint64(wide.relative + 48, BigInt(centralStart.relative), true);
-        const locator = location(end - 20), locatorHeader = new DataView(parts[locator.disk].buffer);
-        locatorHeader.setUint32(locator.relative + 4, wide.disk, true);
-        locatorHeader.setBigUint64(locator.relative + 8, BigInt(wide.relative), true);
-        locatorHeader.setUint32(locator.relative + 16, parts.length, true);
-    }
-    return parts;
-}
-/** All destinations preflight; all volumes staged before the first per-volume publication. */
-export async function publishZipVolumes(scope, publication, parts, inputPaths, before) {
-    const { fs, signal } = scope.context;
-    if (!fs.publishStagedFile)
-        fail("ZIP split publication requires atomic owned staging");
-    const destinations = [];
-    const forbidden = new Set(inputPaths);
-    const inputStats = await Promise.all(inputPaths.map(path => scope.stat(path)));
-    for (let disk = 0; disk < parts.length; disk++) {
-        const output = volumeName(publication.output, disk, parts.length);
-        checkPath(output, scope.limits);
-        if (forbidden.has(output))
-            fail("ZIP split output aliases an input volume");
-        const existing = await scope.stat(output);
-        if (existing && (existing.type !== "file" || !hasIdentity(existing) || existing.nlink !== 1 || inputStats.some(stat => stat && sameIdentity(stat, existing))))
-            fail("ZIP split destination is not a safe regular file");
-        const capabilities = await scope.operation(() => fs.capabilitiesFor?.(output, { signal, create: true }) ?? fs.capabilities);
-        if ((capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true))
-            fail("ZIP split publication requires atomic owned staging");
-        destinations.push({ ...publication, output, existing, bytes: parts[disk] });
-    }
-    const staged = [];
-    const stage = async (disk) => {
-        if (disk < destinations.length) {
-            const prepared = destinations[disk];
-            await writeFileOutput(scope.context, prepared.bytes, () => stageZip(scope, { ...prepared, stagingPrefix: `zip-volume-${disk + 1}`, reservedPath: prepared.output, parent: prepared.stagingParent ?? prepared.parent, parentStat: prepared.stagingParentStat ?? prepared.parentStat }, async (value) => {
-                staged.push(value);
-                await before(prepared.output, disk);
-                await stage(disk + 1);
-            }));
-            return;
-        }
-        if (await scope.operation(() => fs.realpath(publication.parentName, { signal })) !== publication.parent)
-            fail("ZIP split parent changed before publication");
-        if (publication.stagingName && await scope.operation(() => fs.realpath(publication.stagingName, { signal })) !== publication.stagingParent)
-            fail("ZIP split staging parent changed before publication");
-        for (let index = 0; index < staged.length; index++) {
-            const prepared = destinations[index];
-            await scope.operation(() => fs.publishStagedFile(staged[index], prepared.output, { signal, parent: prepared.parentStat, destination: prepared.existing ?? null }));
-        }
-    };
-    await stage(0);
-}
+export * from "../../../../safe-bash-zip-engine/zip/volumes.js";
 //# sourceMappingURL=volumes.js.map

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

@@ -1,31 +1,2 @@
-import { type ArchiveLimits } from "../internal.js";
-export interface ZipDisks {
-    readonly starts: readonly number[];
-    readonly lengths: readonly number[];
-}
-export declare function zipDiskRecord(disks: ZipDisks | undefined, start: number, end: number): void;
-export declare function zipDiskOffset(disks: ZipDisks | undefined, disk: number, offset: number): number;
-export declare function zip64Directory(view: DataView, end: number, limits: ArchiveLimits, disks?: ZipDisks, displacement?: number): {
-    members: number;
-    centralStart: number;
-    centralSize: number;
-    centralEnd: number;
-    diskMembers: number;
-    disk: number;
-    zip64Disk: number;
-    zip64DiskMembers: number;
-};
-export declare function zip64Fields(data: Uint8Array | undefined, values: readonly number[]): number[];
-export declare function stripZip64(bytes: Uint8Array): Uint8Array;
-export declare function zip64Extra(values: readonly number[], retained: Uint8Array): Uint8Array;
-export declare function writeZip64End(view: DataView, offset: number, count: number, size: number, start: number, recordOffset?: number): number;
-export declare function zip64Member(size: number, compressed: number, offset: number, force?: boolean, allowed?: boolean, forceSizes?: boolean): {
-    size: number;
-    compressed: number;
-    offset: number;
-    values: number[];
-    wide: boolean;
-};
-export declare function zipEnd(count: number, size: number, start: number, comment: Uint8Array, force?: boolean, allowed?: boolean): Uint8Array;
-export declare function zipDescriptor(checksum: number, compressed: number, size: number, wide: boolean, signed?: boolean): Uint8Array;
+export * from "../../../../safe-bash-zip-engine/zip/zip64.js";
 //# sourceMappingURL=zip64.d.ts.map

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

@@ -1,228 +1,2 @@
-import { fail } from "../internal.js";
-function wide(view, offset) {
-    if (offset < 0 || offset + 8 > view.byteLength)
-        fail("ZIP64 truncated numeric field");
-    const value = view.getBigUint64(offset, true);
-    if (value > BigInt(Number.MAX_SAFE_INTEGER))
-        fail("ZIP64 unsafe numeric field");
-    return Number(value);
-}
-export function zipDiskRecord(disks, start, end) {
-    if (!disks)
-        return;
-    let disk = disks.starts.length - 1;
-    while (disk >= 0 && disks.starts[disk] > start)
-        disk--;
-    if (disk < 0 || end > disks.starts[disk] + disks.lengths[disk])
-        fail("ZIP record straddles volume boundary");
-}
-export function zipDiskOffset(disks, disk, offset) {
-    if (!Number.isSafeInteger(disk) || disk < 0 || !Number.isSafeInteger(offset) || offset < 0)
-        fail("ZIP invalid disk offset");
-    if (!disks) {
-        if (disk)
-            fail("ZIP multi-disk archive requires a volume resolver");
-        return offset;
-    }
-    if (disk >= disks.starts.length || offset >= disks.lengths[disk])
-        fail("ZIP disk offset outside volume");
-    return disks.starts[disk] + offset;
-}
-export function zip64Directory(view, end, limits, disks, displacement = 0) {
-    zipDiskRecord(disks, end, view.byteLength);
-    let members = view.getUint16(end + 10, true);
-    let centralSize = view.getUint32(end + 12, true);
-    let centralStart = view.getUint32(end + 16, true);
-    let centralEnd = end;
-    let zip64Disk = -1, zip64DiskMembers = -1;
-    let diskMembers = view.getUint16(end + 8, true);
-    const disk = view.getUint16(end + 4, true);
-    if (!disks && disk)
-        fail("ZIP multi-disk archive requires a volume resolver");
-    const centralDisk = view.getUint16(end + 6, true);
-    if (disks && disk !== disks.starts.length - 1)
-        fail("ZIP final disk number mismatch");
-    if (centralStart !== 0xffffffff)
-        centralStart = zipDiskOffset(disks, centralDisk, centralStart);
-    if (centralStart !== 0xffffffff)
-        centralStart += displacement;
-    const locator = end >= 20 && view.getUint32(end - 20, true) === 0x07064b50;
-    if (locator) {
-        zipDiskRecord(disks, end - 20, end);
-        const recordDisk = view.getUint32(end - 16, true);
-        if (view.getUint32(end - 4, true) !== (disks?.starts.length ?? 1))
-            fail("ZIP64 multi-disk locator count mismatch");
-        centralEnd = zipDiskOffset(disks, recordDisk, wide(view, end - 12)) + displacement;
-        if (centralEnd > end - 76 || view.getUint32(centralEnd, true) !== 0x06064b50)
-            fail("ZIP64 invalid end-record span");
-        const length = wide(view, centralEnd + 4);
-        if (length < 44 || length - 44 > limits.maxPaxBytes || length !== end - 32 - centralEnd)
-            fail("ZIP64 invalid end-record length");
-        zipDiskRecord(disks, centralEnd, centralEnd + 12 + length);
-        const version = view.getUint16(centralEnd + 14, true);
-        if (version < 45 || version > 46)
-            fail("ZIP64 unsupported end-record extraction version");
-        if (view.getUint32(centralEnd + 16, true) !== recordDisk || view.getUint32(centralEnd + 20, true) !== centralDisk)
-            fail("ZIP64 inconsistent disk numbers");
-        const count = wide(view, centralEnd + 32);
-        const wideDiskMembers = wide(view, centralEnd + 24);
-        if (wideDiskMembers > count || recordDisk === disk && wideDiskMembers !== diskMembers && diskMembers !== 65535 || members !== 65535 && members !== count || !disks && wideDiskMembers !== count)
-            fail("ZIP64 inconsistent member count");
-        if (recordDisk === disk)
-            diskMembers = wideDiskMembers;
-        zip64Disk = recordDisk;
-        zip64DiskMembers = wideDiskMembers;
-        const size = wide(view, centralEnd + 40);
-        const start = zipDiskOffset(disks, centralDisk, wide(view, centralEnd + 48)) + displacement;
-        if (centralSize !== 0xffffffff && centralSize !== size || centralStart !== 0xffffffff && centralStart !== start)
-            fail("ZIP64 inconsistent central directory");
-        members = count;
-        centralSize = size;
-        centralStart = start;
-    }
-    else if (centralSize === 0xffffffff || centralStart === 0xffffffff)
-        fail("ZIP64 missing end record and locator");
-    else if (!disks && diskMembers !== members)
-        fail("ZIP inconsistent member count");
-    if (members > limits.maxMembers)
-        fail("ZIP member limit exceeded");
-    if (centralStart > limits.maxArchiveBytes || centralSize > limits.maxArchiveBytes || centralSize !== centralEnd - centralStart)
-        fail("ZIP invalid central directory span");
-    return { members, centralStart, centralSize, centralEnd, diskMembers, disk, zip64Disk, zip64DiskMembers };
-}
-export function zip64Fields(data, values) {
-    let offset = 0;
-    const view = data && new DataView(data.buffer, data.byteOffset, data.byteLength);
-    return values.map((value, index) => {
-        if (value !== 0xffffffff)
-            return value;
-        if (!view)
-            fail("ZIP64 missing required extra field");
-        const width = index === 3 ? 4 : 8;
-        if (offset + width > view.byteLength)
-            fail("ZIP64 truncated extra field");
-        const resolved = width === 4 ? view.getUint32(offset, true) : wide(view, offset);
-        offset += width;
-        return resolved;
-    });
-}
-export function stripZip64(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const retained = [];
-    let length = 0;
-    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 payload");
-        if (view.getUint16(offset, true) !== 1) {
-            retained.push(bytes.subarray(offset, next));
-            length += next - offset;
-        }
-        offset = next;
-    }
-    const result = new Uint8Array(length);
-    let offset = 0;
-    for (const field of retained) {
-        result.set(field, offset);
-        offset += field.length;
-    }
-    return result;
-}
-export function zip64Extra(values, retained) {
-    values.forEach(counter);
-    if (retained.length + 4 + values.length * 8 > 65535)
-        fail("ZIP64 extra field limit exceeded");
-    const bytes = new Uint8Array(4 + values.length * 8 + retained.length);
-    const view = new DataView(bytes.buffer);
-    view.setUint16(0, 1, true);
-    view.setUint16(2, values.length * 8, true);
-    values.forEach((value, index) => view.setBigUint64(4 + index * 8, BigInt(value), true));
-    bytes.set(retained, 4 + values.length * 8);
-    return bytes;
-}
-export function writeZip64End(view, offset, count, size, start, recordOffset = offset) {
-    [offset, count, size, start, recordOffset].forEach(counter);
-    if (offset > view.byteLength - 76)
-        fail("ZIP64 truncated end-record destination");
-    view.setUint32(offset, 0x06064b50, true);
-    view.setBigUint64(offset + 4, 44n, true);
-    view.setUint16(offset + 12, 0x32d, true);
-    view.setUint16(offset + 14, 45, true);
-    view.setUint32(offset + 16, 0, true);
-    view.setUint32(offset + 20, 0, true);
-    view.setBigUint64(offset + 24, BigInt(count), true);
-    view.setBigUint64(offset + 32, BigInt(count), true);
-    view.setBigUint64(offset + 40, BigInt(size), true);
-    view.setBigUint64(offset + 48, BigInt(start), true);
-    view.setUint32(offset + 56, 0x07064b50, true);
-    view.setUint32(offset + 60, 0, true);
-    view.setBigUint64(offset + 64, BigInt(recordOffset), true);
-    view.setUint32(offset + 72, 1, true);
-    return offset + 76;
-}
-function counter(value) {
-    if (!Number.isSafeInteger(value) || value < 0)
-        fail("ZIP64 unsafe or invalid numeric field");
-}
-export function zip64Member(size, compressed, offset, force = false, allowed = true, forceSizes = false) {
-    [size, compressed, offset].forEach(counter);
-    const widths = [size, compressed, offset].map((value, index) => force || forceSizes && index < 2 || value >= 0xffffffff);
-    if (!allowed && widths.some(Boolean))
-        fail("ZIP64 required but disabled");
-    return {
-        size: widths[0] ? 0xffffffff : size,
-        compressed: widths[1] ? 0xffffffff : compressed,
-        offset: widths[2] ? 0xffffffff : offset,
-        values: [size, compressed, offset].filter((_, index) => widths[index]),
-        wide: widths.some(Boolean),
-    };
-}
-export function zipEnd(count, size, start, comment, force = false, allowed = true) {
-    [count, size, start].forEach(counter);
-    if (size > Number.MAX_SAFE_INTEGER - start)
-        fail("ZIP64 unsafe directory sum");
-    if (comment.length > 65535)
-        fail("ZIP archive comment limit exceeded");
-    const wide = force || count >= 65535 || size >= 0xffffffff || start >= 0xffffffff;
-    if (wide && !allowed)
-        fail("ZIP64 required but disabled");
-    const length = (wide ? 76 : 0) + 22 + comment.length;
-    if (start + size > Number.MAX_SAFE_INTEGER - length)
-        fail("ZIP64 unsafe archive sum");
-    const bytes = new Uint8Array(length);
-    const view = new DataView(bytes.buffer);
-    const end = wide ? writeZip64End(view, 0, count, size, start, start + size) : 0;
-    view.setUint32(end, 0x06054b50, true);
-    view.setUint16(end + 8, Math.min(count, 65535), true);
-    view.setUint16(end + 10, Math.min(count, 65535), true);
-    view.setUint32(end + 12, size >= 0xffffffff ? 0xffffffff : size, true);
-    view.setUint32(end + 16, start >= 0xffffffff ? 0xffffffff : start, true);
-    view.setUint16(end + 20, comment.length, true);
-    bytes.set(comment, end + 22);
-    return bytes;
-}
-export function zipDescriptor(checksum, compressed, size, wide, signed = true) {
-    [checksum, compressed, size].forEach(counter);
-    if (checksum > 0xffffffff)
-        fail("ZIP invalid descriptor checksum");
-    if (!wide && (compressed >= 0xffffffff || size >= 0xffffffff))
-        fail("ZIP64 descriptor required");
-    const bytes = new Uint8Array((signed ? 4 : 0) + (wide ? 20 : 12));
-    const view = new DataView(bytes.buffer);
-    const base = signed ? 4 : 0;
-    if (signed)
-        view.setUint32(0, 0x08074b50, true);
-    view.setUint32(base, checksum, true);
-    if (wide) {
-        view.setBigUint64(base + 4, BigInt(compressed), true);
-        view.setBigUint64(base + 12, BigInt(size), true);
-    }
-    else {
-        view.setUint32(base + 4, compressed, true);
-        view.setUint32(base + 8, size, true);
-    }
-    return bytes;
-}
+export * from "../../../../safe-bash-zip-engine/zip/zip64.js";
 //# sourceMappingURL=zip64.js.map

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

@@ -1,69 +1,2 @@
-import { type ZipDisks } from "./zip/zip64.js";
-import { type ZipEncryption } from "./zip/crypto.js";
-import { type ZipAes } from "./zip/aes.js";
-import { type ByteSource } from "../../contracts/index.js";
-import { type ArchiveLimits } from "./internal.js";
-export interface ZipEntry {
-    aes?: ZipAes & {
-        readonly method: number;
-    };
-    /** Encrypt new plaintext/compressed data; retained encrypted entries omit this. */
-    encryption?: ZipEncryption;
-    name: string;
-    data: Uint8Array;
-    size: number;
-    method: number;
-    crc32: number;
-    modified: Date;
-    mode: number;
-    directory: boolean;
-    symlink: boolean;
-    zip64?: boolean;
-    descriptors?: boolean;
-    rawName?: Uint8Array;
-    localName?: Uint8Array;
-    comment?: Uint8Array;
-    localExtra?: Uint8Array;
-    centralExtra?: Uint8Array;
-    flags?: number;
-    versionMadeBy?: number;
-    internalAttributes?: number;
-    externalAttributes?: number;
-    dosTime?: number;
-    dosDate?: number;
-    /** Live, uncompressed input. Consumed once; data is empty for this profile. */
-    source?: ByteSource;
-    level?: number;
-    expectedSize?: number;
-    compressedSize?: number;
-}
-export interface ZipArchive {
-    entries: readonly ZipEntry[];
-    comment: Uint8Array;
-    /** Inert SFX bytes, never interpreted or executed. */
-    prefix?: Uint8Array;
-    /** Serialized metadata retained and conservative input-slab admission bytes;
-     * excludes codec workspace, provider storage and caller-owned input. */
-    onRetention?: (counters: Readonly<{
-        metadataBytes: number;
-        payloadBytes: number;
-    }>) => void;
-}
-export declare function crc32(bytes: Uint8Array, previous?: number): number;
-export declare function readZipArchive(bytes: Uint8Array, limits: ArchiveLimits, signal: AbortSignal, profile?: Readonly<{
-    grow?: boolean;
-    prefix?: boolean;
-    disks?: ZipDisks;
-}>): Promise<ZipArchive>;
-export declare function decodeZipEntry(entry: ZipEntry, limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): ByteSource;
-export declare function makeZipEntry(name: string, bytes: Uint8Array, attributes: {
-    modified: Date;
-    mode: number;
-    directory: boolean;
-    symlink: boolean;
-}, limits: ArchiveLimits, signal: AbortSignal, level?: number, forceCompression?: boolean, method?: "deflate" | "bzip2" | "lzma"): Promise<ZipEntry>;
-export declare function updateZipExtras(entry: ZipEntry, previous: ZipEntry | undefined, mode: "strip" | "all", limits: ArchiveLimits): ZipEntry;
-export declare function setZipEntryComment(entry: ZipEntry, comment: Uint8Array, limits: ArchiveLimits): ZipEntry;
-export declare function streamZipArchive(archive: ZipArchive, limits: ArchiveLimits, signal: AbortSignal, descriptors?: boolean, forceZip64?: boolean, allowZip64?: boolean): ByteSource;
-export declare function writeZipArchive(archive: ZipArchive, limits: ArchiveLimits, signal: AbortSignal, descriptors?: boolean, forceZip64?: boolean, allowZip64?: boolean): Promise<Uint8Array>;
+export * from "../../../safe-bash-zip-engine/zip-format.js";
 //# sourceMappingURL=zip-format.d.ts.map