@poe-platform/safe-bash 0.1.614 → 0.1.616

package/dist/safe-bash/core.browser.js

@@ -3245,7 +3245,7 @@ async function parseEnvOptions(args, environment, signal, argumentValues) {
   const values = /* @__PURE__ */ new Map();
   const operands = [];
   const operandValues = [];
-  const longOptions = /* @__PURE__ */ new Map([
+  const longOptions2 = /* @__PURE__ */ new Map([
     ["ignore-environment", "i"],
     ["unset", "u"],
     ["null", "0"],
@@ -3280,7 +3280,7 @@ async function parseEnvOptions(args, environment, signal, argumentValues) {
     if (argument2.startsWith("--")) {
       const equals = argument2.indexOf("=");
       const name2 = argument2.slice(2, equals < 0 ? void 0 : equals);
-      const key = longOptions.get(name2);
+      const key = longOptions2.get(name2);
       if (!key) throw new UsageError(`unrecognized option '${argument2}'`);
       const required = key === "u" || key === "C" || key === "S";
       if (!required && equals >= 0) throw new UsageError(`option '--${name2}' does not take an argument`);
@@ -3555,11 +3555,11 @@ function executionCommands(execute4, configuration = {}) {
       const operandIndices = [];
       let replacementOrigin;
       const shortOptions = "0rn:s:I:d:tP:xE:";
-      const longOptions = { null: "0", "no-run-if-empty": "r", "max-args": "n", "max-chars": "s", replace: "I", delimiter: "d", verbose: "t", "max-procs": "P", exit: "x", eof: "E" };
+      const longOptions2 = { null: "0", "no-run-if-empty": "r", "max-args": "n", "max-chars": "s", replace: "I", delimiter: "d", verbose: "t", "max-procs": "P", exit: "x", eof: "E" };
       const parsed = options(
         argumentValues.args,
         shortOptions,
-        longOptions,
+        longOptions2,
         true,
         (index) => {
           operandIndices.push(index);
@@ -26729,7 +26729,8 @@ function entryBounds(entry, limits) {
   format(entry.method, entry.flags ?? 2048, entry.method === 8 || (entry.flags ?? 0) & 8 ? 20 : 10);
   if (entry.directory !== entry.name.endsWith("/") || entry.directory && (entry.symlink || entry.size !== 0)) fail("ZIP inconsistent directory metadata");
   const type = entry.mode & 61440;
-  if (type !== 0 && type !== (entry.directory ? 16384 : entry.symlink ? 40960 : 32768)) fail("ZIP unsupported or conflicting file type");
+  const pipePayload = !entry.directory && !entry.symlink && type === 4096;
+  if (type !== 0 && !pipePayload && type !== (entry.directory ? 16384 : entry.symlink ? 40960 : 32768)) fail("ZIP unsupported or conflicting file type");
   if (!Number.isFinite(entry.modified.getTime())) fail("ZIP invalid modification time");
 }
 async function copyBytes(source2, destination2, start, chunkSize2, signal) {
@@ -26896,7 +26897,7 @@ async function* decodeZipEntry(entry, limits, signal) {
     await reader.close();
   }
 }
-async function makeZipEntry(name2, bytes3, attributes, limits, signal, level = 6) {
+async function makeZipEntry(name2, bytes3, attributes, limits, signal, level = 6, forceCompression = false) {
   const chunkSize2 = admit(limits, signal);
   const entry = { name: name2, data: bytes3, size: bytes3.length, method: 0, crc32: 0, ...attributes, modified: new Date(attributes.modified.getTime()) };
   entryBounds(entry, limits);
@@ -26908,15 +26909,16 @@ async function makeZipEntry(name2, bytes3, attributes, limits, signal, level = 6
     yield bytes3;
   })(), signal);
   try {
-    if (level !== 0 && bytes3.length && !entry.directory && !entry.symlink) {
+    if (level !== 0 && (bytes3.length || forceCompression) && !entry.directory && !entry.symlink) {
       const chunks = [];
       let length = 0;
       for await (const chunk of codec(reader, { mode: "deflate-raw", chunkSize: chunkSize2, level }, signal)) {
         length += chunk.length;
-        if (length >= bytes3.length) break;
+        if (length > limits.maxArchiveBytes) fail("ZIP compressed byte limit exceeded");
+        if (!forceCompression && length >= bytes3.length) break;
         chunks.push(new Uint8Array(chunk));
       }
-      if (length < bytes3.length) {
+      if (forceCompression || length < bytes3.length) {
         entry.data = new Uint8Array(length);
         let offset = 0;
         for (const chunk of chunks) {
@@ -26946,7 +26948,7 @@ function timestampExtra(modified) {
   view.setInt32(5, seconds, true);
   return bytes3;
 }
-async function writeZipArchive(archive, limits, signal) {
+async function writeZipArchive(archive, limits, signal, descriptors = false) {
   const chunkSize2 = admit(limits, signal);
   number3(archive.entries.length, Math.min(limits.maxMembers, 65534), "member");
   number3(archive.comment.length, Math.min(limits.maxTextBytes, 65535), "archive comment");
@@ -26961,7 +26963,8 @@ async function writeZipArchive(archive, limits, signal) {
     total += entry.size;
     number3(total, limits.maxTotalBytes, "total byte");
     const rawName = entry.rawName ?? pathBytes(entry.name, limits);
-    const flags3 = (entry.flags ?? 2048) & ~8;
+    const descriptor = descriptors && !entry.directory;
+    const flags3 = (entry.flags ?? 2048) & ~8 | (descriptor ? 8 : 0);
     const comment2 = entry.comment ?? new Uint8Array();
     number3(comment2.length, Math.min(limits.maxTextBytes, 65535), "entry comment");
     if (flags3 & 2048) text2(comment2);
@@ -26989,8 +26992,8 @@ async function writeZipArchive(archive, limits, signal) {
       if (mode !== entry.mode || Boolean(entry.externalAttributes & 16) && !entry.directory) fail("ZIP retained file attributes mismatch");
     }
     encoded2.push({ entry, rawName, flags: flags3, localExtra, centralExtra, comment: comment2, date: date2, time, offset: localLength });
-    localLength += 30 + rawName.length + localExtra.length + entry.data.length;
-    length += 76 + 2 * rawName.length + localExtra.length + centralExtra.length + comment2.length + entry.data.length;
+    localLength += 30 + rawName.length + localExtra.length + entry.data.length + (descriptor ? 16 : 0);
+    length += 76 + 2 * rawName.length + localExtra.length + centralExtra.length + comment2.length + entry.data.length + (descriptor ? 16 : 0);
     number3(length, Math.min(limits.maxArchiveBytes, 4294967294), "archive byte");
   }
   number3(length, Math.min(limits.maxArchiveBytes, 4294967294), "archive byte");
@@ -27000,21 +27003,28 @@ async function writeZipArchive(archive, limits, signal) {
   for (const item of encoded2) {
     await yieldTurn(signal);
     const { entry, rawName, flags: flags3, localExtra, centralExtra, comment: comment2, date: date2, time, offset } = item;
-    const version = entry.method === 8 ? 20 : 10;
+    const version = entry.method === 8 || flags3 & 8 ? 20 : 10;
     view.setUint32(offset, 67324752, true);
     view.setUint16(offset + 4, version, true);
     view.setUint16(offset + 6, flags3, true);
     view.setUint16(offset + 8, entry.method, true);
     view.setUint16(offset + 10, time, true);
     view.setUint16(offset + 12, date2, true);
-    view.setUint32(offset + 14, entry.crc32, true);
-    view.setUint32(offset + 18, entry.data.length, true);
-    view.setUint32(offset + 22, entry.size, true);
+    view.setUint32(offset + 14, flags3 & 8 ? 0 : entry.crc32, true);
+    view.setUint32(offset + 18, flags3 & 8 ? 0 : entry.data.length, true);
+    view.setUint32(offset + 22, flags3 & 8 ? 0 : entry.size, true);
     view.setUint16(offset + 26, rawName.length, true);
     view.setUint16(offset + 28, localExtra.length, true);
     bytes3.set(rawName, offset + 30);
     bytes3.set(localExtra, offset + 30 + rawName.length);
     await copyBytes(entry.data, bytes3, offset + 30 + rawName.length + localExtra.length, chunkSize2, signal);
+    if (flags3 & 8) {
+      const descriptor = offset + 30 + rawName.length + localExtra.length + entry.data.length;
+      view.setUint32(descriptor, 134695760, true);
+      view.setUint32(descriptor + 4, entry.crc32, true);
+      view.setUint32(descriptor + 8, entry.data.length, true);
+      view.setUint32(descriptor + 12, entry.size, true);
+    }
     view.setUint32(central, 33639248, true);
     view.setUint16(central + 4, entry.versionMadeBy ?? 798, true);
     view.setUint16(central + 6, version, true);
@@ -27029,7 +27039,8 @@ async function writeZipArchive(archive, limits, signal) {
     view.setUint16(central + 30, centralExtra.length, true);
     view.setUint16(central + 32, comment2.length, true);
     view.setUint16(central + 36, entry.internalAttributes ?? 0, true);
-    view.setUint32(central + 38, entry.externalAttributes ?? (entry.mode | (entry.directory ? 16384 : entry.symlink ? 40960 : 32768)) * 65536 + (entry.directory ? 16 : 0), true);
+    const mode = entry.mode & 61440 ? entry.mode : entry.mode | (entry.directory ? 16384 : entry.symlink ? 40960 : 32768);
+    view.setUint32(central + 38, entry.externalAttributes ?? mode * 65536 + (entry.directory ? 16 : 0), true);
     view.setUint32(central + 42, offset, true);
     bytes3.set(rawName, central + 46);
     bytes3.set(centralExtra, central + 46 + rawName.length);
@@ -27066,6 +27077,7 @@ var ZipScope = class {
   closedReason = new Error("ZIP command is closed");
   drain;
   work = 0;
+  stdinSource;
   close = () => {
     if (!this.drain) {
       this.drain = Promise.resolve().then(async () => {
@@ -27104,6 +27116,9 @@ var ZipScope = class {
       throw error;
     }
   }
+  get stdin() {
+    return this.stdinSource ??= this.source(this.original.stdin);
+  }
   source(source2) {
     const iterator = source2[Symbol.asyncIterator]();
     let closing;
@@ -27376,7 +27391,8 @@ var Answers = class {
   }
 };
 
-// packages/safe-bash/src/commands/archive/zip.ts
+// packages/safe-bash/src/commands/archive/zip/options.ts
+init_platform();
 var ZipFailure = class extends Error {
   constructor(status2, label, detail) {
     super(detail);
@@ -27386,6 +27402,107 @@ var ZipFailure = class extends Error {
   status;
   label;
 };
+var longOptions = {
+  "recurse-paths": "r",
+  quiet: "q",
+  "junk-paths": "j",
+  "no-dir-entries": "D",
+  symlinks: "y",
+  test: "T",
+  "names-stdin": "@",
+  update: "u",
+  freshen: "f",
+  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"
+};
+var reservedOptions = [
+  "adjust-sfx",
+  "temp-path",
+  "entry-comments",
+  "display-bytes",
+  "display-counts",
+  "display-dots",
+  "display-globaldots",
+  "dot-size",
+  "display-usize",
+  "display-volume",
+  "difference-archive",
+  "encrypt",
+  "fix",
+  "fixfix",
+  "fifo",
+  "filesync",
+  "force-descriptors",
+  "force-zip64",
+  "grow",
+  "help",
+  "more-help",
+  "junk-sfx",
+  "DOS-names",
+  "to-crlf",
+  "from-crlf",
+  "logfile-path",
+  "log-append",
+  "log-info",
+  "license",
+  "move",
+  "must-match",
+  "no-wild",
+  "latest-time",
+  "output-file",
+  "paths",
+  "password",
+  "recurse-patterns",
+  "regex",
+  "split-size",
+  "split-pause",
+  "split-verbose",
+  "split-bell",
+  "show-command",
+  "show-debug",
+  "show-files",
+  "show-options",
+  "from-date",
+  "before-date",
+  "unzip-command",
+  "copy-entries",
+  "verbose",
+  "version",
+  "wild-stop-dirs",
+  "strip-extra",
+  "archive-comment"
+];
+function normalizeZipOption(argument2) {
+  if (!argument2.startsWith("--") || argument2 === "--") return argument2;
+  const equal2 = argument2.indexOf("=");
+  const name2 = argument2.slice(2, equal2 < 0 ? void 0 : equal2);
+  const names = [...Object.keys(longOptions), ...reservedOptions];
+  const matches2 = names.includes(name2) ? [name2] : names.filter((option) => option.startsWith(name2));
+  if (matches2.length > 1) throw new ZipFailure(16, "Invalid command arguments", `long option '${name2}' ambiguous`);
+  const matched = matches2[0];
+  const short = matched === void 0 ? void 0 : longOptions[matched];
+  if (!short) throw new ZipFailure(16, "Invalid command arguments", `unsupported option: ${argument2}`);
+  if (equal2 >= 0 && short !== "i" && short !== "x" && short !== "n" && short !== "Z") {
+    throw new ZipFailure(16, "Invalid command arguments", `option '${matched}' does not allow a value`);
+  }
+  return `-${short}${equal2 < 0 ? "" : argument2.slice(equal2)}`;
+}
+
+// packages/safe-bash/src/commands/archive/zip.ts
+var defaultStoreSuffixes = [".Z", ".zip", ".zoo", ".arc", ".lzh", ".arj"];
 async function parse12(scope, limits) {
   const context2 = scope.context;
   if (context2.args.length > limits.maxArgumentBytes) fail("argument count limit exceeded");
@@ -27414,6 +27531,8 @@ async function parse12(scope, limits) {
   let storeLinks = false;
   let test = false;
   let level = 6;
+  let method = "deflate";
+  let suffixes = defaultStoreSuffixes;
   let stdinNames = false;
   let literal = false;
   let firstOperand = -1;
@@ -27421,8 +27540,9 @@ async function parse12(scope, limits) {
   const includes = [];
   const excludes = [];
   for (let index = 0; index < context2.args.length; index++) {
-    const argument2 = context2.args[index];
-    checkPath(argument2, limits);
+    const original = context2.args[index];
+    checkPath(original, limits);
+    const argument2 = literal ? original : normalizeZipOption(original);
     if (!literal && argument2 === "--") {
       if (archive === void 0) throw new ZipFailure(16, "Invalid command arguments", "can't use -- before archive name");
       literal = true;
@@ -27440,17 +27560,43 @@ async function parse12(scope, limits) {
         else if (flag === "y") storeLinks = true;
         else if (flag === "T") test = true;
         else if (flag === "@") stdinNames = true;
-        else if (flag !== void 0 && flag >= "0" && flag <= "9") level = Number(flag);
-        else if (flag === "i" || flag === "x") {
+        else if (flag !== void 0 && flag >= "0" && flag <= "9") {
+          level = Number(flag);
+          if (level === 0) method = "store";
+        } else if (flag === "n" || flag === "Z") {
+          let value2 = argument2.slice(offset + 1);
+          if (!value2) {
+            const next = context2.args[index + 1];
+            if (next === void 0 || next.startsWith("-") && next !== "-") throw new ZipFailure(16, "Invalid command arguments", `option '${flag}' requires a value`);
+            value2 = next;
+            index++;
+          }
+          if (value2.startsWith("=")) value2 = value2.slice(1);
+          if (flag === "n") {
+            suffixes = value2 ? value2.split(":").filter((suffix2) => suffix2.length > 0) : defaultStoreSuffixes;
+            if (value2 && suffixes.length > limits.maxMembers) fail("suffix count limit exceeded");
+          } else {
+            const matches2 = ["store", "deflate", "bzip2"].filter((name2) => name2.startsWith(value2.toLowerCase()));
+            const selected = matches2.length === 1 ? matches2[0] : void 0;
+            if (!selected) throw new ZipFailure(16, "Invalid command arguments", "Option -Z (--compression-method):  unknown method");
+            if (selected === "bzip2") throw new ZipFailure(19, "Not supported", "Compression method bzip2 not enabled");
+            method = selected === "store" ? "store" : "deflate";
+          }
+          break;
+        } else if (flag === "i" || flag === "x") {
           const patterns2 = flag === "i" ? includes : excludes;
           const before = patterns2.length;
           const append = (pattern) => {
-            checkPath(pattern, limits);
+            if (pattern) checkPath(pattern, limits);
             if (includes.length + excludes.length >= limits.maxMembers) fail("pattern count limit exceeded");
             patterns2.push(pattern);
           };
-          if (offset + 1 < argument2.length) append(argument2.slice(offset + 1));
-          while (index + 1 < context2.args.length) {
+          const attached = offset + 1 < argument2.length;
+          if (attached) {
+            const value2 = argument2.slice(offset + 1);
+            append(value2.startsWith("=") ? value2.slice(1) : value2);
+          }
+          while (!attached && index + 1 < context2.args.length) {
             const next = context2.args[index + 1];
             if (next === "@") {
               index++;
@@ -27471,13 +27617,16 @@ async function parse12(scope, limits) {
       operands.push(argument2);
     }
   }
-  if (archive === void 0) throw new ZipFailure(16, "Invalid command arguments", "expected zip [-r] [-q] [-j] [-@] [-0..-9] ARCHIVE FILES... [-i PATTERNS...] [-x PATTERNS...]");
-  if (archive === "-" || operands.includes("-")) throw new ZipFailure(16, "Invalid command arguments", "standard input/output archives are unsupported");
-  if (!archive.slice(archive.lastIndexOf("/") + 1).includes(".")) archive += ".zip";
+  if (archive === void 0) {
+    if (action !== "add") throw new ZipFailure(16, "Invalid command arguments", "expected archive name");
+    archive = "-";
+    if (!stdinNames) operands.push("-");
+  }
+  if (archive !== "-" && !archive.slice(archive.lastIndexOf("/") + 1).includes(".")) archive += ".zip";
   checkPath(archive, limits);
   const names = [];
   if (stdinNames) {
-    const input3 = await collectBytes(scope.source(context2.stdin), { maxBytes: limits.maxFilesFromBytes, signal: context2.signal });
+    const input3 = await collectBytes(scope.stdin, { maxBytes: limits.maxFilesFromBytes, signal: context2.signal });
     let start = 0;
     let lines3 = 0;
     for (let end = 0; end <= input3.length; end++) {
@@ -27496,7 +27645,7 @@ async function parse12(scope, limits) {
       start = end + 1;
     }
   }
-  return { action, archive, recursive, quiet, junkPaths, omitDirectories, storeLinks, test, includes, excludes, level, operands: [...names, ...operands], firstOperand };
+  return { action, archive, recursive, quiet, junkPaths, omitDirectories, storeLinks, test, includes, excludes, level, method, suffixes, operands: [...names, ...operands], firstOperand };
 }
 function memberName(path, limits) {
   if (path.startsWith("//") && !path.startsWith("///")) fail("UNC source paths are unsupported");
@@ -27538,21 +27687,29 @@ async function filterName(name2, selection, includeCount) {
 async function prepare(scope, parsed, budget) {
   const context2 = scope.context;
   const limits = budget.limits;
-  const outputName = vfsPath(context2.cwd, parsed.archive);
-  const parentName = dirname(outputName);
-  const parent = await scope.operation(() => context2.fs.realpath(parentName, { signal: context2.signal }));
-  const parentStat = await scope.operation(() => context2.fs.lstat(parent, { signal: context2.signal }));
-  const output2 = `${parent === "/" ? "" : parent}/${outputName.slice(outputName.lastIndexOf("/") + 1)}`;
-  checkPath(output2, limits);
-  const existing2 = await scope.stat(output2);
+  if (parsed.archive === "-" && parsed.action !== "add") throw new ZipFailure(16, "Invalid command arguments", "can't use -d, -f, -u, -U, or -g on stdout\n");
+  let publication;
+  if (parsed.archive !== "-") {
+    const outputName = vfsPath(context2.cwd, parsed.archive);
+    const parentName = dirname(outputName);
+    const parent = await scope.operation(() => context2.fs.realpath(parentName, { signal: context2.signal }));
+    const parentStat = await scope.operation(() => context2.fs.lstat(parent, { signal: context2.signal }));
+    const output3 = `${parent === "/" ? "" : parent}/${outputName.slice(outputName.lastIndexOf("/") + 1)}`;
+    checkPath(output3, limits);
+    const existing3 = await scope.stat(output3);
+    publication = { output: output3, parentName, parent, parentStat, existing: existing3 };
+  }
+  const output2 = publication?.output;
+  const existing2 = publication?.existing;
+  if (parsed.archive === "-" && parsed.test && !parsed.quiet) await budget.output("	zip warning: can't use -T on stdout, -T ignored\n");
   if (existing2 && (existing2.type !== "file" || !hasIdentity(existing2) || existing2.nlink !== 1)) fail("updating archive requires a regular, single-link file with known backing identity; archive aliases are unsupported");
   let archive = { entries: [], comment: new Uint8Array() };
-  if (existing2) {
+  if (existing2 && publication) {
     if (!Number.isSafeInteger(existing2.size) || existing2.size < 0 || existing2.size > limits.maxArchiveBytes) fail("archive byte limit exceeded");
-    const bytes4 = await collectBytes(scope.input(output2), { maxBytes: limits.maxArchiveBytes, signal: context2.signal });
+    const bytes4 = await collectBytes(scope.input(publication.output), { maxBytes: limits.maxArchiveBytes, signal: context2.signal });
     if (bytes4.length !== existing2.size) fail("archive changed while reading");
     archive = await readZipArchive(bytes4, limits, context2.signal);
-    const current = await scope.stat(output2);
+    const current = await scope.stat(publication.output);
     if (!current || !unchanged4(existing2, current)) fail("archive changed while reading");
   }
   const old = new Map(archive.entries.map((entry) => [entry.name, entry]));
@@ -27565,12 +27722,35 @@ async function prepare(scope, parsed, budget) {
   let visits = 0;
   let work = 0;
   let compressedBytes = 0;
+  const encodeSelected = async (source2, name2, bytes4, attributes) => {
+    const store = parsed.method === "store" || parsed.level !== 9 && parsed.suffixes.some((suffix2) => name2.endsWith(suffix2));
+    if (!store && parsed.level === 0 && bytes4.length && !attributes.directory && !attributes.symlink) throw new ZipFailure(5, "Internal logic error", "bad pack level");
+    const level = store ? 0 : parsed.level;
+    let entry = await makeZipEntry(name2, bytes4, attributes, limits, context2.signal, level, parsed.archive === "-" && !store);
+    const prior = old.get(name2);
+    if (prior?.comment) entry = { ...entry, comment: prior.comment };
+    if (entry.data.length > limits.maxArchiveBytes - compressedBytes) fail("archive byte limit exceeded");
+    compressedBytes += entry.data.length;
+    selected.set(name2, { entry, source: source2 });
+  };
   const visit = async (source2, name2, depth) => {
     context2.signal.throwIfAborted();
     if (++visits > limits.maxMembers) fail("traversal member limit exceeded");
     if (++work > limits.maxPatternSteps) fail("archive work limit exceeded");
     if (visits % 128 === 0) await yieldTurn(context2.signal);
     if (depth > limits.maxDepth) fail("archive recursion depth limit exceeded");
+    if (source2 === "-") {
+      const previous = selected.get(name2);
+      if (previous && previous.source !== source2) throw new ZipFailure(16, "Invalid command arguments", "cannot repeat names in zip file");
+      if (previous || !await filterName(name2, selection, parsed.includes.length)) return;
+      const prior2 = old.get(name2);
+      const modified = /* @__PURE__ */ new Date();
+      if (parsed.action === "freshen" && !prior2 || prior2 && (parsed.action === "update" || parsed.action === "freshen") && Math.floor(modified.getTime() / 1e3) <= Math.floor(prior2.modified.getTime() / 1e3)) return;
+      const bytes4 = await collectBytes(scope.stdin, { maxBytes: Math.min(limits.maxEntryBytes, limits.maxTotalBytes - budget.totalBytes), signal: context2.signal });
+      await budget.member(bytes4.length);
+      await encodeSelected(source2, name2, bytes4, { modified, mode: 4528, directory: false, symlink: false });
+      return;
+    }
     const path = vfsPath(context2.cwd, source2);
     checkPath(path, limits);
     let canonical;
@@ -27623,12 +27803,7 @@ async function prepare(scope, parsed, budget) {
         if (!directory2 && bytes4.length !== stat.size) fail(`source changed while reading: ${source2}`);
         const current = await inspectSource(scope, path, parsed.storeLinks);
         if (current.canonical !== canonical || !unchanged4(stat, current.stat)) fail(`source changed while reading: ${source2}`);
-        let entry = await makeZipEntry(name2, bytes4, { modified: new Date(stat.mtimeMs), mode: stat.mode, directory: directory2, symlink }, limits, context2.signal, parsed.level);
-        if ([".z", ".zip", ".zoo", ".arc", ".lzh", ".arj"].some((suffix2) => name2.toLowerCase().endsWith(suffix2))) entry = { ...entry, method: 0, data: bytes4 };
-        if (prior?.comment) entry = { ...entry, comment: prior.comment };
-        if (entry.data.length > limits.maxArchiveBytes - compressedBytes) fail("archive byte limit exceeded");
-        compressedBytes += entry.data.length;
-        selected.set(name2, { entry, source: source2 });
+        await encodeSelected(source2, name2, bytes4, { modified: new Date(stat.mtimeMs), mode: stat.mode, directory: directory2, symlink });
       }
     }
     if (directory2 && parsed.recursive) {
@@ -27709,8 +27884,8 @@ async function prepare(scope, parsed, budget) {
     append(entry, false);
   }
   if (!entries2.length) queue("	zip warning: zip file empty\n");
-  const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal);
-  if (parsed.test) {
+  const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal, parsed.archive === "-");
+  if (parsed.test && parsed.archive !== "-") {
     for (const message3 of progress) await budget.output(message3);
     progress.length = 0;
     progressBytes = 0;
@@ -27735,7 +27910,7 @@ async function prepare(scope, parsed, budget) {
 `);
     }
   }
-  return { output: output2, parentName, parent, parentStat, existing: existing2, bytes: bytes3, progress };
+  return { publication, bytes: bytes3, progress };
 }
 function createZipCommand(options2 = {}) {
   const limits = settings2(options2);
@@ -27743,13 +27918,25 @@ function createZipCommand(options2 = {}) {
     original.signal.throwIfAborted();
     const scope = new ZipScope(original, limits);
     const context2 = scope.context;
-    const budget = new Budget14(context2, limits);
+    let budget = new Budget14(context2, limits);
     try {
       const parsed = await parse12(scope, limits);
+      if (parsed.archive === "-") budget = new Budget14({ ...context2, stdout: context2.stderr }, limits);
       const prepared = await prepare(scope, parsed, budget);
       if (!prepared) return { exitCode: 12 };
-      await writeFileOutput(context2, prepared.bytes, () => scope.operation(() => publishZip(scope, prepared)));
-      for (const message3 of prepared.progress) await budget.output(message3);
+      const publication = prepared.publication;
+      if (publication) {
+        await writeFileOutput(context2, prepared.bytes, () => scope.operation(() => publishZip(scope, { ...publication, bytes: prepared.bytes })));
+        for (const message3 of prepared.progress) await budget.output(message3);
+      } else {
+        for (const message3 of prepared.progress) await budget.output(message3);
+        const output2 = createOutputOperation(context2, context2.stdout);
+        try {
+          await writeBytes(output2.output, prepared.bytes, output2.signal);
+        } finally {
+          await output2.close();
+        }
+      }
       return { exitCode: 0 };
     } catch (error) {
       original.signal.throwIfAborted();
@@ -28155,7 +28342,7 @@ function createUnzipCommand(options2 = {}) {
         }
         let path = extraction.member(root, entry.name);
         const fileType = entry.mode & 61440;
-        if (fileType && fileType !== 32768 && fileType !== 16384 && fileType !== 40960) fail("unsupported special ZIP entry");
+        if (fileType && fileType !== 32768 && fileType !== 16384 && fileType !== 40960 && fileType !== 4096) fail("unsupported special ZIP entry");
         if (path === root && !entry.directory) fail("entry would replace extraction root");
         let shown = parsed.destination === void 0 ? entry.name : `${parsed.destination.endsWith("/") ? parsed.destination : `${parsed.destination}/`}${entry.name}`;
         await extraction.parents(root, path, true);