@poe-platform/safe-bash 0.1.798 → 0.1.800

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

@@ -1,361 +1,2 @@
-import { readBytes } from "../../../contracts/index.js";
-import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
-import { writeFileOutput } from "../../../contracts/filesystem-output.js";
-import { checkPath, fail, hasIdentity as hasPosixIdentity, sameIdentity as samePosixIdentity } from "../internal.js";
-export function hasZipIdentity(stat) {
-    return hasPosixIdentity(stat) || ((typeof stat.identityScope === "object" && stat.identityScope !== null || typeof stat.identityScope === "symbol")
-        && typeof stat.opaqueIdentity === "string" && stat.opaqueIdentity.length > 0 && stat.opaqueIdentity.length <= 4096
-        && hasZipVersion(stat));
-}
-function hasZipVersion(stat) {
-    return typeof stat.opaqueVersion === "string" && stat.opaqueVersion.length > 0 && stat.opaqueVersion.length <= 4096;
-}
-export function sameZipIdentity(first, second) {
-    return samePosixIdentity(first, second) || hasZipIdentity(first) && hasZipIdentity(second)
-        && first.opaqueIdentity !== undefined && first.identityScope === second.identityScope && first.opaqueIdentity === second.opaqueIdentity;
-}
-export function unchangedZipSource(before, after) {
-    return before.type === after.type && before.size === after.size && before.mode === after.mode
-        && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs
-        && before.nlink === after.nlink && before.opaqueVersion === after.opaqueVersion && before.revision === after.revision
-        && (!hasZipIdentity(before) || sameZipIdentity(before, after));
-}
-export async function safeZipFile(scope, path, stat, allowHardlinked = false) {
-    if (stat.type !== "file" || !hasZipIdentity(stat))
-        return false;
-    if (stat.nlink !== undefined) {
-        if (stat.nlink === 1)
-            return true;
-        if (!allowHardlinked || stat.nlink < 1 || !hasPosixIdentity(stat))
-            return false;
-        const capabilities = await scope.operation(() => scope.context.fs.capabilitiesFor?.(path, { signal: scope.context.signal }) ?? scope.context.fs.capabilities);
-        return capabilities.hardlinks === true && capabilities.atomicFileMutation === true && typeof scope.context.fs.writeFileConditional === "function";
-    }
-    const capabilities = await scope.operation(() => scope.context.fs.capabilitiesFor?.(path, { signal: scope.context.signal }) ?? scope.context.fs.capabilities);
-    return stat.opaqueIdentity !== undefined && capabilities.hardlinks === false;
-}
-export class ZipScope {
-    original;
-    limits;
-    context;
-    controller = new AbortController();
-    pending = new Set();
-    readers = new Set();
-    closedReason = new Error("ZIP command is closed");
-    drain;
-    inputDrain;
-    work = 0;
-    stdinSource;
-    constructor(original, limits) {
-        this.original = original;
-        this.limits = limits;
-        this.context = { ...original, signal: AbortSignal.any([original.signal, this.controller.signal]) };
-        original.registerCleanup?.(this.close);
-    }
-    close = () => {
-        if (!this.drain) {
-            this.drain = Promise.resolve().then(async () => {
-                while (this.pending.size)
-                    await Promise.allSettled([...this.pending]);
-                await this.closeInputs();
-            });
-            this.controller.abort(this.original.signal.aborted ? this.original.signal.reason : this.closedReason);
-        }
-        return this.drain;
-    };
-    closeInputs() {
-        return this.inputDrain ??= Promise.allSettled([...this.readers].map(close => close())).then(results => {
-            const failures = results.filter(result => result.status === "rejected").map(result => result.reason);
-            if (failures.length === 1)
-                throw failures[0];
-            if (failures.length)
-                throw new AggregateError(failures, "ZIP reader cleanup failed");
-        });
-    }
-    async operation(action) {
-        this.context.signal.throwIfAborted();
-        if (++this.work > this.limits.maxPatternSteps)
-            fail("filesystem work limit exceeded");
-        const pending = Promise.resolve().then(() => { this.context.signal.throwIfAborted(); return action(); });
-        this.pending.add(pending);
-        try {
-            const value = await pending;
-            this.context.signal.throwIfAborted();
-            return value;
-        }
-        finally {
-            this.pending.delete(pending);
-        }
-    }
-    async stat(path) {
-        try {
-            return await this.operation(() => this.context.fs.lstat(path, { signal: this.context.signal }));
-        }
-        catch (error) {
-            this.context.signal.throwIfAborted();
-            if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
-                return undefined;
-            throw error;
-        }
-    }
-    get stdin() {
-        return this.stdinSource ??= this.source(this.original.stdin);
-    }
-    source(source, controller) {
-        if (this.inputDrain)
-            fail("ZIP inputs are closed");
-        const iterator = source[Symbol.asyncIterator]();
-        let closing;
-        const close = () => closing ??= (async () => {
-            controller?.abort(this.closedReason);
-            try {
-                await iterator.return?.();
-            }
-            finally {
-                this.readers.delete(close);
-            }
-        })();
-        this.readers.add(close);
-        return { [Symbol.asyncIterator]: () => ({
-                next: () => this.operation(async () => {
-                    const result = await iterator.next();
-                    if (result.done)
-                        this.readers.delete(close);
-                    return result;
-                }),
-                async return() { await close(); return { done: true, value: undefined }; },
-            }) };
-    }
-    async *input(path, fifo = false, expected) {
-        const { fs } = this.context;
-        if (expected) {
-            if (!hasZipIdentity(expected))
-                fail("ZIP source requires known backing identity");
-            const controller = new AbortController();
-            const signal = AbortSignal.any([this.context.signal, controller.signal]);
-            let handle;
-            let acquisition;
-            let reading;
-            let closing;
-            const close = () => closing ??= (async () => {
-                controller.abort(this.closedReason);
-                try {
-                    await acquisition?.catch(() => { });
-                    await reading?.catch(() => { });
-                    await handle?.close();
-                }
-                finally {
-                    this.readers.delete(close);
-                }
-            })();
-            if (this.inputDrain)
-                fail("ZIP inputs are closed");
-            this.readers.add(close);
-            try {
-                await (acquisition = this.operation(async () => {
-                    const capabilities = await (fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
-                    signal.throwIfAborted();
-                    if (capabilities.retainedRead !== true || !fs.openReadFile)
-                        fail("ZIP source requires retained reads");
-                    handle = await fs.openReadFile(path, { signal });
-                }));
-                if (this.inputDrain)
-                    fail("ZIP inputs are closed");
-                const stat = await (reading = this.operation(() => handle.stat({ signal })));
-                if (!unchangedZipSource(expected, stat))
-                    fail(`source changed while opening: ${path}`);
-                let position = 0;
-                while (position < expected.size) {
-                    const size = Math.min(this.limits.chunkSize, expected.size - position);
-                    signal.throwIfAborted();
-                    const bytes = await (reading = this.operation(() => handle.read(position, size, { signal })));
-                    signal.throwIfAborted();
-                    if (!bytes.length || bytes.length > size)
-                        fail(`source changed while reading: ${path}`);
-                    position += bytes.length;
-                    yield bytes;
-                }
-                signal.throwIfAborted();
-                const current = await (reading = this.operation(() => handle.stat({ signal })));
-                if (!unchangedZipSource(expected, current))
-                    fail(`source changed while reading: ${path}`);
-            }
-            finally {
-                await close();
-            }
-            return;
-        }
-        const controller = new AbortController();
-        const signal = AbortSignal.any([this.context.signal, controller.signal]);
-        const capabilities = await this.operation(() => fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
-        if (fifo && (!fs.readStream || capabilities.streamingRead !== true))
-            fail("filesystem lacks explicit FIFO byte stream capability");
-        if (fs.readStream && capabilities.streamingRead !== false) {
-            const source = await this.operation(() => this.source(fs.readStream(path, { signal, chunkSize: this.limits.chunkSize }), controller));
-            yield* readBytes(source, signal);
-        }
-        else {
-            const stat = await this.operation(() => fs.stat(path, { signal }));
-            if (stat.size > this.limits.maxBufferedFileBytes)
-                fail("filesystem lacks streaming reads: buffered file limit exceeded");
-            const bytes = await this.operation(() => fs.readFile(path, { signal, ...(Number.isFinite(this.limits.maxBufferedFileBytes) ? { maxBytes: this.limits.maxBufferedFileBytes } : {}) }));
-            if (bytes.length > this.limits.maxBufferedFileBytes)
-                fail("buffered file limit exceeded");
-            yield bytes;
-        }
-    }
-}
-/** Own a temporary archive through acquisition, writing, consumption and cleanup. */
-export async function stageZip(scope, prepared, consume) {
-    const { fs, signal } = scope.context;
-    const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.parent, { signal }) ?? fs.capabilities);
-    if ((capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true) || !fs.createStagedFile || !fs.removeStagedFile)
-        fail("ZIP temporary path requires atomic owned file staging");
-    if (prepared.source && ((capabilities.atomicFileMutation !== true && capabilities.trustedOwnedStaging !== true) || !fs.writeFileConditional))
-        fail("ZIP temporary path requires atomic conditional writes");
-    let staging;
-    let failure;
-    const close = retainFileSystemCleanup(fs, async (cleanup) => {
-        if (staging) {
-            if (!cleanup.removeStagedFile)
-                fail("ZIP atomic cleanup unavailable");
-            await cleanup.removeStagedFile(staging);
-        }
-    }, { maxOperations: 16 });
-    try {
-        for (let attempt = 0; attempt < scope.limits.maxMembers; attempt++) {
-            const path = `${prepared.parent === "/" ? "" : prepared.parent}/.${prepared.stagingPrefix ?? "zip"}-${attempt + 1}`;
-            checkPath(path, scope.limits);
-            checkPath(`${path}/archive.zip`, scope.limits);
-            if (path === prepared.reservedPath)
-                continue;
-            try {
-                await scope.operation(async () => {
-                    staging = await fs.createStagedFile(path, "archive.zip", { type: "file", data: prepared.bytes ?? new Uint8Array() }, {
-                        signal, parent: prepared.parentStat, ...(prepared.existing ? { mode: prepared.existing.mode & 0o7777 } : {}),
-                        ...(prepared.mtimeMs === undefined ? {} : { mtimeMs: prepared.mtimeMs, atimeMs: prepared.mtimeMs }),
-                    });
-                });
-                break;
-            }
-            catch (error) {
-                signal.throwIfAborted();
-                if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST")
-                    throw error;
-            }
-        }
-        if (!staging)
-            fail("ZIP temporary directory attempt limit exceeded");
-        if (prepared.source) {
-            for await (const chunk of readBytes(prepared.source, signal)) {
-                try {
-                    await writeFileOutput(scope.context, chunk, bytes => scope.operation(async () => {
-                        const stat = await fs.writeFileConditional(staging.file.path, bytes, {
-                            signal, parent: staging.directory.stat, expected: staging.file.stat, append: true,
-                        });
-                        staging = { ...staging, file: { path: staging.file.path, stat } };
-                    }));
-                }
-                catch (error) {
-                    void scope.closeInputs().catch(() => { });
-                    throw error;
-                }
-            }
-        }
-        if (prepared.mtimeMs !== undefined && (staging.file.stat.mtimeMs !== prepared.mtimeMs || staging.file.stat.atimeMs !== prepared.mtimeMs))
-            fail("ZIP staging did not retain archive modification time");
-        await consume(staging);
-    }
-    catch (error) {
-        failure = { reason: error };
-    }
-    try {
-        await close();
-    }
-    catch (error) {
-        if (failure)
-            throw new AggregateError([failure.reason, error], "ZIP publication and cleanup failed");
-        throw error;
-    }
-    if (failure)
-        throw failure.reason;
-}
-export async function publishZip(scope, prepared) {
-    const { fs, signal } = scope.context;
-    const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.output, { signal, create: true }) ?? fs.capabilities);
-    if (capabilities.atomicFilePublication === true && fs.publishFileConditional && !prepared.validate && prepared.stagingName === undefined) {
-        if (capabilities.readOnly === true || capabilities.write === false)
-            fail("ZIP destination is not writable");
-        if (prepared.existing && (!hasZipIdentity(prepared.existing) || !hasZipVersion(prepared.existing)))
-            fail("ZIP conditional publication requires an observed opaque version");
-        const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
-        if (parent !== prepared.parent)
-            fail("archive parent changed before publication");
-        let size = 0;
-        let completed = false;
-        let active = true;
-        const input = prepared.source ?? { async *[Symbol.asyncIterator]() { yield prepared.bytes ?? new Uint8Array(); } };
-        const source = scope.source((async function* () {
-            for await (const chunk of readBytes(input, signal)) {
-                if (!active)
-                    fail("ZIP publication source is closed");
-                if (chunk.length > scope.limits.maxArchiveBytes - size)
-                    fail("archive byte limit exceeded");
-                size += chunk.length;
-                let owned = chunk;
-                if (prepared.source)
-                    await writeFileOutput(scope.context, chunk, async (bytes) => { owned = Uint8Array.from(bytes); });
-                yield owned;
-            }
-            completed = true;
-        })());
-        try {
-            const receipt = await scope.operation(() => fs.publishFileConditional(prepared.output, source, {
-                signal, parent: prepared.parentStat, expected: prepared.existing ?? null, maxBytes: Number.isFinite(scope.limits.maxArchiveBytes) ? scope.limits.maxArchiveBytes : Number.MAX_SAFE_INTEGER,
-                ...(prepared.existing && capabilities.permissions !== false ? { mode: prepared.existing.mode & 0o7777 } : {}),
-                ...(prepared.mtimeMs === undefined ? {} : { mtimeMs: prepared.mtimeMs }),
-            }));
-            if (!completed || receipt.type !== "file" || receipt.size !== size || !hasZipIdentity(receipt)
-                || !hasZipVersion(receipt) || prepared.existing?.opaqueVersion === receipt.opaqueVersion)
-                fail("Invalid ZIP conditional publication acknowledgement");
-        }
-        finally {
-            active = false;
-            await scope.closeInputs();
-        }
-        return;
-    }
-    if ((capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true) || !fs.publishStagedFile)
-        fail("ZIP publication requires atomic owned file staging");
-    await stageZip(scope, {
-        ...prepared, reservedPath: prepared.output, parent: prepared.stagingParent ?? prepared.parent, parentStat: prepared.stagingParentStat ?? prepared.parentStat,
-    }, async (staging) => {
-        if (prepared.validate)
-            await prepared.validate(staging.file.path);
-        if (prepared.stagingName !== undefined) {
-            const current = await scope.operation(() => fs.realpath(prepared.stagingName, { signal }));
-            if (current !== prepared.stagingParent)
-                fail("ZIP temporary path changed before publication");
-        }
-        const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
-        if (parent !== prepared.parent)
-            fail("archive parent changed before publication");
-        if (prepared.existing && (prepared.existing.nlink ?? 1) > 1) {
-            if (capabilities.atomicFileMutation !== true || !fs.writeFileConditional)
-                fail("ZIP hardlinked archive update requires conditional in-place file mutation");
-            const stagedBytes = await scope.operation(() => fs.readFile(staging.file.path, { signal, ...(Number.isFinite(scope.limits.maxArchiveBytes) ? { maxBytes: scope.limits.maxArchiveBytes } : {}) }));
-            const receipt = await scope.operation(() => fs.writeFileConditional(prepared.output, stagedBytes, {
-                signal, parent: prepared.parentStat, expected: prepared.existing,
-                ...(capabilities.permissions !== false ? { mode: prepared.existing.mode & 0o7777 } : {}),
-                ...(prepared.mtimeMs === undefined ? {} : { mtimeMs: prepared.mtimeMs, atimeMs: prepared.mtimeMs }),
-            }));
-            if (prepared.mtimeMs !== undefined && (receipt.mtimeMs !== prepared.mtimeMs || receipt.atimeMs !== prepared.mtimeMs))
-                fail("ZIP publication did not retain archive modification time");
-            return;
-        }
-        await scope.operation(() => fs.publishStagedFile(staging, prepared.output, {
-            signal, parent: prepared.parentStat, destination: prepared.existing ?? null,
-        }));
-    });
-}
+export * from "../../../../safe-bash-zip-engine/zip/safety.js";
 //# sourceMappingURL=safety.js.map

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

@@ -1,5 +1,2 @@
-import { type ArchiveLimits } from "../internal.js";
-import { type ZipArchive } from "../zip-format.js";
-/** Accept only a complete validated archive following a prefix. Never execute it. */
-export declare function readZipSfx(bytes: Uint8Array, limits: ArchiveLimits, signal: AbortSignal, password?: Uint8Array): Promise<ZipArchive>;
+export * from "../../../../safe-bash-zip-engine/zip/sfx.js";
 //# sourceMappingURL=sfx.d.ts.map

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

@@ -1,53 +1,2 @@
-import { yieldTurn } from "../../../contracts/yield.js";
-import { fail } from "../internal.js";
-import { decodeZipEntry, readZipArchive } from "../zip-format.js";
-/** Accept only a complete validated archive following a prefix. Never execute it. */
-export async function readZipSfx(bytes, limits, signal, password) {
-    signal.throwIfAborted();
-    if (bytes.length > limits.maxArchiveBytes)
-        fail("ZIP archive byte limit exceeded");
-    let archive;
-    try {
-        archive = await readZipArchive(bytes, limits, signal, { prefix: true });
-    }
-    catch {
-        signal.throwIfAborted();
-    }
-    if (!archive) {
-        const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        // Unadjusted SFX offsets are relative to the embedded ZIP. Signature
-        // recognition only nominates a candidate; the strict reader proves all spans.
-        for (let offset = 1; offset + 22 <= bytes.length; offset++) {
-            if (offset > limits.maxPatternSteps)
-                fail("ZIP SFX scan work limit exceeded");
-            if (offset % 4096 === 0)
-                await yieldTurn(signal);
-            const signature = view.getUint32(offset, true);
-            if (signature !== 0x04034b50 && signature !== 0x06054b50)
-                continue;
-            let candidate;
-            try {
-                candidate = await readZipArchive(bytes.subarray(offset), limits, signal);
-            }
-            catch {
-                signal.throwIfAborted();
-                continue;
-            }
-            archive = candidate;
-            break;
-        }
-    }
-    if (!archive)
-        fail("ZIP SFX prefix does not contain a validated archive");
-    // CRC/expanded-size validation is required before prefix removal publication.
-    let decoded = 0;
-    for (const entry of archive.entries) {
-        for await (const chunk of decodeZipEntry(entry, limits, signal, password)) {
-            if (chunk.length > limits.maxTotalBytes - decoded)
-                fail("ZIP SFX decoded byte limit exceeded");
-            decoded += chunk.length;
-        }
-    }
-    return archive;
-}
+export * from "../../../../safe-bash-zip-engine/zip/sfx.js";
 //# sourceMappingURL=sfx.js.map

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

@@ -1,6 +1,2 @@
-import { Budget } from "../internal.js";
-import type { ZipScope } from "./safety.js";
-/** A literal argv grammar: spaces, quotes and backslash escapes, with no shell. */
-export declare function parseZipTestCommand(value: string): readonly string[];
-export declare function testZipCommand(scope: ZipScope, command: readonly string[] | undefined, path: string, budget: Budget, archive: string, quiet: boolean, password?: Uint8Array): Promise<void>;
+export * from "../../../../safe-bash-zip-engine/zip/test-command.js";
 //# sourceMappingURL=test-command.d.ts.map

package/dist/safe-bash/commands/archive/zip/test-command.js

@@ -1,102 +1,2 @@
-import { byteLength } from "../../../byte-encoding.js";
-import { shellValueFromBytes } from "../../../contracts/value.js";
-import { createCommandArguments, toByteSource } from "../../../contracts/index.js";
-import { Budget, fail } from "../internal.js";
-import { ZipFailure, zipPublicText } from "./options.js";
-/** A literal argv grammar: spaces, quotes and backslash escapes, with no shell. */
-export function parseZipTestCommand(value) {
-    const words = [];
-    let word = "";
-    let quote = "";
-    let active = false;
-    for (let index = 0; index < value.length; index++) {
-        const character = value[index];
-        if ("\n\r\0;|&<>$`".includes(character))
-            throw new ZipFailure(16, "Invalid command arguments", "unsupported virtual test-command syntax");
-        if (character === "\\" && quote !== "'") {
-            const next = value[++index];
-            if (next === undefined || "\n\r\0;|&<>$`".includes(next))
-                throw new ZipFailure(16, "Invalid command arguments", "invalid test-command escape");
-            word += next;
-            active = true;
-        }
-        else if (quote) {
-            if (character === quote)
-                quote = "";
-            else
-                word += character;
-        }
-        else if (character === "'" || character === '"') {
-            quote = character;
-            active = true;
-        }
-        else if (character === " " || character === "\t") {
-            if (active) {
-                words.push(word);
-                word = "";
-                active = false;
-            }
-        }
-        else {
-            word += character;
-            active = true;
-        }
-    }
-    if (quote)
-        throw new ZipFailure(16, "Invalid command arguments", "unterminated test-command quote");
-    if (active)
-        words.push(word);
-    if (!words[0] || words[0].includes("{}"))
-        throw new ZipFailure(16, "Invalid command arguments", "invalid virtual test command");
-    return words;
-}
-export async function testZipCommand(scope, command, path, budget, archive, quiet, password) {
-    const { context, limits } = scope;
-    let outputBytes = 0;
-    const sink = { async write(chunk) {
-            context.signal.throwIfAborted();
-            if (chunk.length > limits.maxTextBytes - outputBytes)
-                fail("ZIP test-command output limit exceeded");
-            outputBytes += chunk.length;
-        } };
-    try {
-        if (!context.invoke)
-            fail("virtual command invocation unavailable");
-        const virtualCommand = command ?? ["unzip", "-tqq"];
-        const placeholders = virtualCommand.slice(1).some(word => word.includes("{}"));
-        let argumentBytes = command === undefined && password !== undefined ? password.length + 4 : 0;
-        for (const word of virtualCommand.slice(1)) {
-            let placeholders = 0;
-            for (let index = 0; index + 1 < word.length; index++)
-                if (word[index] === "{" && word[index + 1] === "}") {
-                    placeholders++;
-                    index++;
-                }
-            const size = byteLength(word) + placeholders * (byteLength(path) - 2) + 1;
-            if (size > limits.maxArgumentBytes - argumentBytes)
-                fail("ZIP test-command argument byte limit exceeded");
-            argumentBytes += size;
-        }
-        if (!placeholders && byteLength(path) + 1 > limits.maxArgumentBytes - argumentBytes)
-            fail("ZIP test-command argument byte limit exceeded");
-        const args = virtualCommand.slice(1).map(word => word.split("{}").join(path));
-        if (!placeholders)
-            args.push(path);
-        const values = createCommandArguments(command === undefined && password !== undefined ? ["-P", shellValueFromBytes(password), ...args] : args);
-        const result = await scope.operation(() => context.invoke(virtualCommand[0], values.args, {
-            argumentValues: values,
-            signal: context.signal, stdin: toByteSource(""), stdinIsDefault: true, stdout: sink, stderr: sink,
-        }));
-        if (result.exitCode !== 0)
-            fail("ZIP virtual test command failed");
-    }
-    catch {
-        context.signal.throwIfAborted();
-        if (!quiet)
-            await budget.output(`test of ${zipPublicText(archive)} FAILED\n`);
-        throw new ZipFailure(8, "Zip file invalid, could not spawn unzip, or wrong unzip", "virtual test command failed; original files unmodified");
-    }
-    if (!quiet)
-        await budget.output(`test of ${zipPublicText(archive)} OK\n`);
-}
+export * from "../../../../safe-bash-zip-engine/zip/test-command.js";
 //# sourceMappingURL=test-command.js.map

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

@@ -1,22 +1,2 @@
-import { type FileStat } from "../../../contracts/index.js";
-import { type ArchiveLimits, type ZipHost } from "../internal.js";
-import { type ZipPublication, type ZipScope } from "./safety.js";
-import { type ZipDisks } from "./zip64.js";
-export declare function splitSize(value: string): number;
-export declare function volumeName(archive: string, disk: number, disks: number): string;
-export declare function zipEndOffset(bytes: Uint8Array): number;
-/** Input disks are supplied by the host, then read solely through the invocation VFS. */
-export declare function resolveZipVolumes(scope: Pick<ZipScope, "context" | "limits" | "operation" | "stat" | "input">, archive: string, final: Uint8Array, host?: ZipHost): Promise<{
-    bytes: Uint8Array;
-    disks?: ZipDisks;
-    paths: readonly string[];
-    volumes?: readonly {
-        path: string;
-        stat: FileStat;
-    }[];
-}>;
-/** Partition a validated single-disk encoding, preserving record boundaries and ciphertext. */
-export declare function splitZipVolumes(input: Uint8Array, size: number, limits: ArchiveLimits, signal: AbortSignal): Promise<Uint8Array[]>;
-/** All destinations preflight; all volumes staged before the first per-volume publication. */
-export declare function publishZipVolumes(scope: ZipScope, publication: ZipPublication, parts: readonly Uint8Array[], inputPaths: readonly string[], before: (path: string, disk: number) => Promise<void>): Promise<void>;
+export * from "../../../../safe-bash-zip-engine/zip/volumes.js";
 //# sourceMappingURL=volumes.d.ts.map