@poe-platform/safe-bash 0.1.532 → 0.1.534

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

@@ -841,7 +841,7 @@ var Parser = class {
       return { minimum: 0, maximum: 1 };
     }
     this.position += 2;
-    const number5 = () => {
+    const number6 = () => {
       let value2 = 0, count2 = 0;
       while (this.tokens[this.position] >= "0" && this.tokens[this.position] <= "9") {
         this.work.charge();
@@ -850,12 +850,12 @@ var Parser = class {
       }
       return count2 ? value2 : void 0;
     };
-    const minimum = number5();
+    const minimum = number6();
     if (minimum === void 0) syntax("Invalid content of \\{\\}");
     let maximum = minimum;
     if (this.at(",")) {
       this.position++;
-      maximum = number5() ?? Infinity;
+      maximum = number6() ?? Infinity;
     }
     if (!this.escaped("}")) syntax("Unmatched \\{");
     this.position += 2;
@@ -1111,15 +1111,15 @@ function* matchExprSteps(descriptor2, subject, options3 = {}) {
         if (start < 0 || end < start || end - start > input3.values.length - state.position) break;
         work.charge(end - start);
         if (work.checkpoint()) yield;
-        let equal = true;
+        let equal2 = true;
         for (let offset = 0; offset < end - start; offset++) {
           if (input3.values[start + offset] !== input3.values[state.position + offset]) {
-            equal = false;
+            equal2 = false;
             break;
           }
           if ((offset + 1) % 256 === 0) yield;
         }
-        if (!equal) break;
+        if (!equal2) break;
         state.position += end - start;
         if (end > start) {
           work.allocate(1);
@@ -2449,34 +2449,34 @@ async function formatPrintf(context2) {
   const arguments_ = incoming.args[0] === "--" ? incoming.slice(1) : incoming;
   const args = arguments_.args;
   requireOperands(args);
-  const format2 = args[0];
-  if (format2.startsWith("-") && incoming.args[0] !== "--") throw new UsageError(`invalid option '${format2}'`);
+  const format3 = args[0];
+  if (format3.startsWith("-") && incoming.args[0] !== "--") throw new UsageError(`invalid option '${format3}'`);
   const rawFormat = typeof arguments_.values[0] === "string" ? void 0 : arguments_.bytes(0);
-  const formatLength = rawFormat?.length ?? format2.length;
+  const formatLength = rawFormat?.length ?? format3.length;
   let argument2 = 1;
   let exitCode = 0;
   let stopped = false;
   do {
     const before = argument2;
     for (let offset = 0; offset < formatLength && !stopped; ) {
-      if (rawFormat ? rawFormat[offset] !== 37 : format2[offset] !== "%") {
-        const end = rawFormat ? rawFormat.indexOf(37, offset) : format2.indexOf("%", offset);
+      if (rawFormat ? rawFormat[offset] !== 37 : format3[offset] !== "%") {
+        const end = rawFormat ? rawFormat.indexOf(37, offset) : format3.indexOf("%", offset);
         const limit = end < 0 ? formatLength : end;
-        const literal = rawFormat ? rawFormat.subarray(offset, limit) : format2.slice(offset, limit);
+        const literal = rawFormat ? rawFormat.subarray(offset, limit) : format3.slice(offset, limit);
         const escaped3 = escapeBytes(literal);
         await output(context2, escaped3.bytes);
         stopped = escaped3.stop;
         offset += literal.length;
         continue;
       }
-      if (rawFormat ? rawFormat[offset + 1] === 37 : format2[offset + 1] === "%") {
+      if (rawFormat ? rawFormat[offset + 1] === 37 : format3[offset + 1] === "%") {
         await output(context2, "%");
         offset += 2;
         continue;
       }
       let tokenEnd = offset + 1;
       if (rawFormat) while (tokenEnd < rawFormat.length && (rawFormat[tokenEnd] >= 48 && rawFormat[tokenEnd] <= 57 || [32, 35, 43, 45, 46].includes(rawFormat[tokenEnd]))) tokenEnd++;
-      const fragment = rawFormat ? decoder.decode(rawFormat.subarray(offset, tokenEnd + 1)) : format2.slice(offset);
+      const fragment = rawFormat ? decoder.decode(rawFormat.subarray(offset, tokenEnd + 1)) : format3.slice(offset);
       const match = /^%([-+ #0]*)(\d+)?(?:\.(\d+))?([sbqcdiouxXfFeEgG])/u.exec(fragment);
       if (!match) throw new UsageError(`invalid format near '${fragment}'`);
       offset += match[0].length;
@@ -2504,30 +2504,30 @@ async function formatPrintf(context2) {
       if (specifier === "q") text3 = supplied === "" ? "''" : supplied.replace(/[^a-zA-Z0-9_./-]/gu, (character) => character === "\n" ? "$'\\n'" : `\\${character}`);
       else if (specifier === "c") text3 = supplied ? String.fromCodePoint(supplied.codePointAt(0)) : "\0";
       else {
-        let number5 = supplied === "" ? 0 : /^["']/u.test(supplied) ? supplied.codePointAt(1) ?? 0 : Number(supplied);
+        let number6 = supplied === "" ? 0 : /^["']/u.test(supplied) ? supplied.codePointAt(1) ?? 0 : Number(supplied);
         if (/^[+-]0[xX][0-9a-fA-F]+$/u.test(supplied.trim())) {
-          number5 = Number(supplied.trim().slice(1)) * (supplied.trim().startsWith("-") ? -1 : 1);
+          number6 = Number(supplied.trim().slice(1)) * (supplied.trim().startsWith("-") ? -1 : 1);
         }
         if (/^[+-]?0[0-9]+$/u.test(supplied) && !/[fFeEgG]/u.test(specifier)) {
-          if (/[89]/u.test(supplied)) number5 = NaN;
-          else number5 = parseInt(supplied.replace(/^[+-]?0/u, ""), 8) * (supplied.startsWith("-") ? -1 : 1);
+          if (/[89]/u.test(supplied)) number6 = NaN;
+          else number6 = parseInt(supplied.replace(/^[+-]?0/u, ""), 8) * (supplied.startsWith("-") ? -1 : 1);
         }
-        if (!Number.isFinite(number5)) {
+        if (!Number.isFinite(number6)) {
           await writeDiagnostic(context2.stderr, `printf: '${supplied}': invalid number
 `, context2.signal);
           exitCode = 1;
-          number5 = 0;
+          number6 = 0;
         }
-        if (/[fF]/u.test(specifier)) text3 = number5.toFixed(precision ?? 6);
-        else if (/[eE]/u.test(specifier)) text3 = number5.toExponential(precision ?? 6).replace(/e([+-])(\d)$/u, "e$10$2");
-        else if (/[gG]/u.test(specifier)) text3 = Number(number5.toPrecision(Math.max(1, precision ?? 6))).toString();
+        if (/[fF]/u.test(specifier)) text3 = number6.toFixed(precision ?? 6);
+        else if (/[eE]/u.test(specifier)) text3 = number6.toExponential(precision ?? 6).replace(/e([+-])(\d)$/u, "e$10$2");
+        else if (/[gG]/u.test(specifier)) text3 = Number(number6.toPrecision(Math.max(1, precision ?? 6))).toString();
         else {
           const radix = /[xX]/u.test(specifier) ? 16 : specifier === "o" ? 8 : 10;
           const unsigned = /[uoxX]/u.test(specifier);
           let integral;
           try {
             const token = supplied.trim();
-            if (!token || /^["']/u.test(token)) integral = BigInt(Math.trunc(number5));
+            if (!token || /^["']/u.test(token)) integral = BigInt(Math.trunc(number6));
             else {
               const magnitude = token.replace(/^[+-]/u, "");
               if (!/^(?:0[xX][0-9a-fA-F]+|0[0-7]*|[1-9][0-9]*)$/u.test(magnitude)) throw new Error("invalid integer");
@@ -2548,7 +2548,7 @@ async function formatPrintf(context2) {
           }
         }
         if (/[XFEG]/u.test(specifier)) text3 = text3.toUpperCase();
-        if (number5 >= 0 && /[difFeEgG]/u.test(specifier)) text3 = (flags3.includes("+") ? "+" : flags3.includes(" ") ? " " : "") + text3;
+        if (number6 >= 0 && /[difFeEgG]/u.test(specifier)) text3 = (flags3.includes("+") ? "+" : flags3.includes(" ") ? " " : "") + text3;
       }
       if (flags3.includes("-")) text3 = text3.padEnd(width, " ");
       else if (flags3.includes("0") && /[diouxXfFeEgG]/u.test(specifier) && (precision === void 0 || /[fFeEgG]/u.test(specifier))) {
@@ -3384,14 +3384,14 @@ function filesystemCommands(maxDirectoryEntries) {
         else if (parsed.flags.has("F") && stat.type === "file" && stat.mode & 73) suffix2 = "*";
         if (parsed.flags.has("l")) {
           const size = parsed.flags.has("h") ? humanSize(stat.size, path) : String(stat.size);
-          const date = new Date(stat.mtimeMs).toISOString().slice(0, 16).replace("T", " ");
+          const date2 = new Date(stat.mtimeMs).toISOString().slice(0, 16).replace("T", " ");
           let target = "";
           if (stat.type === "symlink") {
             await admitFilesystemModes(context2, "ls", ["link"], [path]);
             needCapability(context2, "readlink");
             target = ` -> ${escapeText(await context2.fs.readlink(path, { signal: context2.signal }), "display")}`;
           }
-          await output(context2, `${modeText(stat)} ${stat.nlink ?? 1} ${stat.uid ?? 0} ${stat.gid ?? 0} ${size} ${date} ${escapeText(display2, "display")}${suffix2}${target}
+          await output(context2, `${modeText(stat)} ${stat.nlink ?? 1} ${stat.uid ?? 0} ${stat.gid ?? 0} ${size} ${date2} ${escapeText(display2, "display")}${suffix2}${target}
 `);
         } else await output(context2, `${escapeText(display2, "display")}${suffix2}
 `);
@@ -4152,7 +4152,7 @@ function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
         }
         let lineStart = true;
         let blankCount = 0;
-        let number5 = 1;
+        let number6 = 1;
         for await (const chunk of source2) {
           const transformed = [];
           const append = (text3) => {
@@ -4160,7 +4160,7 @@ function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
           };
           for (const byte of chunk) {
             if (lineStart && byte === 10 && parsed.flags.has("s") && blankCount > 0) continue;
-            if (lineStart && (parsed.flags.has("b") ? byte !== 10 : parsed.flags.has("n"))) append(`${String(number5++).padStart(6)}	`);
+            if (lineStart && (parsed.flags.has("b") ? byte !== 10 : parsed.flags.has("n"))) append(`${String(number6++).padStart(6)}	`);
             if (byte === 10) {
               if (parsed.flags.has("E")) transformed.push(36);
               transformed.push(10);
@@ -4654,7 +4654,7 @@ async function emitRecords(context2, records5, destination2) {
 }
 async function collectSortRecords(source2, delimiter, budget, signal, accept) {
   const pending = new RecordBuffer(bufferLimit);
-  const admit2 = (length) => {
+  const admit3 = (length) => {
     signal.throwIfAborted();
     budget.admit(length);
   };
@@ -4663,13 +4663,13 @@ async function collectSortRecords(source2, delimiter, budget, signal, accept) {
       let start = 0;
       for (let offset = 0; offset < chunk.length; offset++) {
         if (chunk[offset] !== delimiter) continue;
-        const accepted = accept(pending.finish(admit2, chunk, start, offset));
+        const accepted = accept(pending.finish(admit3, chunk, start, offset));
         if ((accepted instanceof Promise ? await accepted : accepted) === false) return false;
         start = offset + 1;
       }
       pending.append(chunk, start);
     }
-    if (pending.size) return await accept(pending.finish(admit2)) !== false;
+    if (pending.size) return await accept(pending.finish(admit3)) !== false;
     return true;
   } finally {
     pending.clear();
@@ -5017,7 +5017,7 @@ function predicateCommands() {
     const unary2 = /* @__PURE__ */ new Set(["-n", "-z", "-e", "-a", "-f", "-c", "-d", "-L", "-h", "-s", "-r", "-w", "-x"]);
     const binary3 = /* @__PURE__ */ new Set(["=", "==", "!=", "<", ">", "-eq", "-ne", "-lt", "-le", "-gt", "-ge", "-nt", "-ot", "-ef"]);
     let offset = 0;
-    const number5 = (text3) => {
+    const number6 = (text3) => {
       if (!/^[ \t]*[+-]?[0-9]+[ \t]*$/u.test(text3)) throw new UsageError(`integer expression expected: '${text3}'`);
       return BigInt(text3.trim());
     };
@@ -5053,8 +5053,8 @@ function predicateCommands() {
             if (identity2 !== "unknown") return identity2 === "same";
             return leftStat?.ino !== void 0 && rightStat?.ino !== void 0 && leftStat.type === rightStat.type && leftStat.ino === rightStat.ino && leftStat.dev === rightStat.dev;
           }
-          const leftNumber = number5(token);
-          const rightNumber = number5(right);
+          const leftNumber = number6(token);
+          const rightNumber = number6(right);
           if (operator === "-eq") return leftNumber === rightNumber;
           if (operator === "-ne") return leftNumber !== rightNumber;
           if (operator === "-lt") return leftNumber < rightNumber;
@@ -5449,7 +5449,7 @@ async function* argumentsFrom(source2, signal, delimiter, replacement = false) {
   let active = false;
   let escaped3 = false;
   let quote5 = "";
-  const parse18 = function* (text3) {
+  const parse19 = function* (text3) {
     for (const character of text3) {
       if (delimiter !== void 0) {
         if (character === delimiter) {
@@ -5490,9 +5490,9 @@ async function* argumentsFrom(source2, signal, delimiter, replacement = false) {
   };
   for await (const chunk of readBytes(source2, signal)) {
     signal.throwIfAborted();
-    yield* parse18(utf82.decode(chunk, { stream: true }));
+    yield* parse19(utf82.decode(chunk, { stream: true }));
   }
-  yield* parse18(utf82.decode());
+  yield* parse19(utf82.decode());
   if (quote5 || escaped3) throw new UsageError(quote5 ? "unmatched quote in input" : "trailing backslash in input");
   if (active) yield current;
 }
@@ -6123,9 +6123,9 @@ function findCommands(execute5, maxDirectoryEntries) {
         index++;
       } else if (args[index] === "-maxdepth" || args[index] === "-mindepth") {
         if (args[index + 1] === void 0) throw new UsageError(`${args[index]} requires a number`);
-        const number5 = integer(args[index + 1]);
-        if (args[index] === "-maxdepth") maxDepth = number5;
-        else minDepth = number5;
+        const number6 = integer(args[index + 1]);
+        if (args[index] === "-maxdepth") maxDepth = number6;
+        else minDepth = number6;
         args.splice(index, 2);
         values.splice(index, 2);
       } else if (args[index] === "-depth") {
@@ -6321,7 +6321,7 @@ function findCommands(execute5, maxDirectoryEntries) {
     };
     const evaluate = args.length ? disjunction() : async () => true;
     if (offset !== args.length) throw new UsageError(`unexpected expression '${args[offset]}'`);
-    for (const prepare of formats2) await prepare();
+    for (const prepare2 of formats2) await prepare2();
     if (deletes && prunes && !explicitDepth) throw new PublicDiagnostic("-delete implies -depth; -prune is ineffective unless -depth is explicitly supplied");
     for (const reference of references.keys()) {
       context2.signal.throwIfAborted();
@@ -6958,15 +6958,15 @@ function widthValue(text3, maximum, unicode) {
   while (text3.charCodeAt(offset) === 32 || text3.charCodeAt(offset) >= 9 && text3.charCodeAt(offset) <= 13) offset++;
   if (text3[offset] === "+") offset++;
   const start = offset;
-  let number5 = 0;
+  let number6 = 0;
   while (text3.charCodeAt(offset) >= 48 && text3.charCodeAt(offset) <= 57) {
-    number5 = Math.min(1073741824, number5 * 10 + text3.charCodeAt(offset++) - 48);
+    number6 = Math.min(1073741824, number6 * 10 + text3.charCodeAt(offset++) - 48);
   }
-  if (offset === start || offset !== text3.length || number5 > maximum) {
-    const range3 = offset === text3.length && offset !== start && number5 > maximum;
-    throw new PublicDiagnostic(`invalid width: ${quote(Uint8Array.from(text3, (unit2) => unit2.charCodeAt(0)), false, unicode)}${range3 ? number5 > 1073741823 ? ": Value too large for defined data type" : ": Numerical result out of range" : ""}`);
+  if (offset === start || offset !== text3.length || number6 > maximum) {
+    const range3 = offset === text3.length && offset !== start && number6 > maximum;
+    throw new PublicDiagnostic(`invalid width: ${quote(Uint8Array.from(text3, (unit2) => unit2.charCodeAt(0)), false, unicode)}${range3 ? number6 > 1073741823 ? ": Value too large for defined data type" : ": Numerical result out of range" : ""}`);
   }
-  return number5;
+  return number6;
 }
 function parse3(context2) {
   const settings17 = { width: 75, goal: 70, crown: false, tagged: false, split: false, uniform: false, prefix: new Uint8Array(), leading: 0, fullPrefix: 0, files: [] };
@@ -10291,8 +10291,8 @@ function parse4(context2) {
     else if (key === "z") settings17.separator = 0;
     else if (key === "help" || key === "version") settings17.information = key;
     else if (key === "n") {
-      const number5 = decimal(value2, true, unicode);
-      if (number5 < settings17.count) settings17.count = number5;
+      const number6 = decimal(value2, true, unicode);
+      if (number6 < settings17.count) settings17.count = number6;
     } else if (key === "i") {
       if (settings17.range) throw new ShufDiagnostic("multiple -i options specified");
       const dash = value2.indexOf("-");
@@ -13763,10 +13763,10 @@ function parse6(source2, extended, separator, maxProgramInstructions) {
   };
   const address = () => {
     horizontal();
-    const number5 = /^[0-9]+/u.exec(source2.slice(offset));
-    if (number5) {
-      offset += number5[0].length;
-      const value2 = Number(number5[0]);
+    const number6 = /^[0-9]+/u.exec(source2.slice(offset));
+    if (number6) {
+      offset += number6[0].length;
+      const value2 = Number(number6[0]);
       if (!Number.isSafeInteger(value2) || value2 < 1) throw new ProgramError("sed line addresses must be positive integers");
       return { kind: "number", number: value2 };
     }
@@ -13966,7 +13966,7 @@ async function execute2(program, context2, files, quiet, budget, separator, outp
     const next = await peekNext();
     return !next.done && next.value.fileIndex !== record4.fileIndex ? { ...record4, terminated: true } : record4;
   };
-  let number5 = 0;
+  let number6 = 0;
   let hold = "";
   let holdTerminated = true;
   const joinSpace = (left, right) => {
@@ -13987,7 +13987,7 @@ async function execute2(program, context2, files, quiet, budget, separator, outp
   try {
     while (!current.done) {
       budget.step();
-      number5++;
+      number6++;
       let record4 = await prepareRecord(current.value);
       let pattern = record4.text;
       const appended = [];
@@ -14038,7 +14038,7 @@ async function execute2(program, context2, files, quiet, budget, separator, outp
         if (terminated) outputState.unterminatedFiles.delete(path);
         else outputState.unterminatedFiles.add(path);
       };
-      const matches3 = async (address) => address.kind === "number" ? number5 === address.number : address.kind === "last" ? (await peekNext()).done === true : await getPattern(address.pattern).find(pattern, budget) !== void 0;
+      const matches3 = async (address) => address.kind === "number" ? number6 === address.number : address.kind === "last" ? (await peekNext()).done === true : await getPattern(address.pattern).find(pattern, budget) !== void 0;
       for (let pc = 0; pc < program.length; ) {
         budget.step();
         await budget.checkpoint();
@@ -14048,13 +14048,13 @@ async function execute2(program, context2, files, quiet, budget, separator, outp
         if (instruction.first) {
           if (instruction.second) {
             if (active.has(pc)) {
-              if (instruction.second.kind === "number" && number5 > instruction.second.number) selected = false;
-              ending = instruction.second.kind === "number" ? number5 >= instruction.second.number : await matches3(instruction.second);
+              if (instruction.second.kind === "number" && number6 > instruction.second.number) selected = false;
+              ending = instruction.second.kind === "number" ? number6 >= instruction.second.number : await matches3(instruction.second);
               if (ending) active.delete(pc);
             } else {
               selected = await matches3(instruction.first);
               if (selected) {
-                ending = instruction.second.kind === "number" && number5 >= instruction.second.number || instruction.second.kind === "last" && (await peekNext()).done === true;
+                ending = instruction.second.kind === "number" && number6 >= instruction.second.number || instruction.second.kind === "last" && (await peekNext()).done === true;
                 if (!ending) active.add(pc);
               }
             }
@@ -14075,7 +14075,7 @@ async function execute2(program, context2, files, quiet, budget, separator, outp
             break;
           }
           case "=":
-            await emit2(`${number5}${separator}`);
+            await emit2(`${number6}${separator}`);
             break;
           case "l": {
             const escapes = { "\x07": "\\a", "\b": "\\b", "\f": "\\f", "\n": "\\n", "\r": "\\r", "	": "\\t", "\v": "\\v", "\\": "\\\\" };
@@ -14203,7 +14203,7 @@ async function execute2(program, context2, files, quiet, budget, separator, outp
               return { status: 0, quit: false };
             }
             record4 = await prepareRecord(next.value);
-            number5++;
+            number6++;
             pattern = instruction.kind === "N" ? joinSpace(pattern, record4.text) : record4.text;
             substituted = false;
             break;
@@ -14338,7 +14338,7 @@ var AwkArray = class {
   entries = /* @__PURE__ */ new Map();
 };
 var unset = Object.freeze({ kind: "unset" });
-var numeric = (number5) => ({ kind: "number", number: number5 });
+var numeric = (number6) => ({ kind: "number", number: number6 });
 var string = (text3) => ({ kind: "string", text: text3 });
 function inputValue(text3) {
   return /^[ \t\r\n]*[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?[ \t\r\n]*$/u.test(text3) ? { kind: "numeric", text: text3, number: Number(text3) } : string(text3);
@@ -14366,28 +14366,28 @@ function general2(value2, precision, alternate) {
   return result2;
 }
 var formatPattern = /^%([-+ #0]*)(\*|[0-9]+)?(?:\.(\*|[0-9]*))?([csdiuoxXfFeEgG])/u;
-function validateFormat(format2) {
-  for (let offset = 0; offset < format2.length; ) {
-    if (format2[offset] !== "%") {
+function validateFormat(format3) {
+  for (let offset = 0; offset < format3.length; ) {
+    if (format3[offset] !== "%") {
       offset++;
       continue;
     }
-    if (format2[offset + 1] === "%") {
+    if (format3[offset + 1] === "%") {
       offset += 2;
       continue;
     }
-    const match = formatPattern.exec(format2.slice(offset));
-    if (!match) throw new ProgramError(`unsupported format near '${format2.slice(offset)}'`);
+    const match = formatPattern.exec(format3.slice(offset));
+    if (!match) throw new ProgramError(`unsupported format near '${format3.slice(offset)}'`);
     offset += match[0].length;
     if (match[2] !== "*" && Number(match[2] ?? 0) > 1e6 || match[3] !== "*" && Number(match[3] ?? 0) > (/[fFeEgG]/u.test(match[4]) ? 100 : 1e6)) throw new ProgramError("excessive format width or precision");
   }
 }
-function formatted(format2, values, text3, budget) {
-  budget?.step(format2.length);
+function formatted(format3, values, text3, budget) {
+  budget?.step(format3.length);
   let result2 = "";
   let argument2 = 0;
   const limit = Math.min(budget?.maxBufferBytes ?? 32 * 1024 * 1024, 32 * 1024 * 1024);
-  const admit2 = (length) => {
+  const admit3 = (length) => {
     budget?.step(0);
     if (length > limit - result2.length) throw new ProgramError(budget && budget.maxBufferBytes < 32 * 1024 * 1024 ? "text buffer limit exceeded" : "formatted output exceeds buffer limit");
     budget?.step(length);
@@ -14401,20 +14401,20 @@ function formatted(format2, values, text3, budget) {
     if (value2 === void 0) throw new ProgramError("not enough arguments for format");
     return value2;
   };
-  for (let offset = 0; offset < format2.length; ) {
-    if (format2[offset] !== "%") {
-      admit2(1);
-      result2 += format2[offset++];
+  for (let offset = 0; offset < format3.length; ) {
+    if (format3[offset] !== "%") {
+      admit3(1);
+      result2 += format3[offset++];
       continue;
     }
-    if (format2[offset + 1] === "%") {
-      admit2(1);
+    if (format3[offset + 1] === "%") {
+      admit3(1);
       result2 += "%";
       offset += 2;
       continue;
     }
-    const match = formatPattern.exec(format2.slice(offset));
-    if (!match) throw new ProgramError(`unsupported format near '${format2.slice(offset)}'`);
+    const match = formatPattern.exec(format3.slice(offset));
+    if (!match) throw new ProgramError(`unsupported format near '${format3.slice(offset)}'`);
     offset += match[0].length;
     let flags3 = match[1];
     let width = match[2] === "*" ? Math.trunc(amountOf(take())) : Number(match[2] ?? 0);
@@ -14430,10 +14430,10 @@ function formatted(format2, values, text3, budget) {
     let part;
     if (conversion === "s") {
       const source2 = text3(value2);
-      admit2(Math.min(source2.length, precision ?? source2.length));
+      admit3(Math.min(source2.length, precision ?? source2.length));
       part = source2.slice(0, precision);
     } else if (conversion === "c") {
-      admit2(1);
+      admit3(1);
       part = value2.kind === "string" ? value2.text[0] ?? "\0" : String.fromCharCode(Math.trunc(amountOf(value2)) & 255);
     } else {
       const amount = amountOf(value2);
@@ -14448,46 +14448,46 @@ function formatted(format2, values, text3, budget) {
         part = (/[uoxX]/u.test(conversion) ? BigInt.asUintN(32, integer10) : integer10).toString(radix);
         if (precision !== void 0) {
           const negative = part.startsWith("-");
-          admit2(amount === 0 && precision === 0 ? 0 : Math.max(part.length, precision + Number(negative)));
+          admit3(amount === 0 && precision === 0 ? 0 : Math.max(part.length, precision + Number(negative)));
           part = amount === 0 && precision === 0 ? "" : negative ? `-${part.slice(1).padStart(precision, "0")}` : part.padStart(precision, "0");
         }
         if (flags3.includes("#") && amount !== 0) {
           const prefix3 = radix === 16 ? "0x" : radix === 8 ? "0" : "";
-          admit2(prefix3.length + part.length);
+          admit3(prefix3.length + part.length);
           part = prefix3 + part;
         }
       }
-      admit2(part.length);
+      admit3(part.length);
       part = part.replace(/e([+-])([0-9])$/u, "e$10$2");
       if (/[XFEG]/u.test(conversion)) {
-        admit2(part.length);
+        admit3(part.length);
         part = part.toUpperCase();
       }
       if (amount >= 0 && !/[uoxX]/u.test(conversion)) {
         const prefix3 = flags3.includes("+") ? "+" : flags3.includes(" ") ? " " : "";
-        admit2(prefix3.length + part.length);
+        admit3(prefix3.length + part.length);
         part = prefix3 + part;
       }
       if (flags3.includes("#") && /[fFeE]/u.test(conversion)) {
         budget?.step(part.length);
         if (!part.includes(".")) {
-          admit2(part.length + 1);
+          admit3(part.length + 1);
           part = part.replace(/([eE]|$)/u, ".$1");
         }
       }
     }
-    admit2(Math.max(part.length, width));
+    admit3(Math.max(part.length, width));
     if (flags3.includes("-")) part = part.padEnd(width, " ");
     else if (flags3.includes("0") && /[diuoxXfFeEgG]/u.test(conversion) && (precision === void 0 || /[fFeEgG]/u.test(conversion))) {
       const prefix3 = /^(?:[+ -]|0[xX])/u.exec(part)?.[0] ?? "";
       part = prefix3 + part.slice(prefix3.length).padStart(Math.max(0, width - prefix3.length), "0");
     } else part = part.padStart(width, " ");
-    admit2(part.length);
+    admit3(part.length);
     result2 += part;
   }
   return result2;
 }
-function text(value2, format2 = "%.6g", budget) {
+function text(value2, format3 = "%.6g", budget) {
   if (value2.kind === "unset") return "";
   if (value2.kind !== "number") return value2.text;
   if (Number.isInteger(value2.number) && Math.abs(value2.number) < 1e21) {
@@ -14497,16 +14497,16 @@ function text(value2, format2 = "%.6g", budget) {
     budget?.step(result2.length);
     return result2;
   }
-  return formatted(format2, [value2], (argument2) => String(number(argument2)), budget);
+  return formatted(format3, [value2], (argument2) => String(number(argument2)), budget);
 }
-function compare3(left, right, format2, budget) {
+function compare3(left, right, format3, budget) {
   if (left.kind !== "string" && right.kind !== "string") {
     const first2 = number(left);
     const second2 = number(right);
     return first2 < second2 ? -1 : first2 > second2 ? 1 : 0;
   }
-  const first = text(left, format2, budget);
-  const second = text(right, format2, budget);
+  const first = text(left, format3, budget);
+  const second = text(right, format3, budget);
   return first < second ? -1 : first > second ? 1 : 0;
 }
 
@@ -14563,11 +14563,11 @@ var Lexer = class {
       this.offset += name2.length;
       return { kind: "name", text: name2, offset };
     }
-    const number5 = /^(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?/u.exec(rest)?.[0];
-    if (number5) {
-      if (!Number.isFinite(Number(number5))) throw new ProgramError("non-finite numeric literal");
-      this.offset += number5.length;
-      return { kind: "number", text: number5, offset };
+    const number6 = /^(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?/u.exec(rest)?.[0];
+    if (number6) {
+      if (!Number.isFinite(Number(number6))) throw new ProgramError("non-finite numeric literal");
+      this.offset += number6.length;
+      return { kind: "number", text: number6, offset };
     }
     if (rest[0] === '"') {
       this.offset++;
@@ -16923,7 +16923,7 @@ async function diagnostic2(context2, error) {
 async function* lines2(source2, limits, state, binary3, nullData) {
   let pending = import_buffer.Buffer.alloc(0);
   let offset = 0;
-  let number5 = 0;
+  let number6 = 0;
   const delimiter = nullData ? 0 : 10;
   for await (const data2 of readBytes(source2, limits.signal)) {
     await limits.tick();
@@ -16943,7 +16943,7 @@ async function* lines2(source2, limits, state, binary3, nullData) {
       const content = import_buffer.Buffer.concat([pending, chunk.subarray(start, end)]);
       const bytes3 = import_buffer.Buffer.concat([content, import_buffer.Buffer.from([delimiter])]);
       state.bytesSearched = offset + bytes3.length;
-      yield { content, bytes: bytes3, number: ++number5, offset };
+      yield { content, bytes: bytes3, number: ++number6, offset };
       offset += bytes3.length;
       pending = import_buffer.Buffer.alloc(0);
       start = end + 1;
@@ -16953,7 +16953,7 @@ async function* lines2(source2, limits, state, binary3, nullData) {
   }
   if (pending.length) {
     state.bytesSearched = offset + pending.length;
-    yield { bytes: pending, content: pending, number: ++number5, offset };
+    yield { bytes: pending, content: pending, number: ++number6, offset };
   }
 }
 
@@ -17499,7 +17499,7 @@ function createGrepCommands(executor) {
       const patterns2 = [];
       let patternCount = 0;
       let patternBytes = 0;
-      const admit2 = (chunk, atStart) => {
+      const admit3 = (chunk, atStart) => {
         context2.signal.throwIfAborted();
         const size = typeof chunk === "string" ? import_buffer.Buffer.byteLength(chunk) : chunk.length;
         if (size > bufferLimit - patternBytes) throw new UsageError(`pattern byte limit exceeded (${bufferLimit} bytes)`);
@@ -17514,7 +17514,7 @@ function createGrepCommands(executor) {
         return atStart;
       };
       const addArgument = async (pattern) => {
-        admit2(pattern, true);
+        admit3(pattern, true);
         if (pattern === "") {
           if (++patternCount > maxPatternCount) throw new UsageError(`pattern count limit exceeded (${maxPatternCount})`);
           patterns2.push("");
@@ -17525,7 +17525,7 @@ function createGrepCommands(executor) {
       async function* admitted(source2) {
         let atStart = true;
         for await (const chunk of source2) {
-          atStart = admit2(chunk, atStart);
+          atStart = admit3(chunk, atStart);
           yield chunk;
         }
       }
@@ -17554,9 +17554,9 @@ function createGrepCommands(executor) {
       let failed = false;
       for (const name2 of names) {
         let count2 = 0;
-        let number5 = 0;
+        let number6 = 0;
         const named2 = name2 === "-" ? "(standard input)" : name2;
-        const prefix3 = (lineNumber = false) => `${!parsed.flags.has("h") && (parsed.flags.has("H") || names.length > 1) ? `${named2}:` : ""}${lineNumber && parsed.flags.has("n") ? `${number5}:` : ""}`;
+        const prefix3 = (lineNumber = false) => `${!parsed.flags.has("h") && (parsed.flags.has("H") || names.length > 1) ? `${named2}:` : ""}${lineNumber && parsed.flags.has("n") ? `${number6}:` : ""}`;
         try {
           const available2 = new AvailableRecords(parsed.flags.has("z") ? 0 : 10, bufferLimit);
           const source2 = name2 === "-" ? input(context2) : requiredFileInput(context2, grepRequirements, "file", name2, bufferLimit);
@@ -17565,7 +17565,7 @@ function createGrepCommands(executor) {
             for (let index = 0; index < batch.length; index++) {
               const line = batch[index];
               context2.signal.throwIfAborted();
-              number5++;
+              number6++;
               const found = results[index];
               if (found.length > 0 === parsed.flags.has("v")) continue;
               count2++;
@@ -17625,9 +17625,9 @@ init_platform();
 // packages/safe-bash/src/commands/bytes/encoding/shared.ts
 init_platform();
 var blockSize = 8192;
-function validatedOption(parsed, key, parse18, fallback) {
+function validatedOption(parsed, key, parse19, fallback) {
   let result2 = fallback;
-  for (const text3 of parsed.values.get(key) ?? []) result2 = parse18(text3);
+  for (const text3 of parsed.values.get(key) ?? []) result2 = parse19(text3);
   return result2;
 }
 async function* sources(context2, operands, maxInputBytes) {
@@ -17769,7 +17769,7 @@ function decodeQuantum(quantum, alphabet) {
     }
     carry &= (1 << bits) - 1;
   }
-  return { bytes: decoded, valid: quantum.length === alphabet.quantum && alphabet.lengths.includes(length) && quantum.slice(length).every((number5) => number5 === -1) && carry === 0 };
+  return { bytes: decoded, valid: quantum.length === alphabet.quantum && alphabet.lengths.includes(length) && quantum.slice(length).every((number6) => number6 === -1) && carry === 0 };
 }
 async function decode(context2, files, alphabet, ignore, maxInputBytes) {
   const lookup = new Int16Array(256).fill(-2);
@@ -17831,27 +17831,27 @@ function formats(text3) {
   if (!result2.length) throw new UsageError("empty output type");
   return result2;
 }
-function formatRow(row, format2, bigEndian) {
+function formatRow(row, format3, bigEndian) {
   let text3 = "";
   const escapes = { 0: "\\0", 7: "\\a", 8: "\\b", 9: "\\t", 10: "\\n", 11: "\\v", 12: "\\f", 13: "\\r" };
-  for (let offset = 0; offset < row.length; offset += format2.size) {
-    if (format2.kind === "c") {
+  for (let offset = 0; offset < row.length; offset += format3.size) {
+    if (format3.kind === "c") {
       const byte = row[offset];
       const character = escapes[byte] ?? (byte >= 32 && byte <= 126 ? String.fromCharCode(byte) : byte.toString(8).padStart(3, "0"));
       text3 += ` ${character.padStart(3)}`;
       continue;
     }
-    let number5 = 0n;
-    for (let index = 0; index < format2.size; index++) {
+    let number6 = 0n;
+    for (let index = 0; index < format3.size; index++) {
       const byte = row[offset + index] ?? 0;
-      const shift = bigEndian ? format2.size - index - 1 : index;
-      number5 |= BigInt(byte) << BigInt(shift * 8);
+      const shift = bigEndian ? format3.size - index - 1 : index;
+      number6 |= BigInt(byte) << BigInt(shift * 8);
     }
-    const bits = format2.size * 8;
-    if (format2.kind === "d" && number5 >= 1n << BigInt(bits - 1)) number5 -= 1n << BigInt(bits);
-    const base = format2.kind === "o" ? 8 : format2.kind === "x" ? 16 : 10;
-    const width = format2.kind === "o" ? Math.ceil(bits / 3) : format2.kind === "x" ? bits / 4 : format2.kind === "d" ? (1n << BigInt(bits - 1)).toString().length + 1 : ((1n << BigInt(bits)) - 1n).toString().length;
-    text3 += ` ${number5.toString(base).padStart(width, base === 10 ? " " : "0")}`;
+    const bits = format3.size * 8;
+    if (format3.kind === "d" && number6 >= 1n << BigInt(bits - 1)) number6 -= 1n << BigInt(bits);
+    const base = format3.kind === "o" ? 8 : format3.kind === "x" ? 16 : 10;
+    const width = format3.kind === "o" ? Math.ceil(bits / 3) : format3.kind === "x" ? bits / 4 : format3.kind === "d" ? (1n << BigInt(bits - 1)).toString().length + 1 : ((1n << BigInt(bits)) - 1n).toString().length;
+    text3 += ` ${number6.toString(base).padStart(width, base === 10 ? " " : "0")}`;
   }
   return text3;
 }
@@ -17904,9 +17904,9 @@ function createOdCommand(maxInputBytes) {
     const selected = (parsed.values.get("t") ?? ["o2"]).flatMap(formats);
     if (selected.length > 16) throw new UsageError("at most 16 output types are supported");
     const width = validatedOption(parsed, "w", (text3) => {
-      const number5 = numeric2(text3);
-      if (number5 < 1 || number5 > 4096 || selected.some((format2) => number5 % format2.size !== 0)) throw new UsageError("width must be 1..4096 and a multiple of each output type size");
-      return number5;
+      const number6 = numeric2(text3);
+      if (number6 < 1 || number6 > 4096 || selected.some((format3) => number6 % format3.size !== 0)) throw new UsageError("width must be 1..4096 and a multiple of each output type size");
+      return number6;
     }, 16);
     const skip = validatedOption(parsed, "j", (text3) => numeric2(text3, true), 0);
     const count2 = validatedOption(parsed, "N", (text3) => numeric2(text3, true), Infinity);
@@ -18016,14 +18016,14 @@ function createXxdCommand(maxInputBytes) {
     const plain = parsed.flags.has("p");
     const reverse = parsed.flags.has("r");
     const columns = validatedOption(parsed, "c", (text3) => {
-      const number5 = numeric2(text3);
-      if (!plain && (number5 < 1 || number5 > 256) || plain && number5 > 4096) throw new UsageError("columns must be 1..256 (plain: 0..4096)");
-      return number5;
+      const number6 = numeric2(text3);
+      if (!plain && (number6 < 1 || number6 > 256) || plain && number6 > 4096) throw new UsageError("columns must be 1..256 (plain: 0..4096)");
+      return number6;
     }, plain ? 30 : 16);
     const group = validatedOption(parsed, "g", (text3) => {
-      const number5 = numeric2(text3);
-      if (number5 > 256) throw new UsageError("group size must be 0..256");
-      return number5;
+      const number6 = numeric2(text3);
+      if (number6 > 256) throw new UsageError("group size must be 0..256");
+      return number6;
     }, 2);
     const skip = validatedOption(parsed, "s", numeric2, 0);
     const count2 = validatedOption(parsed, "l", numeric2, Infinity);
@@ -22322,9 +22322,9 @@ async function* codec(input3, options3, signal) {
   if (!Number.isSafeInteger(requestedSize) || requestedSize <= 0) throw new RangeError("invalid codec chunk size");
   const chunkSize2 = Math.min(requestedSize, 64 * 1024);
   let output2 = new Uint8Array(chunkSize2);
-  const encoding = options3.mode === "gzip";
+  const encoding = options3.mode === "gzip" || options3.mode === "deflate-raw";
   const stream = new ZStream();
-  const initialized = encoding ? deflateInit2(stream, options3.level ?? 6, 8, 31, 8, 0, true) : inflateInit2(stream, options3.mode === "inflate-raw" ? -15 : 31);
+  const initialized = encoding ? deflateInit2(stream, options3.level ?? 6, 8, options3.mode === "deflate-raw" ? -15 : 31, 8, 0, true) : inflateInit2(stream, options3.mode === "inflate-raw" ? -15 : 31);
   if (initialized !== Z_OK) {
     if (encoding) deflateEnd(stream);
     else inflateEnd(stream);
@@ -23240,9 +23240,9 @@ async function contextSide(changes, start, end, kind, budget, append) {
     }
   }
 }
-async function contextual(changes, format2, oldLabel, newLabel, context2, budget, append) {
+async function contextual(changes, format3, oldLabel, newLabel, context2, budget, append) {
   context2 = Math.min(context2, changes.length);
-  append(format2 === "unified" ? `--- ${oldLabel}
+  append(format3 === "unified" ? `--- ${oldLabel}
 +++ ${newLabel}
 ` : `*** ${oldLabel}
 --- ${newLabel}
@@ -23288,7 +23288,7 @@ async function contextual(changes, format2, oldLabel, newLabel, context2, budget
       await budget.checkpoint();
     }
     budget.hunk();
-    if (format2 === "unified") {
+    if (format3 === "unified") {
       append(`@@ -${unifiedRange(oldPosition, oldCount)} +${unifiedRange(newPosition, newCount)} @@
 `);
       for (let index = start; index < end; index++) {
@@ -23322,15 +23322,15 @@ function contextLength(value2) {
 function flags(args) {
   const result2 = { format: "normal", whitespace: "exact", context: 0, brief: false, recursive: false, newFile: false, labels: [], files: [] };
   let selectedFormat;
-  const selectFormat = (format2) => {
-    if (selectedFormat !== void 0 && selectedFormat !== format2) throw new ToolError("conflicting output format options");
-    selectedFormat = result2.format = format2;
+  const selectFormat = (format3) => {
+    if (selectedFormat !== void 0 && selectedFormat !== format3) throw new ToolError("conflicting output format options");
+    selectedFormat = result2.format = format3;
   };
   let explicitContext = false;
   let legacyContext = -1;
   let previousDigit = false;
-  const selectContext = (format2, width, explicit) => {
-    selectFormat(format2);
+  const selectContext = (format3, width, explicit) => {
+    selectFormat(format3);
     result2.context = Math.max(result2.context, width);
     explicitContext ||= explicit;
   };
@@ -24085,7 +24085,7 @@ async function context(reader) {
   }
   return output2.join("");
 }
-async function parsePatch(text3, budget, format2, target, progress) {
+async function parsePatch(text3, budget, format3, target, progress) {
   if (text3 && !text3.endsWith("\n")) throw new ToolError("patch is truncated: missing final LF");
   const reader = new Reader2(text3, budget);
   const patches = [];
@@ -24112,7 +24112,7 @@ async function parsePatch(text3, budget, format2, target, progress) {
       while (/^diff /u.test(reader.peek() ?? "")) await reader.take();
       const first = reader.peek() ?? "";
       const detected = first.startsWith("*** ") ? "context" : /^\d/u.test(first) ? "normal" : "unified";
-      if (format2 && detected !== format2) throw new ToolError(`patch format is ${detected}, not requested ${format2}`);
+      if (format3 && detected !== format3) throw new ToolError(`patch format is ${detected}, not requested ${format3}`);
       if (detected === "unified") {
         reader.index = start;
         patches.push(...(await parseUnifiedSection(reader, budget)).map((patch) => ({ ...patch, ...indexPath === void 0 ? {} : { indexPath } })));
@@ -24208,8 +24208,8 @@ async function backupName(path, budget) {
     const version = entry.name.slice(prefix3.length, -1);
     if (version.length > 4096) throw new ToolError("backup version length limit exceeded");
     if (!/^[1-9]\d*$/u.test(version)) continue;
-    const number5 = BigInt(version);
-    if (number5 > maximum) maximum = number5;
+    const number6 = BigInt(version);
+    if (number6 > maximum) maximum = number6;
   }
   return maximum ? `${path}.~${maximum + 1n}~` : `${path}.orig`;
 }
@@ -24404,8 +24404,8 @@ ${context2 ? "---" : "+++"} ${names[1]}${times[1]}
 function flags2(args) {
   const result2 = { input: "-", reverse: false, dryRun: false, atomic: false, quiet: false, force: false, backup: true, fuzz: 2, ignoreWhitespace: false, removeEmpty: false };
   const operands = [];
-  const select = (format2) => {
-    result2.format = format2;
+  const select = (format3) => {
+    result2.format = format3;
   };
   let literal = false;
   for (let index = 0; index < args.length; index++) {
@@ -24918,7 +24918,7 @@ function createChmodCommand(configuration = {}) {
 init_platform();
 function parse9(args) {
   let follow = false;
-  let format2;
+  let format3;
   let printf = false;
   let literal = false;
   const paths = [];
@@ -24929,14 +24929,14 @@ function parse9(args) {
     else if (argument2 === "--dereference") follow = true;
     else if (argument2 === "--format" || argument2.startsWith("--format=") || argument2 === "--printf" || argument2.startsWith("--printf=")) {
       printf = argument2.startsWith("--printf");
-      format2 = argument2.includes("=") ? argument2.slice(argument2.indexOf("=") + 1) : args[++index];
-      if (format2 === void 0) throw new UsageError(`missing format for '${argument2}'`);
+      format3 = argument2.includes("=") ? argument2.slice(argument2.indexOf("=") + 1) : args[++index];
+      if (format3 === void 0) throw new UsageError(`missing format for '${argument2}'`);
     } else if (!argument2.startsWith("--")) {
       for (let offset = 1; offset < argument2.length; offset++) {
         if (argument2[offset] === "L") follow = true;
         else if (argument2[offset] === "c") {
-          format2 = argument2.slice(offset + 1) || args[++index];
-          if (format2 === void 0) throw new UsageError("missing format for '-c'");
+          format3 = argument2.slice(offset + 1) || args[++index];
+          if (format3 === void 0) throw new UsageError("missing format for '-c'");
           printf = false;
           break;
         } else throw new UsageError(`unrecognized option '${argument2}'`);
@@ -24944,7 +24944,7 @@ function parse9(args) {
     } else throw new UsageError(`unrecognized option '${argument2}'`);
   }
   requireOperands(paths);
-  return { follow, format: format2, printf, paths };
+  return { follow, format: format3, printf, paths };
 }
 function quoted(text3, style2) {
   if (style2 === "literal") return text3;
@@ -24977,9 +24977,9 @@ function timestamp2(milliseconds) {
   const nanoseconds = value2 < 0 ? -magnitude : magnitude;
   const remainder = (nanoseconds % 1000000000n + 1000000000n) % 1000000000n;
   const seconds = (nanoseconds - remainder) / 1000000000n;
-  const date = new Date(Number(seconds * 1000n));
-  if (Number.isNaN(date.getTime())) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
-  return `${date.toISOString().replace("T", " ").replace(/\.\d{3}Z$/u, `.${remainder.toString().padStart(9, "0")}`)} +0000`;
+  const date2 = new Date(Number(seconds * 1000n));
+  if (Number.isNaN(date2.getTime())) throw new FsError("EIO", { message: "invalid filesystem timestamp" });
+  return `${date2.toISOString().replace("T", " ").replace(/\.\d{3}Z$/u, `.${remainder.toString().padStart(9, "0")}`)} +0000`;
 }
 function epoch(milliseconds, precision) {
   if (precision > 3) throw new FsError("ENOTSUP", { message: "stat timestamps support at most millisecond precision" });
@@ -24990,21 +24990,21 @@ function epoch(milliseconds, precision) {
   const seconds = value2 < 0 && fraction === 0 ? -Math.floor(value2 / 1e3) : Math.floor(absolute2 / scale);
   return `${value2 < 0 ? "-" : ""}${seconds}${precision ? "." + fraction.toString().padStart(precision, "0") : ""}`;
 }
-function directive(format2, start) {
+function directive(format3, start) {
   let index = start + 1;
   const flagsStart = index;
-  while (index < format2.length && "-+ #0".includes(format2[index])) index++;
-  const flags3 = format2.slice(flagsStart, index);
+  while (index < format3.length && "-+ #0".includes(format3[index])) index++;
+  const flags3 = format3.slice(flagsStart, index);
   const widthStart = index;
-  while (index < format2.length && format2[index] >= "0" && format2[index] <= "9") index++;
-  const width = format2.slice(widthStart, index);
+  while (index < format3.length && format3[index] >= "0" && format3[index] <= "9") index++;
+  const width = format3.slice(widthStart, index);
   let precision;
-  if (format2[index] === ".") {
+  if (format3[index] === ".") {
     const precisionStart = ++index;
-    while (index < format2.length && format2[index] >= "0" && format2[index] <= "9") index++;
-    precision = format2.slice(precisionStart, index);
+    while (index < format3.length && format3[index] >= "0" && format3[index] <= "9") index++;
+    precision = format3.slice(precisionStart, index);
   }
-  const code = format2[index];
+  const code = format3[index];
   if (code === void 0) throw new UsageError("invalid stat format directive");
   const codePoint = code.charCodeAt(0);
   if (code !== "%" && !(codePoint >= 65 && codePoint <= 90) && !(codePoint >= 97 && codePoint <= 122)) {
@@ -25036,7 +25036,7 @@ function formatField(text3, code, flags3, width, precision, numeric4, epoch2) {
   }
   return import_buffer.Buffer.concat([import_buffer.Buffer.alloc(padding, 32), bytes3]);
 }
-async function render(context2, path, name2, stat, format2, escapes, limit) {
+async function render(context2, path, name2, stat, format3, escapes, limit) {
   const chunks = [];
   let bytes3 = 0;
   const append = (text3) => {
@@ -25045,11 +25045,11 @@ async function render(context2, path, name2, stat, format2, escapes, limit) {
     if (bytes3 > limit) throw new FsError("EFBIG", { message: "stat format output limit exceeded" });
     chunks.push(chunk);
   };
-  for (let index = 0; index < format2.length; ) {
+  for (let index = 0; index < format3.length; ) {
     context2.signal.throwIfAborted();
-    if (escapes && format2[index] === "\\") {
+    if (escapes && format3[index] === "\\") {
       const named2 = { a: "\x07", b: "\b", e: "\x1B", f: "\f", n: "\n", r: "\r", t: "	", v: "\v", "\\": "\\" };
-      const code2 = format2[index + 1] ?? "";
+      const code2 = format3[index + 1] ?? "";
       if (Object.hasOwn(named2, code2)) {
         append(named2[code2]);
         index += 2;
@@ -25057,30 +25057,30 @@ async function render(context2, path, name2, stat, format2, escapes, limit) {
       }
       const radix = code2 === "x" ? 16 : 8;
       const start = index + (radix === 16 ? 2 : 1);
-      const end = Math.min(format2.length, start + (radix === 16 ? 2 : 3));
+      const end = Math.min(format3.length, start + (radix === 16 ? 2 : 3));
       let offset = start;
       let value2 = 0;
       while (offset < end) {
-        const digit3 = "0123456789abcdef".indexOf(format2[offset].toLowerCase());
+        const digit3 = "0123456789abcdef".indexOf(format3[offset].toLowerCase());
         if (digit3 < 0 || digit3 >= radix) break;
         value2 = value2 * radix + digit3;
         offset++;
       }
       if (offset === start) {
-        append(format2[index++]);
+        append(format3[index++]);
         continue;
       }
       append(Uint8Array.of(value2));
       index = offset;
       continue;
     }
-    if (format2[index] !== "%") {
-      const point = String.fromCodePoint(format2.codePointAt(index));
+    if (format3[index] !== "%") {
+      const point = String.fromCodePoint(format3.codePointAt(index));
       append(point);
       index += point.length;
       continue;
     }
-    const parsed = directive(format2, index);
+    const parsed = directive(format3, index);
     index += parsed.length;
     const { code, flags: flags3 } = parsed;
     const width = Number(parsed.width || 0);
@@ -25136,8 +25136,8 @@ function createStatCommand(configuration = {}) {
       try {
         const path = pathOf(context2, name2);
         const stat = await context2.fs[parsed.follow ? "stat" : "lstat"](path, { signal: context2.signal });
-        const format2 = parsed.format ?? "  File: %N\n  Size: %s	Type: %F\n  Mode: %a (%A)\nAccess: %x\nModify: %y\nChange: %z\n Birth: %w";
-        const text3 = await render(context2, path, name2, stat, format2, parsed.printf, configured.limits.maxOutputBytes);
+        const format3 = parsed.format ?? "  File: %N\n  Size: %s	Type: %F\n  Mode: %a (%A)\nAccess: %x\nModify: %y\nChange: %z\n Birth: %w";
+        const text3 = await render(context2, path, name2, stat, format3, parsed.printf, configured.limits.maxOutputBytes);
         await budget.output(parsed.printf ? text3 : import_buffer.Buffer.concat([text3, Uint8Array.of(10)]));
       } catch (error) {
         context2.signal.throwIfAborted();
@@ -26896,12 +26896,12 @@ function truncateCommand(options3 = {}) {
         }
       }
       outputBytes += length;
-      const encoder4 = new TextEncoder();
+      const encoder5 = new TextEncoder();
       for (let offset = 0; offset < text3.length; ) {
         let end = Math.min(text3.length, offset + (utf82 ? 16384 : 65536));
         if (utf82 && end < text3.length && text3.charCodeAt(end - 1) >= 55296 && text3.charCodeAt(end - 1) <= 56319) end--;
         const chunk = text3.slice(offset, end);
-        await writeBytes(error ? stderr.output : stdout.output, utf82 ? encoder4.encode(chunk) : Uint8Array.from(chunk, (character) => character.charCodeAt(0)), signal);
+        await writeBytes(error ? stderr.output : stdout.output, utf82 ? encoder5.encode(chunk) : Uint8Array.from(chunk, (character) => character.charCodeAt(0)), signal);
         offset = end;
       }
     };
@@ -27476,7 +27476,7 @@ async function parseOptions2(context2, limits) {
   let gzip = false;
   let verbose2 = false;
   let strip = 0;
-  let format2 = "pax";
+  let format3 = "pax";
   let cwd = context2.cwd;
   let nullFiles = false;
   let verbatim = false;
@@ -27545,7 +27545,7 @@ async function parseOptions2(context2, limits) {
       strip = Number(value2);
     } else if (flag === "format") {
       if (value2 !== "ustar" && value2 !== "pax" && value2 !== "posix") fail2(`unsupported archive format: ${value2}`);
-      format2 = value2 === "ustar" ? "ustar" : "pax";
+      format3 = value2 === "ustar" ? "ustar" : "pax";
     } else if (flag === "null") {
       nullFiles = true;
       verbatim = true;
@@ -27593,7 +27593,7 @@ async function parseOptions2(context2, limits) {
   if (mode === "c" && lateExclude) fail2("--exclude after source operands is unsupported; place exclusions before operands");
   if (mode === "c" && !operands.length && !filesFrom) fail2("refusing to create an empty archive without -T");
   if (archive !== "-") checkPath(archive, limits);
-  return { mode, archive, gzip, verbose: verbose2, strip, format: format2, cwd, operands, excludes };
+  return { mode, archive, gzip, verbose: verbose2, strip, format: format3, cwd, operands, excludes };
 }
 function tokenize(pattern) {
   const characters = Array.from(pattern);
@@ -28176,6 +28176,1545 @@ async function readArchive(context2, source2, options3, budget) {
   }
 }
 
+// packages/safe-bash/src/commands/archive/zip.ts
+init_platform();
+
+// packages/safe-bash/src/commands/archive/zip-format.ts
+init_platform();
+var encoder2 = new TextEncoder();
+var cp437 = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+var crcTable4 = Uint32Array.from({ length: 256 }, (_, index) => {
+  let value2 = index;
+  for (let bit = 0; bit < 8; bit++) value2 = value2 >>> 1 ^ (value2 & 1 ? 3988292384 : 0);
+  return value2 >>> 0;
+});
+function crc322(bytes3, previous = 0) {
+  let value2 = previous ^ 4294967295;
+  for (const byte of bytes3) value2 = value2 >>> 8 ^ crcTable4[(value2 ^ byte) & 255];
+  return (value2 ^ 4294967295) >>> 0;
+}
+function number3(value2, maximum, label) {
+  if (!Number.isSafeInteger(value2) || value2 < 0 || value2 > maximum) fail2(`ZIP ${label} limit exceeded or invalid value`);
+}
+function admit2(limits, signal) {
+  signal.throwIfAborted();
+  for (const key of ["maxArchiveBytes", "maxEntryBytes", "maxTotalBytes", "maxMembers", "maxPathBytes", "maxDepth", "maxPaxBytes", "maxTextBytes", "chunkSize"]) {
+    number3(limits[key], Number.MAX_SAFE_INTEGER, key);
+  }
+  if (limits.chunkSize < 512 || limits.chunkSize > 1024 * 1024) fail2("ZIP chunk size must be between 512 and 1048576");
+  return Math.min(limits.chunkSize, 64 * 1024);
+}
+function pathBytes(name2, limits) {
+  if (name2.length > Math.min(limits.maxPathBytes, 65535)) fail2("ZIP path byte limit exceeded");
+  const bytes3 = encoder2.encode(name2);
+  if (!name2 || text2(bytes3) !== name2 || name2.includes("\0")) fail2("ZIP invalid or unsafe path");
+  number3(bytes3.length, Math.min(limits.maxPathBytes, 65535), "path byte");
+  const parts = name2.split("/");
+  if (parts.at(-1) === "") parts.pop();
+  if (parts.some((part) => !part || part === "." || part === "..")) fail2("ZIP unsafe traversal or absolute path");
+  number3(parts.length, limits.maxDepth, "path depth");
+  return bytes3;
+}
+function equal(first, second) {
+  return first.length === second.length && first.every((byte, index) => byte === second[index]);
+}
+function legacyName(bytes3) {
+  let name2 = "";
+  for (const byte of bytes3) name2 += byte < 128 ? String.fromCharCode(byte) : cp437[byte - 128];
+  return name2;
+}
+function extras(bytes3, rawName, comment2, central, limits) {
+  number3(bytes3.length, Math.min(limits.maxPaxBytes, 65535), "extra field");
+  const result2 = {};
+  const view = new DataView(bytes3.buffer, bytes3.byteOffset, bytes3.byteLength);
+  const seen = /* @__PURE__ */ new Set();
+  let offset = 0;
+  while (offset < bytes3.length) {
+    if (offset + 4 > bytes3.length) fail2("ZIP truncated extra field");
+    const identifier = view.getUint16(offset, true);
+    const length = view.getUint16(offset + 2, true);
+    offset += 4;
+    if (offset + length > bytes3.length) fail2("ZIP truncated extra field payload");
+    if (seen.has(identifier)) fail2("ZIP duplicate extra field");
+    seen.add(identifier);
+    if (identifier === 1) fail2("ZIP64 is unsupported");
+    if (identifier === 39169 || identifier === 23 || identifier === 24 || identifier === 25) fail2("ZIP encryption is unsupported");
+    if (identifier === 28789 || identifier === 25461) {
+      if (length < 5 || bytes3[offset] !== 1) fail2("ZIP unsupported or truncated Unicode extra field");
+      const original = identifier === 28789 ? rawName : comment2;
+      if (view.getUint32(offset + 1, true) !== crc322(original)) fail2("ZIP Unicode extra field CRC mismatch");
+      const decoded = text2(bytes3.subarray(offset + 5, offset + length));
+      if (identifier === 28789) {
+        pathBytes(decoded, limits);
+        result2.name = decoded;
+      } else number3(length - 5, limits.maxTextBytes, "Unicode comment");
+    }
+    if (identifier === 21589) {
+      if (!length) fail2("ZIP truncated timestamp extra field");
+      const flags3 = bytes3[offset];
+      if (flags3 & ~7) fail2("ZIP unsupported timestamp flags");
+      const count2 = (flags3 & 1) + (central ? 0 : (flags3 >>> 1 & 1) + (flags3 >>> 2 & 1));
+      if (length !== 1 + count2 * 4) fail2("ZIP truncated or inconsistent timestamp extra field");
+      if (flags3 & 1) result2.modified = view.getInt32(offset + 1, true) * 1e3;
+    }
+    offset += length;
+  }
+  return result2;
+}
+function nameFrom(rawName, flags3, metadata3, limits) {
+  number3(rawName.length, Math.min(limits.maxPathBytes, 65535), "raw path byte");
+  const raw = flags3 & 2048 ? text2(rawName) : legacyName(rawName);
+  pathBytes(raw, limits);
+  if (flags3 & 2048 && metadata3.name !== void 0 && metadata3.name !== raw) fail2("ZIP conflicting UTF-8 and Unicode extra names");
+  return metadata3.name ?? raw;
+}
+function format(method, flags3, version) {
+  number3(flags3, 65535, "general purpose flags");
+  if (flags3 & (1 | 64 | 8192)) fail2("ZIP encryption is unsupported");
+  if (flags3 & ~2062 || method === 0 && flags3 & 6) fail2("ZIP unsupported general purpose flags");
+  if (method !== 0 && method !== 8) fail2("ZIP unsupported compression method");
+  if (version < (method === 8 || flags3 & 8 ? 20 : 10) || version > 20) fail2("ZIP unsupported extraction version (including ZIP64)");
+}
+function dosModified(date2, time) {
+  if (!date2 && !time) return new Date(1980, 0, 1);
+  const year = 1980 + (date2 >>> 9);
+  const month = (date2 >>> 5 & 15) - 1;
+  const day = date2 & 31;
+  const hours = time >>> 11;
+  const minutes = time >>> 5 & 63;
+  const seconds = (time & 31) * 2;
+  const result2 = new Date(Date.UTC(year, month, day, hours, minutes, seconds));
+  if (result2.getUTCFullYear() !== year || result2.getUTCMonth() !== month || result2.getUTCDate() !== day || hours > 23 || minutes > 59 || seconds > 59) fail2("ZIP invalid DOS timestamp");
+  return new Date(year, month, day, hours, minutes, seconds);
+}
+function entryBounds(entry, limits) {
+  pathBytes(entry.name, limits);
+  number3(entry.size, Math.min(limits.maxEntryBytes, limits.maxTotalBytes, 4294967294), "entry byte");
+  number3(entry.data.length, Math.min(limits.maxArchiveBytes, 4294967294), "compressed byte");
+  number3(entry.crc32, 4294967295, "CRC32");
+  number3(entry.mode, 65535, "mode");
+  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)) fail2("ZIP inconsistent directory metadata");
+  const type = entry.mode & 61440;
+  if (type !== 0 && type !== (entry.directory ? 16384 : entry.symlink ? 40960 : 32768)) fail2("ZIP unsupported or conflicting file type");
+  if (!Number.isFinite(entry.modified.getTime())) fail2("ZIP invalid modification time");
+}
+async function copyBytes(source2, destination2, start, chunkSize2, signal) {
+  for (let offset = 0; offset < source2.length; offset += chunkSize2) {
+    signal.throwIfAborted();
+    destination2.set(source2.subarray(offset, offset + chunkSize2), start + offset);
+    if (offset + chunkSize2 < source2.length) await yieldTurn(signal);
+  }
+}
+async function readZipArchive(bytes3, limits, signal) {
+  const chunkSize2 = admit2(limits, signal);
+  number3(bytes3.length, Math.min(limits.maxArchiveBytes, 4294967294), "archive byte");
+  const view = new DataView(bytes3.buffer, bytes3.byteOffset, bytes3.byteLength);
+  let end = -1;
+  const lower = Math.max(0, bytes3.length - 22 - 65535);
+  for (let offset2 = bytes3.length - 22; offset2 >= lower; offset2--) {
+    if ((bytes3.length - offset2) % 4096 === 0) await yieldTurn(signal);
+    if (view.getUint32(offset2, true) === 101010256 && offset2 + 22 + view.getUint16(offset2 + 20, true) === bytes3.length) {
+      const size = view.getUint32(offset2 + 12, true);
+      const start = view.getUint32(offset2 + 16, true);
+      const zip64 = size === 4294967295 || start === 4294967295 || view.getUint16(offset2 + 10, true) === 65535 || offset2 >= 20 && view.getUint32(offset2 - 20, true) === 117853008;
+      if (!zip64 && start + size !== offset2) continue;
+      if (end !== -1) fail2("ZIP ambiguous end records");
+      end = offset2;
+    }
+  }
+  if (end === -1) fail2("ZIP truncated or missing end of central directory");
+  const members = view.getUint16(end + 10, true);
+  const centralSize = view.getUint32(end + 12, true);
+  const centralStart = view.getUint32(end + 16, true);
+  if (members === 65535 || centralSize === 4294967295 || centralStart === 4294967295) fail2("ZIP64 is unsupported");
+  if (view.getUint16(end + 4, true) || view.getUint16(end + 6, true) || view.getUint16(end + 8, true) !== members) fail2("ZIP multi-disk or inconsistent member count is unsupported");
+  if (centralStart + centralSize !== end) fail2("ZIP invalid central directory span or unsupported ZIP64/trailing records");
+  number3(members, limits.maxMembers, "member");
+  number3(bytes3.length - end - 22, limits.maxTextBytes, "archive comment");
+  const entries2 = [];
+  const spans = [];
+  let offset = centralStart;
+  let total = 0;
+  for (let index = 0; index < members; index++) {
+    await yieldTurn(signal);
+    if (offset + 46 > end || view.getUint32(offset, true) !== 33639248) fail2("ZIP truncated or invalid central header");
+    const versionMadeBy = view.getUint16(offset + 4, true);
+    const version = view.getUint16(offset + 6, true);
+    const flags3 = view.getUint16(offset + 8, true);
+    const method = view.getUint16(offset + 10, true);
+    format(method, flags3, version);
+    const dosTime = view.getUint16(offset + 12, true);
+    const dosDate = view.getUint16(offset + 14, true);
+    const checksum = view.getUint32(offset + 16, true);
+    const compressedSize = view.getUint32(offset + 20, true);
+    const size = view.getUint32(offset + 24, true);
+    const nameLength = view.getUint16(offset + 28, true);
+    const extraLength = view.getUint16(offset + 30, true);
+    const commentLength = view.getUint16(offset + 32, true);
+    const internalAttributes = view.getUint16(offset + 36, true);
+    if (internalAttributes & ~1) fail2("ZIP unsupported internal attributes");
+    const externalAttributes = view.getUint32(offset + 38, true);
+    const local = view.getUint32(offset + 42, true);
+    if (view.getUint16(offset + 34, true)) fail2("ZIP multi-disk member is unsupported");
+    if (compressedSize === 4294967295 || size === 4294967295 || local === 4294967295) fail2("ZIP64 is unsupported");
+    number3(size, limits.maxEntryBytes, "entry byte");
+    if (method === 0 && compressedSize !== size) fail2("ZIP stored size mismatch");
+    total += size;
+    number3(total, limits.maxTotalBytes, "total byte");
+    const next = offset + 46 + nameLength + extraLength + commentLength;
+    if (next > end) fail2("ZIP truncated central metadata");
+    number3(commentLength, limits.maxTextBytes, "entry comment");
+    const rawName = bytes3.subarray(offset + 46, offset + 46 + nameLength);
+    const centralExtra = bytes3.subarray(offset + 46 + nameLength, next - commentLength);
+    const comment2 = bytes3.subarray(next - commentLength, next);
+    if (flags3 & 2048) text2(comment2);
+    const centralMetadata = extras(centralExtra, rawName, comment2, true, limits);
+    const name2 = nameFrom(rawName, flags3, centralMetadata, limits);
+    if (local + 30 > centralStart || view.getUint32(local, true) !== 67324752) fail2("ZIP invalid local header span");
+    if (view.getUint16(local + 4, true) !== version || view.getUint16(local + 6, true) !== flags3 || view.getUint16(local + 8, true) !== method || view.getUint16(local + 10, true) !== dosTime || view.getUint16(local + 12, true) !== dosDate) fail2("ZIP central/local metadata mismatch");
+    const localNameLength = view.getUint16(local + 26, true);
+    const localExtraLength = view.getUint16(local + 28, true);
+    const payloadStart = local + 30 + localNameLength + localExtraLength;
+    let payloadEnd = payloadStart + compressedSize;
+    if (payloadEnd > centralStart) fail2("ZIP truncated or overlapping local payload");
+    const localName = bytes3.subarray(local + 30, local + 30 + localNameLength);
+    if (!equal(rawName, localName)) fail2("ZIP central/local filename mismatch");
+    const localExtra = bytes3.subarray(local + 30 + localNameLength, payloadStart);
+    const localMetadata = extras(localExtra, localName, comment2, false, limits);
+    const localEffective = nameFrom(localName, flags3, localMetadata, limits);
+    if (localMetadata.name !== void 0 && localEffective !== name2) fail2("ZIP central/local Unicode name mismatch");
+    if (centralMetadata.modified !== void 0 && localMetadata.modified !== void 0 && centralMetadata.modified !== localMetadata.modified) fail2("ZIP central/local timestamp mismatch");
+    for (const [position, expected] of [[14, checksum], [18, compressedSize], [22, size]]) {
+      const actual = view.getUint32(local + position, true);
+      if (actual !== expected && (!(flags3 & 8) || actual !== 0)) fail2("ZIP central/local size or CRC mismatch");
+    }
+    if (flags3 & 8) {
+      const matches3 = [];
+      for (const signed2 of [false, true]) {
+        const descriptor2 = payloadEnd + (signed2 ? 4 : 0);
+        if (descriptor2 + 12 <= centralStart && (!signed2 || view.getUint32(payloadEnd, true) === 134695760) && view.getUint32(descriptor2, true) === checksum && view.getUint32(descriptor2 + 4, true) === compressedSize && view.getUint32(descriptor2 + 8, true) === size) matches3.push(descriptor2 + 12);
+      }
+      if (matches3.length !== 1) fail2("ZIP truncated, ambiguous or mismatched data descriptor");
+      payloadEnd = matches3[0];
+    }
+    const host2 = versionMadeBy >>> 8;
+    const unixMode = host2 === 3 || host2 === 19 ? externalAttributes >>> 16 : 0;
+    const directory2 = name2.endsWith("/");
+    if (Boolean(externalAttributes & 16) && !directory2) fail2("ZIP conflicting directory attributes");
+    const mode = unixMode || (directory2 ? 16877 : 33188);
+    const symlink = (mode & 61440) === 40960;
+    const modified = dosModified(dosDate, dosTime);
+    const timestamp3 = centralMetadata.modified ?? localMetadata.modified;
+    if (timestamp3 !== void 0) modified.setTime(timestamp3);
+    const entry = { name: name2, data: bytes3.subarray(payloadStart, payloadStart + compressedSize), size, method, crc32: checksum, modified, mode, directory: directory2, symlink, rawName, localName, comment: comment2, localExtra, centralExtra, flags: flags3, versionMadeBy, internalAttributes, externalAttributes, dosTime, dosDate };
+    entryBounds(entry, limits);
+    entries2.push(entry);
+    spans.push({ start: local, end: payloadEnd });
+    offset = next;
+  }
+  if (offset !== end) fail2("ZIP central directory size or member count mismatch");
+  spans.sort((first, second) => first.start - second.start);
+  let covered = 0;
+  for (const span of spans) {
+    if (span.start !== covered) fail2("ZIP overlapping spans, gaps or self-extracting prefix are unsupported");
+    covered = span.end;
+  }
+  if (covered !== centralStart) fail2("ZIP unreferenced local data is unsupported");
+  for (const entry of entries2) {
+    const data2 = new Uint8Array(entry.data.length);
+    await copyBytes(entry.data, data2, 0, chunkSize2, signal);
+    entry.data = data2;
+    entry.rawName = new Uint8Array(entry.rawName);
+    entry.localName = new Uint8Array(entry.localName);
+    entry.comment = new Uint8Array(entry.comment);
+    entry.localExtra = new Uint8Array(entry.localExtra);
+    entry.centralExtra = new Uint8Array(entry.centralExtra);
+    await yieldTurn(signal);
+  }
+  return { entries: entries2, comment: new Uint8Array(bytes3.subarray(end + 22)) };
+}
+async function* decodeZipEntry(entry, limits, signal) {
+  const chunkSize2 = admit2(limits, signal);
+  entryBounds(entry, limits);
+  const reader = new CodecReader((async function* () {
+    yield entry.data;
+  })(), signal);
+  let length = 0;
+  let checksum = 0;
+  const source2 = entry.method === 8 ? codec(reader, { mode: "inflate-raw", chunkSize: chunkSize2 }, signal) : (async function* () {
+    for (let offset = 0; offset < entry.data.length; offset += chunkSize2) {
+      yield new Uint8Array(entry.data.subarray(offset, offset + chunkSize2));
+      await yieldTurn(signal);
+    }
+  })();
+  try {
+    for await (const chunk of source2) {
+      signal.throwIfAborted();
+      length += chunk.length;
+      number3(length, Math.min(limits.maxEntryBytes, limits.maxTotalBytes), "decoded byte");
+      checksum = crc322(chunk, checksum);
+      yield chunk;
+    }
+    if (entry.method === 8 && await reader.chunk() !== void 0) fail2("ZIP trailing compressed data");
+    if (length !== entry.size) fail2("ZIP uncompressed size mismatch");
+    if (checksum !== entry.crc32) fail2("ZIP CRC32 mismatch");
+  } finally {
+    await reader.close();
+  }
+}
+async function makeZipEntry(name2, bytes3, attributes, limits, signal) {
+  const chunkSize2 = admit2(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);
+  for (let offset = 0; offset < bytes3.length; offset += chunkSize2) {
+    entry.crc32 = crc322(bytes3.subarray(offset, offset + chunkSize2), entry.crc32);
+    await yieldTurn(signal);
+  }
+  const reader = new CodecReader((async function* () {
+    yield bytes3;
+  })(), signal);
+  try {
+    if (bytes3.length && !entry.directory && !entry.symlink) {
+      const chunks = [];
+      let length = 0;
+      for await (const chunk of codec(reader, { mode: "deflate-raw", chunkSize: chunkSize2 }, signal)) {
+        length += chunk.length;
+        if (length >= bytes3.length) break;
+        chunks.push(new Uint8Array(chunk));
+      }
+      if (length < bytes3.length) {
+        entry.data = new Uint8Array(length);
+        let offset = 0;
+        for (const chunk of chunks) {
+          entry.data.set(chunk, offset);
+          offset += chunk.length;
+          await yieldTurn(signal);
+        }
+        entry.method = 8;
+        return entry;
+      }
+    }
+    entry.data = new Uint8Array(bytes3.length);
+    await copyBytes(bytes3, entry.data, 0, chunkSize2, signal);
+    return entry;
+  } finally {
+    await reader.close();
+  }
+}
+function timestampExtra(modified) {
+  const seconds = Math.floor(modified.getTime() / 1e3);
+  if (seconds < -2147483648 || seconds > 2147483647) return new Uint8Array();
+  const bytes3 = new Uint8Array(9);
+  const view = new DataView(bytes3.buffer);
+  view.setUint16(0, 21589, true);
+  view.setUint16(2, 5, true);
+  bytes3[4] = 1;
+  view.setInt32(5, seconds, true);
+  return bytes3;
+}
+async function writeZipArchive(archive, limits, signal) {
+  const chunkSize2 = admit2(limits, signal);
+  number3(archive.entries.length, Math.min(limits.maxMembers, 65534), "member");
+  number3(archive.comment.length, Math.min(limits.maxTextBytes, 65535), "archive comment");
+  let length = 22 + archive.comment.length;
+  let localLength = 0;
+  let total = 0;
+  const encoded2 = [];
+  for (const entry of archive.entries) {
+    await yieldTurn(signal);
+    entryBounds(entry, limits);
+    if (entry.method === 0 && entry.data.length !== entry.size) fail2("ZIP stored size mismatch");
+    total += entry.size;
+    number3(total, limits.maxTotalBytes, "total byte");
+    const rawName = entry.rawName ?? pathBytes(entry.name, limits);
+    const flags3 = (entry.flags ?? 2048) & ~8;
+    const comment2 = entry.comment ?? new Uint8Array();
+    number3(comment2.length, Math.min(limits.maxTextBytes, 65535), "entry comment");
+    if (flags3 & 2048) text2(comment2);
+    const localExtra = entry.localExtra ?? timestampExtra(entry.modified);
+    const centralExtra = entry.centralExtra ?? timestampExtra(entry.modified);
+    const localMetadata = extras(localExtra, rawName, comment2, false, limits);
+    const centralMetadata = extras(centralExtra, rawName, comment2, true, limits);
+    if (nameFrom(rawName, flags3, centralMetadata, limits) !== entry.name || localMetadata.name !== void 0 && nameFrom(rawName, flags3, localMetadata, limits) !== entry.name || entry.localName && !equal(rawName, entry.localName)) fail2("ZIP retained filename metadata mismatch");
+    if (localMetadata.modified !== void 0 && centralMetadata.modified !== void 0 && localMetadata.modified !== centralMetadata.modified) fail2("ZIP retained timestamp metadata mismatch");
+    const rounded2 = new Date(Math.ceil(Math.floor(entry.modified.getTime() / 1e3) / 2) * 2e3);
+    const year = Math.max(1980, Math.min(2107, rounded2.getFullYear()));
+    const date2 = entry.dosDate ?? year - 1980 << 9 | rounded2.getMonth() + 1 << 5 | rounded2.getDate();
+    const time = entry.dosTime ?? rounded2.getHours() << 11 | rounded2.getMinutes() << 5 | rounded2.getSeconds() >>> 1;
+    number3(date2, 65535, "DOS date");
+    number3(time, 65535, "DOS time");
+    const dosTimestamp = dosModified(date2, time).getTime();
+    const extendedTimestamp = centralMetadata.modified ?? localMetadata.modified;
+    if (extendedTimestamp === void 0 ? dosTimestamp !== rounded2.getTime() : Math.floor(extendedTimestamp / 1e3) !== Math.floor(entry.modified.getTime() / 1e3)) fail2("ZIP retained or unrepresentable timestamp metadata mismatch");
+    for (const [value2, maximum, label] of [[entry.versionMadeBy ?? 798, 65535, "creator version"], [entry.internalAttributes ?? 0, 65535, "internal attributes"], [entry.externalAttributes ?? 0, 4294967295, "external attributes"]]) number3(value2, maximum, label);
+    if ((entry.internalAttributes ?? 0) & ~1) fail2("ZIP unsupported internal attributes");
+    if (entry.externalAttributes !== void 0) {
+      const host2 = (entry.versionMadeBy ?? 798) >>> 8;
+      const unixMode = host2 === 3 || host2 === 19 ? entry.externalAttributes >>> 16 : 0;
+      const mode = unixMode || (entry.directory ? 16877 : 33188);
+      if (mode !== entry.mode || Boolean(entry.externalAttributes & 16) && !entry.directory) fail2("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;
+    number3(length, Math.min(limits.maxArchiveBytes, 4294967294), "archive byte");
+  }
+  number3(length, Math.min(limits.maxArchiveBytes, 4294967294), "archive byte");
+  const bytes3 = new Uint8Array(length);
+  const view = new DataView(bytes3.buffer);
+  let central = localLength;
+  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;
+    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.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);
+    view.setUint32(central, 33639248, true);
+    view.setUint16(central + 4, entry.versionMadeBy ?? 798, true);
+    view.setUint16(central + 6, version, true);
+    view.setUint16(central + 8, flags3, true);
+    view.setUint16(central + 10, entry.method, true);
+    view.setUint16(central + 12, time, true);
+    view.setUint16(central + 14, date2, true);
+    view.setUint32(central + 16, entry.crc32, true);
+    view.setUint32(central + 20, entry.data.length, true);
+    view.setUint32(central + 24, entry.size, true);
+    view.setUint16(central + 28, rawName.length, true);
+    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);
+    view.setUint32(central + 42, offset, true);
+    bytes3.set(rawName, central + 46);
+    bytes3.set(centralExtra, central + 46 + rawName.length);
+    bytes3.set(comment2, central + 46 + rawName.length + centralExtra.length);
+    central += 46 + rawName.length + centralExtra.length + comment2.length;
+  }
+  view.setUint32(central, 101010256, true);
+  view.setUint16(central + 8, encoded2.length, true);
+  view.setUint16(central + 10, encoded2.length, true);
+  view.setUint32(central + 12, central - localLength, true);
+  view.setUint32(central + 16, localLength, true);
+  view.setUint16(central + 20, archive.comment.length, true);
+  bytes3.set(archive.comment, central + 22);
+  signal.throwIfAborted();
+  return bytes3;
+}
+
+// packages/safe-bash/src/commands/archive/zip/safety.ts
+init_platform();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+var ZipScope = class {
+  constructor(original, limits) {
+    this.original = original;
+    this.limits = limits;
+    this.context = { ...original, signal: AbortSignal.any([original.signal, this.controller.signal]) };
+    original.registerCleanup?.(this.close);
+  }
+  original;
+  limits;
+  context;
+  controller = new AbortController();
+  pending = /* @__PURE__ */ new Set();
+  readers = /* @__PURE__ */ new Set();
+  closedReason = new Error("ZIP command is closed");
+  drain;
+  work = 0;
+  close = () => {
+    if (!this.drain) {
+      this.drain = Promise.resolve().then(async () => {
+        while (this.pending.size) await Promise.allSettled([...this.pending]);
+        const results = await Promise.allSettled([...this.readers].map((close) => close()));
+        const failures = results.filter((result2) => result2.status === "rejected").map((result2) => result2.reason);
+        if (failures.length === 1) throw failures[0];
+        if (failures.length) throw new AggregateError(failures, "ZIP reader cleanup failed");
+      });
+      this.controller.abort(this.original.signal.aborted ? this.original.signal.reason : this.closedReason);
+    }
+    return this.drain;
+  };
+  async operation(action) {
+    this.context.signal.throwIfAborted();
+    if (++this.work > this.limits.maxPatternSteps) fail2("filesystem work limit exceeded");
+    const pending = Promise.resolve().then(() => {
+      this.context.signal.throwIfAborted();
+      return action();
+    });
+    this.pending.add(pending);
+    try {
+      const value2 = await pending;
+      this.context.signal.throwIfAborted();
+      return value2;
+    } 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 void 0;
+      throw error;
+    }
+  }
+  source(source2) {
+    const iterator = source2[Symbol.asyncIterator]();
+    let closing;
+    const close = () => closing ??= (async () => {
+      try {
+        await iterator.return?.();
+      } finally {
+        this.readers.delete(close);
+      }
+    })();
+    this.readers.add(close);
+    return { [Symbol.asyncIterator]: () => ({
+      next: () => this.operation(async () => {
+        const result2 = await iterator.next();
+        if (result2.done) this.readers.delete(close);
+        return result2;
+      }),
+      async return() {
+        await close();
+        return { done: true, value: void 0 };
+      }
+    }) };
+  }
+  async *input(path) {
+    const { fs, signal } = this.context;
+    const capabilities = await this.operation(() => fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+    if (fs.readStream && capabilities.streamingRead !== false) {
+      const source2 = await this.operation(() => this.source(fs.readStream(path, { signal, chunkSize: this.limits.chunkSize })));
+      yield* readBytes(source2, signal);
+    } else {
+      const stat = await this.operation(() => fs.stat(path, { signal }));
+      if (stat.size > this.limits.maxBufferedFileBytes) fail2("filesystem lacks streaming reads: buffered file limit exceeded");
+      const bytes3 = await this.operation(() => fs.readFile(path, { signal, maxBytes: this.limits.maxBufferedFileBytes }));
+      if (bytes3.length > this.limits.maxBufferedFileBytes) fail2("buffered file limit exceeded");
+      yield bytes3;
+    }
+  }
+};
+async function publishZip(scope, prepared) {
+  const { fs, signal } = scope.context;
+  const capabilities = await scope.operation(() => fs.capabilitiesFor?.(prepared.output, { signal }) ?? fs.capabilities);
+  if (capabilities.atomicRename !== true || capabilities.exclusiveCreate !== true || capabilities.explicitDirectories !== true || capabilities.permissions !== true || !fs.rmdir || (prepared.existing ? !fs.chmod : capabilities.atomicRenameNoReplace !== true)) fail2("ZIP publication requires atomic rename, exclusive creation, private directories and mode preservation");
+  let directory2;
+  let temporary = "";
+  let identity2;
+  let published = false;
+  let collision = false;
+  let failure;
+  const checkOwner = async () => {
+    const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
+    const owner = directory2 && await scope.stat(directory2.path);
+    if (parent !== prepared.parent || !owner || owner.type !== "directory" || !sameIdentity2(owner, directory2.stat)) fail2("ZIP temporary ownership changed before mutation");
+  };
+  const close = retainFileSystemCleanup(fs, async (cleanup) => {
+    if (!directory2 || !hasIdentity(directory2.stat)) return;
+    const parent = await cleanup.realpath(prepared.parentName);
+    const owner = await cleanup.lstat(directory2.path);
+    if (parent !== prepared.parent || owner.type !== "directory" || !sameIdentity2(owner, directory2.stat)) fail2("ZIP temporary ownership changed before cleanup");
+    if (temporary && !published && !collision) {
+      let current;
+      try {
+        current = await cleanup.lstat(temporary);
+      } catch (error) {
+        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") throw error;
+      }
+      if (current) {
+        if (!identity2 || !sameIdentity2(current, identity2) || current.type !== "file" || current.nlink !== 1) fail2("ZIP temporary file changed before cleanup");
+        await cleanup.rm(temporary);
+      }
+    }
+    await cleanup.rmdir(directory2.path);
+  }, { maxOperations: 16 });
+  try {
+    for (let attempt = 0; attempt < Math.min(64, scope.limits.maxMembers); attempt++) {
+      const path = `${prepared.parent === "/" ? "" : prepared.parent}/.zip-${attempt + 1}`;
+      checkPath(path, scope.limits);
+      if (path === prepared.output) continue;
+      try {
+        await scope.operation(async () => {
+          await fs.mkdir(path, { signal, mode: 448 });
+          directory2 = { path, stat: await fs.lstat(path) };
+        });
+        break;
+      } catch (error) {
+        signal.throwIfAborted();
+        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EEXIST") throw error;
+      }
+    }
+    if (!directory2) fail2("ZIP temporary directory attempt limit exceeded");
+    if (directory2.stat.type !== "directory" || !hasIdentity(directory2.stat) || (directory2.stat.mode & 511) !== 448) fail2("ZIP temporary directory ownership unavailable");
+    temporary = `${directory2.path}/archive.zip`;
+    checkPath(temporary, scope.limits);
+    await checkOwner();
+    await scope.operation(async () => {
+      let writeFailure;
+      try {
+        await fs.writeFile(temporary, prepared.bytes, { signal, flag: "wx", ...prepared.existing ? { mode: prepared.existing.mode & 4095 } : {} });
+      } catch (error) {
+        collision = typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+        writeFailure = { reason: error };
+      }
+      if (!collision) {
+        await checkOwner();
+        try {
+          identity2 = await fs.lstat(temporary);
+        } catch (error) {
+          if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") throw error;
+        }
+      }
+      if (writeFailure) throw writeFailure.reason;
+    });
+    if (!identity2 || !hasIdentity(identity2) || identity2.type !== "file" || identity2.nlink !== 1 || identity2.size !== prepared.bytes.length) fail2("ZIP staged archive identity or size changed");
+    if (prepared.existing) {
+      await checkOwner();
+      await scope.operation(() => fs.chmod(temporary, prepared.existing.mode & 4095, { signal }));
+    }
+    const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
+    const current = await scope.stat(prepared.output);
+    if (parent !== prepared.parent || (prepared.existing ? !current || !sameIdentity2(prepared.existing, current) || current.type !== "file" || current.nlink !== 1 || current.size !== prepared.existing.size || current.mode !== prepared.existing.mode || current.mtimeMs !== prepared.existing.mtimeMs || current.ctimeMs !== prepared.existing.ctimeMs : current !== void 0)) fail2("archive backing entry changed before publication");
+    const staging = await scope.stat(temporary);
+    const owner = await scope.stat(directory2.path);
+    if (!staging || !sameIdentity2(staging, identity2) || staging.type !== "file" || staging.nlink !== 1 || staging.size !== prepared.bytes.length || !owner || !sameIdentity2(owner, directory2.stat) || owner.type !== "directory") fail2("ZIP temporary ownership changed before publication");
+    await scope.operation(async () => {
+      await fs.rename(temporary, prepared.output, { signal, ...!prepared.existing ? { noReplace: true } : {} });
+      published = true;
+    });
+  } 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;
+}
+
+// packages/safe-bash/src/commands/archive/zip.ts
+var ZipFailure = class extends Error {
+  constructor(status2, label, detail) {
+    super(detail);
+    this.status = status2;
+    this.label = label;
+  }
+  status;
+  label;
+};
+function parse12(context2, limits) {
+  if (context2.args.length > limits.maxArgumentBytes) fail2("argument count limit exceeded");
+  let bytes3 = 0;
+  for (const argument2 of context2.args) {
+    const size = import_buffer.Buffer.byteLength(argument2);
+    if (size > limits.maxArgumentBytes - bytes3) fail2("argument byte limit exceeded");
+    bytes3 += size;
+  }
+  if (context2.argumentValues) {
+    const argumentsValue = getCommandArguments(context2);
+    let rawBytes = 0;
+    for (const value2 of argumentsValue.values) {
+      const size = shellValueByteLength(value2);
+      if (size > limits.maxArgumentBytes - rawBytes) fail2("argument byte limit exceeded");
+      rawBytes += size;
+    }
+    for (const value2 of argumentsValue.values) text2(shellValueBytes(value2));
+  }
+  let archive;
+  let recursive = false;
+  let literal = false;
+  let firstOperand = -1;
+  const operands = [];
+  for (const [index, argument2] of context2.args.entries()) {
+    checkPath(argument2, limits);
+    if (!literal && argument2 === "--") {
+      if (archive === void 0) throw new ZipFailure(16, "Invalid command arguments", "can't use -- before archive name");
+      literal = true;
+    } else if (!literal && argument2.startsWith("-") && argument2 !== "-") {
+      if (argument2.length > 1 && [...argument2.slice(1)].every((flag) => flag === "r")) recursive = true;
+      else throw new ZipFailure(16, "Invalid command arguments", `unsupported option: ${argument2}`);
+    } else if (archive === void 0) archive = argument2;
+    else {
+      if (operands.length >= limits.maxMembers) fail2("operand limit exceeded");
+      if (firstOperand < 0) firstOperand = index;
+      operands.push(argument2);
+    }
+  }
+  if (archive === void 0) throw new ZipFailure(16, "Invalid command arguments", "expected zip [-r] ARCHIVE FILES...");
+  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";
+  checkPath(archive, limits);
+  return { archive, recursive, operands, firstOperand };
+}
+function memberName(path, limits) {
+  if (path.startsWith("//") && !path.startsWith("///")) fail2("UNC source paths are unsupported");
+  let start = 0;
+  while (path[start] === "/") start++;
+  while (path.slice(start, start + 2) === "./") start += 2;
+  const name2 = path.slice(start);
+  if (name2.split("/").includes("..")) fail2("parent-component archive names are unsupported");
+  if (name2 && name2 !== ".") checkPath(name2, limits);
+  return name2 === "." ? "" : name2;
+}
+function unchanged4(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 && (!hasIdentity(before) || sameIdentity2(before, after));
+}
+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 output2 = `${parent === "/" ? "" : parent}/${outputName.slice(outputName.lastIndexOf("/") + 1)}`;
+  checkPath(output2, limits);
+  const existing2 = await scope.stat(output2);
+  if (existing2 && (existing2.type !== "file" || !hasIdentity(existing2) || existing2.nlink !== 1)) fail2("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 (!Number.isSafeInteger(existing2.size) || existing2.size < 0 || existing2.size > limits.maxArchiveBytes) fail2("archive byte limit exceeded");
+    const bytes4 = await collectBytes(scope.input(output2), { maxBytes: limits.maxArchiveBytes, signal: context2.signal });
+    if (bytes4.length !== existing2.size) fail2("archive changed while reading");
+    archive = await readZipArchive(bytes4, limits, context2.signal);
+    const current = await scope.stat(output2);
+    if (!current || !unchanged4(existing2, current)) fail2("archive changed while reading");
+  }
+  const old = new Map(archive.entries.map((entry) => [entry.name, entry]));
+  const selected = /* @__PURE__ */ new Map();
+  const ancestors = [];
+  let visits = 0;
+  let work = 0;
+  let compressedBytes = 0;
+  const visit = async (source2, name2, depth) => {
+    context2.signal.throwIfAborted();
+    if (++visits > limits.maxMembers) fail2("traversal member limit exceeded");
+    if (++work > limits.maxPatternSteps) fail2("archive work limit exceeded");
+    if (visits % 128 === 0) await yieldTurn(context2.signal);
+    if (depth > limits.maxDepth) fail2("archive recursion depth limit exceeded");
+    const path = vfsPath(context2.cwd, source2);
+    checkPath(path, limits);
+    let canonical;
+    let stat;
+    try {
+      canonical = await scope.operation(() => context2.fs.realpath(path, { signal: context2.signal }));
+      stat = await scope.operation(() => context2.fs.stat(path, { signal: context2.signal }));
+    } catch (error) {
+      context2.signal.throwIfAborted();
+      if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") throw error;
+      if (!old.has(name2)) await budget.output(`	zip warning: name not matched: ${source2}
+`);
+      return;
+    }
+    checkPath(canonical, limits);
+    if (canonical === output2 || existing2 && sameIdentity2(existing2, stat)) return;
+    if (stat.type !== "file" && stat.type !== "directory") {
+      await budget.output(`	zip warning: ignoring special file: ${source2}
+`);
+      return;
+    }
+    if (existing2 && !hasIdentity(stat)) fail2("cannot exclude archive aliases when source backing identity is unknown");
+    const directory2 = stat.type === "directory";
+    if (directory2 && name2 && !name2.endsWith("/")) name2 += "/";
+    if (name2) {
+      checkPath(name2, limits);
+      const previous = selected.get(name2);
+      if (previous && previous.source !== source2) {
+        await budget.output(`	zip warning:   first full name: ${previous.source}
+                      second full name: ${source2}
+                     name in zip file repeated: ${name2}
+`);
+        throw new ZipFailure(16, "Invalid command arguments", "cannot repeat names in zip file");
+      }
+      if (!previous) {
+        await budget.member(directory2 ? 0 : stat.size);
+        const bytes4 = directory2 ? new Uint8Array() : await collectBytes(scope.input(path), { maxBytes: stat.size, signal: context2.signal });
+        if (!directory2 && bytes4.length !== stat.size) fail2(`source changed while reading: ${source2}`);
+        const current = await scope.operation(() => context2.fs.stat(path, { signal: context2.signal }));
+        const currentPath = await scope.operation(() => context2.fs.realpath(path, { signal: context2.signal }));
+        if (currentPath !== canonical || !unchanged4(stat, current)) fail2(`source changed while reading: ${source2}`);
+        let entry = await makeZipEntry(name2, bytes4, { modified: new Date(stat.mtimeMs), mode: stat.mode, directory: directory2, symlink: false }, limits, context2.signal);
+        if ([".z", ".zip", ".zoo", ".arc", ".lzh", ".arj"].some((suffix2) => name2.toLowerCase().endsWith(suffix2))) entry = { ...entry, method: 0, data: bytes4 };
+        const prior = old.get(name2);
+        if (prior?.comment) entry = { ...entry, comment: prior.comment };
+        if (entry.data.length > limits.maxArchiveBytes - compressedBytes) fail2("archive byte limit exceeded");
+        compressedBytes += entry.data.length;
+        selected.set(name2, { entry, source: source2 });
+      }
+    }
+    if (directory2 && parsed.recursive) {
+      if (ancestors.some((ancestor) => ancestor.path === canonical || sameIdentity2(ancestor.stat, stat))) fail2(`directory cycle while archiving: ${source2}`);
+      ancestors.push({ path: canonical, stat });
+      try {
+        const children = await scope.operation(() => context2.fs.readdir(path, { signal: context2.signal, maxEntries: limits.maxMembers - visits }));
+        if (children.length > limits.maxMembers - visits) fail2("traversal member limit exceeded");
+        for (const child of children) {
+          if (!child.name || child.name === "." || child.name === ".." || child.name.includes("/") || child.name.includes("\0")) fail2("invalid filesystem directory entry");
+          const prefix3 = source2 === "." ? "" : source2.endsWith("/") ? source2 : `${source2}/`;
+          await visit(`${prefix3}${child.name}`, `${name2}${child.name}`, depth + 1);
+        }
+      } finally {
+        ancestors.pop();
+      }
+    }
+  };
+  for (const operand of parsed.operands) await visit(operand, memberName(operand, limits), 0);
+  if (!selected.size) {
+    const detail = parsed.recursive && parsed.firstOperand >= 0 ? `try: zip ${context2.args.slice(0, parsed.firstOperand).join(" ")} . -i ${context2.args.slice(parsed.firstOperand).join(" ")}` : parsed.archive;
+    throw new ZipFailure(12, "Nothing to do!", detail);
+  }
+  const entries2 = [];
+  const progress = [];
+  let progressBytes = 0;
+  const append = (entry, update) => {
+    const percentage = entry.size ? Math.trunc((Math.trunc(200 * (entry.size - entry.data.length) / entry.size) + 1) / 2) : 0;
+    const message3 = `${update ? "updating:" : "  adding:"} ${entry.name} (${entry.method === 8 ? `deflated ${percentage}%` : "stored 0%"})
+`;
+    const size = import_buffer.Buffer.byteLength(message3);
+    if (size > limits.maxTextBytes - budget.textBytes - progressBytes) fail2("text output limit exceeded");
+    progressBytes += size;
+    progress.push(message3);
+  };
+  for (const entry of archive.entries) {
+    if (++work > limits.maxPatternSteps) fail2("archive work limit exceeded");
+    const replacement = selected.get(entry.name);
+    if (replacement) {
+      entries2.push(replacement.entry);
+      append(replacement.entry, true);
+      selected.delete(entry.name);
+    } else {
+      await budget.member(entry.size);
+      entries2.push(entry);
+    }
+  }
+  for (const { entry } of selected.values()) {
+    entries2.push(entry);
+    append(entry, false);
+  }
+  const bytes3 = await writeZipArchive({ entries: entries2, comment: archive.comment }, limits, context2.signal);
+  return { output: output2, parentName, parent, existing: existing2, bytes: bytes3, progress };
+}
+function createZipCommand(options3 = {}) {
+  const limits = settings2(options3);
+  return { name: "zip", description: "Create or update bounded ZIP archives in the virtual filesystem", async execute(original) {
+    original.signal.throwIfAborted();
+    const scope = new ZipScope(original, limits);
+    const context2 = scope.context;
+    const budget = new Budget14(context2, limits);
+    try {
+      const parsed = parse12(context2, limits);
+      const prepared = await prepare(scope, parsed, budget);
+      await writeFileOutput(context2, prepared.bytes, () => scope.operation(() => publishZip(scope, prepared)));
+      for (const message3 of prepared.progress) await budget.output(message3);
+      return { exitCode: 0 };
+    } catch (error) {
+      original.signal.throwIfAborted();
+      context2.signal.throwIfAborted();
+      if (error instanceof ZipFailure) {
+        await budget.output(`
+zip error: ${error.label} (${error.message})
+`);
+        return { exitCode: error.status };
+      }
+      const message3 = escapeText(display(publicDiagnosticMessage(error, context2.onInternalError).slice(0, 1024)), "diagnostic");
+      await writeBytes(context2.stderr, import_buffer.Buffer.from(`zip: ${message3}
+`).subarray(0, limits.maxDiagnosticBytes), context2.signal);
+      return { exitCode: 2 };
+    } finally {
+      try {
+        await scope.close();
+      } finally {
+        original.signal.throwIfAborted();
+      }
+    }
+  } };
+}
+
+// packages/safe-bash/src/commands/archive/unzip.ts
+init_platform();
+
+// packages/safe-bash/src/commands/archive/unzip/arguments.ts
+init_platform();
+function parseArguments(context2, limits) {
+  const { args } = context2;
+  let bytes3 = 0;
+  for (const argument2 of args) {
+    bytes3 += import_buffer.Buffer.byteLength(argument2) + 1;
+    if (bytes3 > limits.maxArgumentBytes) fail2("argument byte limit exceeded");
+    if (argument2.includes("\0")) fail2("NUL in argument");
+  }
+  if (context2.argumentValues) {
+    const argumentsValue = getCommandArguments(context2);
+    let rawBytes = 0;
+    for (const value2 of argumentsValue.values) {
+      const size = shellValueByteLength(value2) + 1;
+      if (size > limits.maxArgumentBytes - rawBytes) fail2("argument byte limit exceeded");
+      rawBytes += size;
+    }
+    for (const value2 of argumentsValue.values) text2(shellValueBytes(value2));
+  }
+  let list = false;
+  let overwrite = false;
+  let destination2;
+  let archive;
+  let ended = false;
+  const patterns2 = [];
+  for (let index = 0; index < args.length; index++) {
+    const argument2 = args[index];
+    if (!ended && argument2 === "--") {
+      ended = true;
+      continue;
+    }
+    if (!ended && argument2.startsWith("-") && argument2 !== "-") {
+      for (let offset = 1; offset < argument2.length; offset++) {
+        const flag = argument2[offset];
+        if (flag === "l") list = true;
+        else if (flag === "o") overwrite = true;
+        else if (flag === "d") {
+          if (destination2 !== void 0) fail2("-d may only be specified once");
+          destination2 = argument2.slice(offset + 1) || args[++index];
+          if (!destination2) fail2("must specify directory to which to extract with -d option");
+          checkPath(destination2, limits);
+          break;
+        } else fail2(`unsupported option: -${flag}`);
+      }
+    } else if (archive === void 0) archive = argument2;
+    else patterns2.push(argument2);
+  }
+  if (archive === void 0) fail2("usage: unzip [-l] [-o] [-d DIR] ARCHIVE [FILES...]");
+  checkPath(archive, limits);
+  return { list, overwrite, destination: destination2, archive, patterns: patterns2 };
+}
+function tokenize2(pattern) {
+  const characters = Array.from(pattern);
+  const tokens2 = [];
+  for (let index = 0; index < characters.length; index++) {
+    const character = characters[index];
+    if (character === "*") {
+      if (tokens2.at(-1)?.kind !== "star") tokens2.push({ kind: "star" });
+    } else if (character === "?") tokens2.push({ kind: "any" });
+    else if (character === "\\") {
+      const escaped3 = characters[++index];
+      tokens2.push(escaped3 === void 0 ? { kind: "never" } : { kind: "literal", value: escaped3 });
+    } else if (character === "[") {
+      const negative = characters[index + 1] === "!" || characters[index + 1] === "^";
+      if (negative) index++;
+      const ranges = [];
+      let closed = false;
+      while (++index < characters.length) {
+        let first = characters[index];
+        if (first === "]") {
+          closed = true;
+          break;
+        }
+        if (first === "\\") first = characters[++index] ?? "";
+        let last = first;
+        if (characters[index + 1] === "-" && characters[index + 2] && characters[index + 2] !== "]") {
+          index += 2;
+          last = characters[index];
+          if (last === "\\") last = characters[++index] ?? "";
+        }
+        ranges.push([first.codePointAt(0) ?? -1, last.codePointAt(0) ?? -1]);
+      }
+      tokens2.push(closed ? { kind: "class", ranges, negative } : { kind: "never" });
+    } else tokens2.push({ kind: "literal", value: character });
+  }
+  return tokens2;
+}
+var Selection = class {
+  constructor(patterns2, limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+    this.patterns = patterns2.map(tokenize2);
+  }
+  limits;
+  signal;
+  work = 0;
+  patterns;
+  matched = /* @__PURE__ */ new Set();
+  step() {
+    if (++this.work > this.limits.maxPatternSteps) fail2("pattern work limit exceeded");
+  }
+  async matches(name2) {
+    if (!this.patterns.length) return true;
+    const characters = Array.from(name2);
+    let selected = false;
+    for (let pattern = 0; pattern < this.patterns.length; pattern++) {
+      this.step();
+      let states = new Uint8Array(characters.length + 1);
+      states[0] = 1;
+      for (const token of this.patterns[pattern]) {
+        const next = new Uint8Array(states.length);
+        for (let index = 0; index < states.length; index++) {
+          this.step();
+          if (token.kind === "star") next[index] = states[index] || (index > 0 ? next[index - 1] : 0);
+          else if (states[index] && index < characters.length) {
+            const character = characters[index];
+            let match = token.kind === "any" || token.kind === "literal" && token.value === character;
+            if (token.kind === "class") {
+              let inRange = false;
+              for (const [first, last] of token.ranges) {
+                this.step();
+                if (character.codePointAt(0) >= first && character.codePointAt(0) <= last) inRange = true;
+              }
+              match = inRange !== token.negative;
+            }
+            if (match) next[index + 1] = 1;
+          }
+          if (this.work % 4096 === 0) await yieldTurn(this.signal);
+        }
+        states = next;
+      }
+      if (states[characters.length]) {
+        this.matched.add(pattern);
+        selected = true;
+      }
+    }
+    return selected;
+  }
+};
+var Answers = class {
+  constructor(source2, limits, signal) {
+    this.limits = limits;
+    this.signal = signal;
+    this.iterator = readBytes(source2, signal)[Symbol.asyncIterator]();
+  }
+  limits;
+  signal;
+  iterator;
+  chunk = new Uint8Array();
+  offset = 0;
+  bytes = 0;
+  pulls = 0;
+  async read(maximum = 9) {
+    const answer = [];
+    while (answer.length < maximum) {
+      this.signal.throwIfAborted();
+      if (this.offset === this.chunk.length) {
+        if (++this.pulls > this.limits.maxPatternSteps) fail2("overwrite input work limit exceeded");
+        if (this.pulls % 64 === 0) await yieldTurn(this.signal);
+        const next = await this.iterator.next();
+        if (next.done) break;
+        if (next.value.length > this.limits.maxFilesFromBytes - this.bytes) fail2("overwrite input byte limit exceeded");
+        this.bytes += next.value.length;
+        this.chunk = Uint8Array.from(next.value);
+        this.offset = 0;
+        if (!this.chunk.length) continue;
+      }
+      const byte = this.chunk[this.offset++];
+      answer.push(byte);
+      if (byte === 10) break;
+    }
+    return answer.length ? import_buffer.Buffer.from(answer).toString("utf8") : void 0;
+  }
+  async close() {
+    await this.iterator.return?.();
+  }
+};
+
+// packages/safe-bash/src/commands/archive/unzip/safety.ts
+init_platform();
+import { retainFileSystemCleanup as retainFileSystemCleanup2 } from "@poe-platform/safe-fs/core";
+var Extraction = class {
+  constructor(context2, limits) {
+    this.context = context2;
+    this.limits = limits;
+  }
+  context;
+  limits;
+  pending = /* @__PURE__ */ new Set();
+  publications = /* @__PURE__ */ new Set();
+  readers = /* @__PURE__ */ new Set();
+  closed = false;
+  work = 0;
+  serial = 0;
+  async operation(action) {
+    this.context.signal.throwIfAborted();
+    if (this.closed) fail2("extraction is closed");
+    if (++this.work > this.limits.maxPatternSteps) fail2("filesystem work limit exceeded");
+    const pending = Promise.resolve().then(() => {
+      this.context.signal.throwIfAborted();
+      return action();
+    });
+    this.pending.add(pending);
+    try {
+      const value2 = await pending;
+      this.context.signal.throwIfAborted();
+      return value2;
+    } finally {
+      this.pending.delete(pending);
+    }
+  }
+  async close() {
+    this.closed = true;
+    while (this.pending.size) await Promise.allSettled([...this.pending]);
+    while (this.publications.size) await Promise.allSettled([...this.publications]);
+    await Promise.allSettled([...this.readers].map((close) => close()));
+  }
+  source(source2) {
+    return { [Symbol.asyncIterator]: () => {
+      const state = {};
+      let closing;
+      const close = () => closing ??= (async () => {
+        try {
+          await state.iterator?.return?.();
+        } finally {
+          this.readers.delete(close);
+        }
+      })();
+      this.readers.add(close);
+      this.context.signal.throwIfAborted();
+      state.iterator = source2[Symbol.asyncIterator]();
+      return {
+        next: () => this.operation(async () => {
+          const result2 = await state.iterator.next();
+          if (result2.done) this.readers.delete(close);
+          return result2;
+        }),
+        async return() {
+          await close();
+          return { done: true, value: void 0 };
+        }
+      };
+    } };
+  }
+  async *input(path) {
+    const { fs, signal } = this.context;
+    const capabilities = await this.operation(async () => await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities);
+    if (fs.readStream && capabilities.streamingRead !== false) {
+      const source2 = await this.operation(async () => fs.readStream(path, { signal, chunkSize: this.limits.chunkSize }));
+      yield* readBytes(this.source(source2), signal);
+    } else {
+      const stat = await this.operation(() => fs.stat(path, { signal }));
+      if (stat.size > this.limits.maxBufferedFileBytes) fail2("filesystem lacks streaming reads: buffered file limit exceeded");
+      const bytes3 = await this.operation(() => fs.readFile(path, { signal, maxBytes: this.limits.maxBufferedFileBytes }));
+      if (bytes3.length > this.limits.maxBufferedFileBytes) fail2("buffered file limit exceeded");
+      yield bytes3;
+    }
+  }
+  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 void 0;
+      throw error;
+    }
+  }
+  async directory(raw, create) {
+    checkPath(raw, this.limits);
+    let current = "/";
+    const { fs, signal } = this.context;
+    for (const component of raw.split("/")) {
+      if (!component || component === ".") continue;
+      current = resolvePath(current, component);
+      const stat = await this.stat(current);
+      if (!stat && create) await this.operation(() => fs.mkdir(current, { signal, mode: 493 }));
+      else if (!stat || stat.type !== "directory") fail2(`unsafe non-directory or symlink ancestor: ${display(current)}`);
+    }
+    return current;
+  }
+  async parents(root, path, create) {
+    if (!isPathWithin(root, path)) fail2("extraction path escapes root");
+    await this.directory(dirname(path), create);
+  }
+  member(root, name2) {
+    checkPath(name2, this.limits);
+    if (name2.startsWith("/") || name2.split("/").includes("..")) fail2(`unsafe archive member: ${display(name2)}`);
+    const path = resolvePath(root, name2);
+    checkPath(path, this.limits);
+    if (!isPathWithin(root, path)) fail2("extraction path escapes root");
+    return path;
+  }
+  async target(root, path, target) {
+    checkPath(target, this.limits);
+    if (target.startsWith("/")) fail2("symlink target escapes extraction root");
+    let current = dirname(path);
+    const components2 = (value2) => {
+      checkPath(value2, this.limits);
+      let descended = false;
+      const result2 = value2.split("/");
+      for (const component of result2) {
+        if (component === ".." && descended) fail2("unsafe non-leading parent in symlink target");
+        if (component && component !== "." && component !== "..") descended = true;
+      }
+      return result2;
+    };
+    let pending = components2(target);
+    let links = 0;
+    let steps = 0;
+    while (pending.length) {
+      if (++steps > this.limits.maxDepth * 41) fail2("symlink target resolution limit exceeded");
+      const component = pending.shift();
+      if (!component || component === ".") continue;
+      if (component === "..") {
+        if (current === root) fail2("symlink target escapes extraction root");
+        current = dirname(current);
+        continue;
+      }
+      const candidate = resolvePath(current, component);
+      checkPath(candidate, this.limits);
+      if (!isPathWithin(root, candidate)) fail2("symlink target escapes extraction root");
+      const stat = await this.stat(candidate);
+      if (stat?.type === "symlink") {
+        if (++links > 40 || !this.context.fs.readlink) fail2("symlink target chain cannot be safely resolved");
+        const link = await this.operation(() => this.context.fs.readlink(candidate, { signal: this.context.signal }));
+        if (link.startsWith("/")) fail2("absolute symlink target chain is unsafe");
+        pending = [...components2(link), ...pending];
+        if (pending.length > this.limits.maxDepth * 41) fail2("symlink target resolution limit exceeded");
+      } else current = candidate;
+    }
+  }
+  async destination(path, archivePath, archiveStat) {
+    const stat = await this.stat(path);
+    if (path === archivePath || stat && sameIdentity2(stat, archiveStat)) fail2("entry would overwrite input archive");
+    if (stat && stat.type !== "file") fail2(`unsafe non-regular destination: ${display(path)}`);
+    if (stat && (!hasIdentity(stat) || !hasIdentity(archiveStat))) fail2("cannot overwrite file with unknown input-archive backing identity");
+    return stat;
+  }
+  async checked(root, path, expected) {
+    await this.parents(root, path, false);
+    const current = await this.stat(path);
+    if (!current || current.type !== expected.type || !sameIdentity2(current, expected)) fail2("extraction entry changed before mutation");
+  }
+  async metadata(root, path, identity2, mode, modified) {
+    const { fs, signal } = this.context;
+    if (fs.chmod && fs.capabilities.permissions !== false) {
+      await this.checked(root, path, identity2);
+      await this.operation(() => fs.chmod(path, mode & 511, { signal }));
+    }
+    if (fs.utimes && fs.capabilities.timestamps !== false) {
+      await this.checked(root, path, identity2);
+      await this.operation(() => fs.utimes(path, modified.getTime(), modified.getTime(), { signal }));
+    }
+  }
+  publish(root, path, chunks, expected, mode, modified, target) {
+    const publication = this.stage(root, path, chunks, expected, mode, modified, target);
+    this.publications.add(publication);
+    return publication.finally(() => {
+      this.publications.delete(publication);
+    });
+  }
+  async stage(root, path, chunks, expected, mode, modified, target) {
+    const { fs, signal } = this.context;
+    let temporary = "";
+    let identity2;
+    let created = false;
+    let failure;
+    const cleanup = retainFileSystemCleanup2(fs, async (view) => {
+      if (!created || !identity2) return;
+      try {
+        let parent = "/";
+        for (const component of dirname(temporary).split("/").filter(Boolean)) {
+          parent = resolvePath(parent, component);
+          if ((await view.lstat(parent)).type !== "directory") return;
+        }
+        const current = await view.lstat(temporary);
+        if (current.type === identity2.type && sameIdentity2(current, identity2)) await view.rm(temporary);
+      } catch (error) {
+        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOENT") throw error;
+      }
+    }, { maxOperations: Math.min(4096, this.limits.maxDepth + 3) });
+    try {
+      await this.parents(root, path, true);
+      for (let attempt = 0; attempt < this.limits.maxMembers; attempt++) {
+        temporary = resolvePath(dirname(path), `.unzip-${++this.serial}`);
+        checkPath(temporary, this.limits);
+        if (temporary === path || await this.stat(temporary)) continue;
+        await this.operation(async () => {
+          if (target === void 0) await fs.writeFile(temporary, new Uint8Array(), { signal, flag: "wx", mode: 384 });
+          else await fs.symlink(target, temporary, { signal });
+          created = true;
+          identity2 = await fs.lstat(temporary);
+        });
+        if (!identity2 || !hasIdentity(identity2)) fail2("temporary file backing identity unavailable");
+        break;
+      }
+      if (!created) fail2("temporary file attempt limit exceeded");
+      if (target === void 0) {
+        for (const chunk of chunks) {
+          await this.checked(root, temporary, identity2);
+          await this.operation(() => fs.appendFile(temporary, chunk, { signal }));
+        }
+        await this.metadata(root, temporary, identity2, mode, modified);
+      }
+      await this.parents(root, path, false);
+      const current = await this.stat(path);
+      if (current ? !expected || !sameIdentity2(current, expected) || current.type !== "file" : expected !== void 0) fail2("destination changed before publication");
+      const staging = await this.stat(temporary);
+      if (!staging || !identity2 || !sameIdentity2(staging, identity2) || staging.type !== (target === void 0 ? "file" : "symlink")) fail2("temporary file changed before publication");
+      await this.operation(() => fs.rename(temporary, path, { signal }));
+      created = false;
+    } catch (error) {
+      failure = { reason: error };
+    }
+    try {
+      await cleanup();
+    } catch (error) {
+      if (failure) throw new AggregateError([failure.reason, error], "unzip publication and cleanup failed");
+      throw error;
+    }
+    if (failure) throw failure.reason;
+  }
+};
+
+// packages/safe-bash/src/commands/archive/unzip.ts
+function filtered(name2) {
+  let output2 = "";
+  for (const character of name2) {
+    const code = character.charCodeAt(0);
+    output2 += code < 32 ? `^${String.fromCharCode(code + 64)}` : character;
+  }
+  return output2;
+}
+function padded(name2) {
+  return name2 + " ".repeat(Math.max(0, 22 - import_buffer.Buffer.byteLength(name2)));
+}
+function date(entry) {
+  const modified = entry.modified;
+  const pad = (value2) => String(value2).padStart(2, "0");
+  return `${modified.getFullYear()}-${pad(modified.getMonth() + 1)}-${pad(modified.getDate())} ${pad(modified.getHours())}:${pad(modified.getMinutes())}`;
+}
+async function comment(bytes3, budget) {
+  if (!bytes3.length) return;
+  const output2 = [];
+  let length = 0;
+  for (const byte of bytes3) {
+    if (!byte) break;
+    if (byte !== 13 && byte !== 19) length += byte === 27 ? 2 : 1;
+    if (length > budget.limits.maxTextBytes - budget.textBytes) fail2("text output limit exceeded");
+  }
+  for (const byte of bytes3) {
+    if (!byte) break;
+    if (byte === 13 || byte === 19) continue;
+    if (byte === 27) output2.push(94, 91);
+    else output2.push(byte);
+  }
+  if (output2.length && output2.at(-1) !== 10) output2.push(10);
+  const value2 = Uint8Array.from(output2);
+  if (value2.length > budget.limits.maxTextBytes - budget.textBytes) fail2("text output limit exceeded");
+  budget.textBytes += value2.length;
+  await writeBytes(budget.context.stdout, value2, budget.context.signal);
+}
+function createUnzipCommand(options3 = {}) {
+  const limits = settings2(options3);
+  return { name: "unzip", description: "List and safely extract ZIP archives in the virtual filesystem", async execute(original) {
+    original.signal.throwIfAborted();
+    const controller = new AbortController();
+    const context2 = { ...original, signal: AbortSignal.any([original.signal, controller.signal]) };
+    const extraction = new Extraction(context2, limits);
+    let answers;
+    let closing;
+    const close = () => closing ??= (async () => {
+      controller.abort(new Error("unzip command closed"));
+      await extraction.close();
+      await answers?.close().catch(() => {
+      });
+    })();
+    original.registerCleanup?.(close);
+    const budget = new Budget14(context2, limits);
+    try {
+      const parsed = parseArguments(context2, limits);
+      const selection = new Selection(parsed.patterns, limits, context2.signal);
+      let archive = parsed.archive;
+      let archiveStat;
+      for (const candidate of [archive, `${archive}.zip`, `${archive}.ZIP`]) {
+        checkPath(candidate, limits);
+        const candidateStat2 = await extraction.stat(vfsPath(context2.cwd, candidate));
+        if (candidateStat2) {
+          archive = candidate;
+          archiveStat = candidateStat2;
+          break;
+        }
+      }
+      if (!archiveStat) {
+        await budget.output(`unzip:  cannot find or open ${archive}, ${archive}.zip or ${archive}.ZIP.
+`, true);
+        return { exitCode: 9 };
+      }
+      const archivePath = await extraction.operation(() => context2.fs.realpath(vfsPath(context2.cwd, archive), { signal: context2.signal }));
+      archiveStat = await extraction.operation(() => context2.fs.stat(archivePath, { signal: context2.signal }));
+      if (archiveStat.type !== "file") fail2("input archive is not a regular file");
+      const bytes3 = await collectBytes(bounded(extraction.input(archivePath), limits.maxArchiveBytes, context2.signal, limits.chunkSize), { signal: context2.signal, maxBytes: limits.maxArchiveBytes });
+      await budget.output(`Archive:  ${filtered(archive)}
+`);
+      const zip = await readZipArchive(bytes3, limits, context2.signal);
+      await comment(zip.comment, budget);
+      if (!zip.entries.length) {
+        await budget.output(`warning [${filtered(archive)}]:  zipfile is empty
+`, true);
+        return { exitCode: 1 };
+      }
+      if (parsed.list) await budget.output("  Length      Date    Time    Name\n---------  ---------- -----   ----\n");
+      const rootRaw = parsed.destination === void 0 ? context2.cwd : vfsPath(context2.cwd, parsed.destination);
+      const root = parsed.list ? resolvePath(rootRaw) : await extraction.directory(rootRaw, true);
+      answers = new Answers(extraction.source(context2.stdin), limits, context2.signal);
+      let overwrite = parsed.overwrite ? "all" : "ask";
+      let exitCode = 0;
+      let selected = 0;
+      let total = 0;
+      let actualTotal = 0;
+      const links = [];
+      const directories = [];
+      for (const entry of zip.entries) {
+        await budget.member(entry.size);
+        checkPath(entry.name, limits);
+        if (!await selection.matches(entry.name)) continue;
+        selected++;
+        total += entry.size;
+        if (parsed.list) {
+          await budget.output(`${String(entry.size).padStart(9)}  ${date(entry)}   ${filtered(entry.name)}
+`);
+          if (entry.comment) await comment(entry.comment, budget);
+          continue;
+        }
+        let path = extraction.member(root, entry.name);
+        const fileType = entry.mode & 61440;
+        if (fileType && fileType !== 32768 && fileType !== 16384 && fileType !== 40960) fail2("unsupported special ZIP entry");
+        if (path === root && !entry.directory) fail2("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);
+        if (entry.directory) {
+          if (entry.size) fail2("directory has nonempty payload");
+          for await (const chunk of readBytes(decodeZipEntry(entry, limits, context2.signal), context2.signal)) {
+            await writeFileOutput(context2, chunk, async () => {
+              if (chunk.length) fail2("directory has nonempty payload");
+            });
+          }
+          const existing3 = await extraction.stat(path);
+          if (existing3 && existing3.type !== "directory") fail2("directory destination is not a directory");
+          if (!existing3) {
+            await extraction.operation(() => context2.fs.mkdir(path, { signal: context2.signal, mode: 493 }));
+            await budget.output(`   creating: ${filtered(shown)}
+`);
+          }
+          const identity2 = await extraction.stat(path);
+          if (!identity2 || identity2.type !== "directory") fail2("directory changed during creation");
+          directories.push({ path, entry, identity: identity2 });
+          continue;
+        }
+        let existing2 = await extraction.destination(path, archivePath, archiveStat);
+        let skip = false;
+        let prompting = 0;
+        while (existing2 && overwrite !== "all") {
+          if (overwrite === "none") {
+            skip = true;
+            break;
+          }
+          if (++prompting > limits.maxMembers) fail2("overwrite prompt work limit exceeded");
+          await budget.output(`replace ${filtered(shown)}? [y]es, [n]o, [A]ll, [N]one, [r]ename: `, true);
+          const answer = await answers.read();
+          if (answer === void 0) {
+            await budget.output(' NULL\n(EOF or read error, treating as "[N]one" ...)\n', true);
+            overwrite = "none";
+            exitCode = 1;
+            skip = true;
+            break;
+          }
+          const choice = answer[0];
+          if (choice === "A") {
+            overwrite = "all";
+            break;
+          }
+          if (choice === "y" || choice === "Y") break;
+          if (choice === "n" || choice === "N") {
+            if (choice === "N") overwrite = "none";
+            skip = true;
+            break;
+          }
+          if (choice === "r" || choice === "R") {
+            let renamed = "";
+            while (!renamed) {
+              await budget.output("new name: ", true);
+              const value2 = await answers.read(limits.maxPathBytes);
+              if (value2 === void 0) fail2("EOF while reading replacement name");
+              renamed = value2.endsWith("\n") ? value2.slice(0, -1) : value2;
+            }
+            path = extraction.member(root, renamed);
+            shown = parsed.destination === void 0 ? renamed : `${parsed.destination.endsWith("/") ? parsed.destination : `${parsed.destination}/`}${renamed}`;
+            await extraction.parents(root, path, true);
+            existing2 = await extraction.destination(path, archivePath, archiveStat);
+            continue;
+          }
+          const response = choice === "\n" || choice === "\r" ? "{ENTER}" : answer.endsWith("\n") ? answer.slice(0, -1) : answer;
+          await budget.output(`error:  invalid response [${response}]
+`, true);
+        }
+        if (skip) continue;
+        const chunks = [];
+        let actual = 0;
+        for await (const chunk of readBytes(decodeZipEntry(entry, limits, context2.signal), context2.signal)) {
+          if (chunk.length > limits.maxEntryBytes - actual || chunk.length > limits.maxTotalBytes - actualTotal) fail2("actual decompressed byte limit exceeded");
+          actual += chunk.length;
+          actualTotal += chunk.length;
+          await writeFileOutput(context2, chunk, async (bytes4) => {
+            chunks.push(Uint8Array.from(bytes4));
+          });
+        }
+        if (entry.symlink) {
+          if (actual > limits.maxPathBytes) fail2("symlink target byte limit exceeded");
+          const target = text2(import_buffer.Buffer.concat(chunks));
+          await extraction.target(root, path, target);
+          if (!context2.fs.symlink || context2.fs.capabilities.symlinks === false) fail2("filesystem does not support symlinks");
+          links.push({ path, shown, target, existing: existing2, entry });
+          await budget.output(`    linking: ${padded(filtered(shown))}  -> ${filtered(target)} 
+`);
+        } else {
+          await extraction.publish(root, path, chunks, existing2, entry.mode, entry.modified);
+          await budget.output(`${entry.method === 0 ? " extracting" : "  inflating"}: ${padded(filtered(shown))}  
+`);
+        }
+      }
+      if (parsed.list) await budget.output(`---------                     -------
+${String(total).padStart(9)}                     ${selected} file${selected === 1 ? "" : "s"}
+`);
+      else {
+        if (links.length) await budget.output("finishing deferred symbolic links:\n");
+        for (const link of links) {
+          await extraction.parents(root, link.path, false);
+          await extraction.target(root, link.path, link.target);
+          await extraction.destination(link.path, archivePath, archiveStat);
+          await extraction.publish(root, link.path, [], link.existing, link.entry.mode, link.entry.modified, link.target);
+          await budget.output(`  ${padded(filtered(link.shown))} -> ${filtered(link.target)}
+`);
+        }
+        for (const { path, entry, identity: identity2 } of directories.reverse()) {
+          await extraction.metadata(root, path, identity2, entry.mode, entry.modified);
+        }
+        for (let index = 0; index < parsed.patterns.length; index++) if (!selection.matched.has(index)) {
+          await budget.output(`caution: filename not matched:  ${filtered(parsed.patterns[index])}
+`, true);
+          exitCode = 11;
+        }
+      }
+      return { exitCode: selected ? exitCode : 11 };
+    } catch (error) {
+      original.signal.throwIfAborted();
+      const message3 = display(publicDiagnosticMessage(error, original.onInternalError).slice(0, limits.maxDiagnosticBytes));
+      await writeBytes(original.stderr, import_buffer.Buffer.from(`unzip: ${message3}
+`).subarray(0, limits.maxDiagnosticBytes), original.signal);
+      return { exitCode: 2 };
+    } finally {
+      await close();
+    }
+  } };
+}
+
 // packages/safe-bash/src/commands/archive/index.ts
 function createTarCommand(options3 = {}) {
   const limits = settings2(options3);
@@ -28219,12 +29758,16 @@ function createTarCommand(options3 = {}) {
   } };
 }
 function createArchiveCommands(options3 = {}) {
-  return [createTarCommand(options3)];
+  return [createTarCommand(options3), createZipCommand(options3), createUnzipCommand(options3)];
 }
 function archiveCommands(options3 = {}) {
   const commands = createArchiveCommands(options3);
   return { name: "archive-commands", setup(host2) {
-    if (!options3.replace && host2.commands.has("tar")) throw new Error("Command already registered: tar");
+    if (!options3.replace) {
+      for (const command7 of commands) {
+        if (host2.commands.has(command7.name)) throw new Error(`Command already registered: ${command7.name}`);
+      }
+    }
     for (const command7 of commands) host2.commands.register(command7, { replace: options3.replace ?? false });
   } };
 }
@@ -28642,17 +30185,17 @@ function createCommCommand(options3 = {}) {
 
 // packages/safe-bash/src/commands/table-text/join.ts
 init_platform();
-function number3(value2, label) {
+function number4(value2, label) {
   if (!/^[0-9]+$/u.test(value2) || !Number.isSafeInteger(Number(value2)) || Number(value2) < 1) fail3(`invalid ${label}: ${value2}`);
   return Number(value2);
 }
-function parse12(context2, budget) {
+function parse13(context2, budget) {
   const options3 = { files: [], fields: [0, 0], unpaired: /* @__PURE__ */ new Set(), paired: true, separator: 10, delimiter: void 0, whole: false, replacement: empty, format: void 0, fold: false, header: false, order: "default" };
   let literal = false;
   let delimiterChoice;
   const apply = (flag, value2) => {
     if (flag === "1" || flag === "2" || flag === "j") {
-      const field2 = number3(value2, "field") - 1;
+      const field2 = number4(value2, "field") - 1;
       if (flag !== "2") options3.fields[0] = field2;
       if (flag !== "1") options3.fields[1] = field2;
     } else if (flag === "a" || flag === "v") {
@@ -28687,7 +30230,7 @@ function parse12(context2, budget) {
         if (specification === "0") return { file: 0, index: 0 };
         const match = /^([12])\.([0-9]+)$/u.exec(specification);
         if (!match) fail3(`invalid output field: ${specification}`);
-        return { file: Number(match[1]), index: number3(match[2], "output field") - 1 };
+        return { file: Number(match[1]), index: number4(match[2], "output field") - 1 };
       });
       options3.format = [...Array.isArray(options3.format) ? options3.format : [], ...fields3];
       budget.check(options3.format.length, budget.limits.maxFields, "field");
@@ -28769,7 +30312,7 @@ function split3(bytes3, options3, budget) {
 function createJoinCommand(factory = {}) {
   const limits = settings3(factory);
   return command3("join", async (context2) => {
-    const budget = new Budget17(context2, limits), options3 = parse12(context2, budget);
+    const budget = new Budget17(context2, limits), options3 = parse13(context2, budget);
     requireCLocale(context2);
     const inputs2 = new Inputs(context2, budget, options3.separator), order = new OrderCheck(options3.order, context2);
     const terminator = Uint8Array.of(options3.separator), delimiter = Uint8Array.of(options3.delimiter ?? 32);
@@ -29195,9 +30738,9 @@ function tabs(specifications) {
       if (!entry) continue;
       const prefix3 = entry.match(/^[+/]+/u)?.[0] ?? "";
       if (prefix3) marker = prefix3.at(-1);
-      const number5 = entry.slice(prefix3.length);
-      if (!number5) continue;
-      const stop = integer(number5, marker ? 0 : 1);
+      const number6 = entry.slice(prefix3.length);
+      if (!number6) continue;
+      const stop = integer(number6, marker ? 0 : 1);
       if (marker === "+") {
         if (relativeRepeat) throw new UsageError("repeating tab stop must be last");
         relativeRepeat = stop;
@@ -29614,9 +31157,9 @@ function fixed2(coefficient, scale, precision) {
 function exponentOf(coefficient, scale) {
   return coefficient === 0n ? 0 : (coefficient < 0n ? -coefficient : coefficient).toString().length - scale - 1;
 }
-function formatted2(coefficient, scale, format2, negativeZero = false) {
-  const kind = format2.kind.toLowerCase();
-  let precision = format2.precision;
+function formatted2(coefficient, scale, format3, negativeZero = false) {
+  const kind = format3.kind.toLowerCase();
+  let precision = format3.precision;
   let exponent = exponentOf(coefficient, scale);
   let text3;
   if (kind === "f") text3 = fixed2(coefficient, scale, precision);
@@ -29628,24 +31171,24 @@ function formatted2(coefficient, scale, format2, negativeZero = false) {
     exponent = exponentOf(value2, significantScale);
     if (kind === "e" || exponent < -4 || exponent >= precision) {
       text3 = fixed2(value2, significantScale + exponent, significant - 1);
-      if (kind === "g" && !format2.flags.includes("#") && text3.includes(".")) text3 = text3.replace(/\.?0+$/u, "");
-      if (format2.flags.includes("#") && !text3.includes(".")) text3 += ".";
+      if (kind === "g" && !format3.flags.includes("#") && text3.includes(".")) text3 = text3.replace(/\.?0+$/u, "");
+      if (format3.flags.includes("#") && !text3.includes(".")) text3 += ".";
       text3 += `e${exponent < 0 ? "-" : "+"}${Math.abs(exponent).toString().padStart(2, "0")}`;
     } else {
       text3 = fixed2(value2, significantScale, Math.max(0, precision - exponent - 1));
-      if (!format2.flags.includes("#") && text3.includes(".")) text3 = text3.replace(/\.?0+$/u, "");
+      if (!format3.flags.includes("#") && text3.includes(".")) text3 = text3.replace(/\.?0+$/u, "");
     }
   }
-  if (format2.flags.includes("#") && !text3.includes(".") && !text3.includes("e")) text3 += ".";
+  if (format3.flags.includes("#") && !text3.includes(".") && !text3.includes("e")) text3 += ".";
   if ((coefficient < 0n || negativeZero) && !text3.startsWith("-")) text3 = "-" + text3;
-  if (coefficient >= 0n && !negativeZero) text3 = (format2.flags.includes("+") ? "+" : format2.flags.includes(" ") ? " " : "") + text3;
-  if (format2.kind === format2.kind.toUpperCase()) text3 = text3.toUpperCase();
-  if (format2.flags.includes("-")) text3 = text3.padEnd(format2.width, " ");
-  else if (format2.flags.includes("0")) {
+  if (coefficient >= 0n && !negativeZero) text3 = (format3.flags.includes("+") ? "+" : format3.flags.includes(" ") ? " " : "") + text3;
+  if (format3.kind === format3.kind.toUpperCase()) text3 = text3.toUpperCase();
+  if (format3.flags.includes("-")) text3 = text3.padEnd(format3.width, " ");
+  else if (format3.flags.includes("0")) {
     const sign = /^[+ -]/u.test(text3) ? text3[0] : "";
-    text3 = sign + text3.slice(sign.length).padStart(Math.max(0, format2.width - sign.length), "0");
-  } else text3 = text3.padStart(format2.width, " ");
-  return format2.prefix + text3 + format2.suffix;
+    text3 = sign + text3.slice(sign.length).padStart(Math.max(0, format3.width - sign.length), "0");
+  } else text3 = text3.padStart(format3.width, " ");
+  return format3.prefix + text3 + format3.suffix;
 }
 function binaryDecimal(value2) {
   const view = new DataView(new ArrayBuffer(8));
@@ -29658,12 +31201,12 @@ function binaryDecimal(value2) {
   if (bits >> 63n) coefficient = -coefficient;
   return power2 >= 0 ? { coefficient: coefficient << BigInt(power2), scale: 0 } : { coefficient: coefficient * 5n ** BigInt(-power2), scale: -power2 };
 }
-async function floatingSequence(first, increment, last, format2, separator, session) {
+async function floatingSequence(first, increment, last, format3, separator, session) {
   if (![first, increment, last].every(Number.isFinite) || increment === 0) throw new UsageError("formatted operands must fit finite binary64 with a nonzero increment");
   if (increment > 0 ? first > last : first < last) return;
-  const render2 = (number5) => {
-    const decimal4 = binaryDecimal(number5);
-    const text3 = formatted2(decimal4.coefficient, decimal4.scale, format2, Object.is(number5, -0));
+  const render2 = (number6) => {
+    const decimal4 = binaryDecimal(number6);
+    const text3 = formatted2(decimal4.coefficient, decimal4.scale, format3, Object.is(number6, -0));
     session.check(import_buffer.Buffer.byteLength(text3), session.limits.maxRecordBytes, "record");
     return text3;
   };
@@ -29679,7 +31222,7 @@ async function floatingSequence(first, increment, last, format2, separator, sess
     const outside = increment > 0 ? current > last : current < last;
     const text3 = render2(current);
     if (outside) {
-      const numeric4 = text3.slice(format2.prefix.length, text3.length - format2.suffix.length);
+      const numeric4 = text3.slice(format3.prefix.length, text3.length - format3.suffix.length);
       if (Number(numeric4) !== last || text3 === previous) break;
     }
     await session.text((index ? separator : "") + text3);
@@ -29766,9 +31309,9 @@ function createSeqCommand(limits) {
     let current = align(first);
     const step = align(increment), finish = align(last);
     const precision = Math.max(first.precision, increment.precision);
-    const format2 = formatText === void 0 ? void 0 : parseFormat(formatText, session);
-    if (format2) {
-      await floatingSequence(Number(operands.length === 1 ? "1" : operands[0]), Number(operands.length === 3 ? operands[1] : "1"), Number(operands.at(-1)), format2, separator, session);
+    const format3 = formatText === void 0 ? void 0 : parseFormat(formatText, session);
+    if (format3) {
+      await floatingSequence(Number(operands.length === 1 ? "1" : operands[0]), Number(operands.length === 3 ? operands[1] : "1"), Number(operands.at(-1)), format3, separator, session);
       return;
     }
     const firstText = (first.negativeZero ? "-" : "") + fixed2(current, scale, precision);
@@ -29806,9 +31349,9 @@ function style(text3) {
 }
 function signed(text3) {
   if (!/^[+-]?\d+$/u.test(text3.trim())) throw new UsageError(`invalid line number: '${text3}'`);
-  const number5 = BigInt(text3);
-  if (number5 < -(1n << 63n) || number5 >= 1n << 63n) throw new UsageError(`line number out of range: '${text3}'`);
-  return number5;
+  const number6 = BigInt(text3);
+  if (number6 < -(1n << 63n) || number6 >= 1n << 63n) throw new UsageError(`line number out of range: '${text3}'`);
+  return number6;
 }
 function createNlCommand(limits) {
   return command5("nl", limits, async (session) => {
@@ -29828,8 +31371,8 @@ function createNlCommand(limits) {
     const header3 = style(value(parsed, "h") ?? "n"), body = style(value(parsed, "b") ?? "t"), footer = style(value(parsed, "f") ?? "n");
     const start = signed(value(parsed, "v") ?? "1"), increment = signed(value(parsed, "i") ?? "1");
     const join = Math.max(1, integer(value(parsed, "l") ?? "1")), width = integer(value(parsed, "w") ?? "6", 1);
-    const separator = value(parsed, "s") ?? "	", format2 = value(parsed, "n") ?? "rn";
-    if (!["ln", "rn", "rz"].includes(format2)) throw new UsageError(`invalid line numbering format: '${format2}'`);
+    const separator = value(parsed, "s") ?? "	", format3 = value(parsed, "n") ?? "rn";
+    if (!["ln", "rn", "rz"].includes(format3)) throw new UsageError(`invalid line numbering format: '${format3}'`);
     session.check(width + import_buffer.Buffer.byteLength(separator), limits.maxRecordBytes, "number field");
     let delimiter = import_buffer.Buffer.from("\\:");
     for (const argument2 of parsed.values.get("d") ?? []) {
@@ -29839,14 +31382,14 @@ function createNlCommand(limits) {
     const delimiters2 = [1, 2, 3].map((count2) => import_buffer.Buffer.concat(Array.from({ length: count2 }, () => delimiter)));
     const budget = new PatternBudget(session);
     const unnumbered = " ".repeat(width + import_buffer.Buffer.byteLength(separator));
-    let current = body, number5 = start, blanks = 0;
+    let current = body, number6 = start, blanks = 0;
     await session.files(session.names(parsed.operands), async (source2) => {
       for await (const record4 of records2(source2, session)) {
         const bytes3 = import_buffer.Buffer.from(record4);
         const section = delimiter.length ? delimiters2.findIndex((candidate) => candidate.equals(bytes3)) : -1;
         if (section >= 0) {
           current = section === 0 ? footer : section === 1 ? body : header3;
-          if (!parsed.flags.has("p")) number5 = start;
+          if (!parsed.flags.has("p")) number6 = start;
           await session.text("\n");
           continue;
         }
@@ -29858,13 +31401,13 @@ function createNlCommand(limits) {
         else if (current === "n") numbered = false;
         else numbered = await current.find(bytes3.toString("latin1"), budget) !== void 0;
         if (numbered) {
-          if (number5 < -(1n << 63n) || number5 >= 1n << 63n) throw new UsageError("line number overflow");
-          let label = number5.toString();
-          if (format2 === "ln") label = label.padEnd(width, " ");
-          else if (format2 === "rz" && number5 < 0n) label = "-" + label.slice(1).padStart(width - 1, "0");
-          else label = label.padStart(width, format2 === "rz" ? "0" : " ");
+          if (number6 < -(1n << 63n) || number6 >= 1n << 63n) throw new UsageError("line number overflow");
+          let label = number6.toString();
+          if (format3 === "ln") label = label.padEnd(width, " ");
+          else if (format3 === "rz" && number6 < 0n) label = "-" + label.slice(1).padStart(width - 1, "0");
+          else label = label.padStart(width, format3 === "rz" ? "0" : " ");
           await session.text(label + separator);
-          number5 += increment;
+          number6 += increment;
         } else await session.text(unnumbered);
         await session.output(record4);
         await session.text("\n");
@@ -29941,13 +31484,13 @@ function tabStops(specifications, session) {
     for (const entry of specification.split(/[, \t]+/u).filter(Boolean)) {
       if (repeat) throw new UsageError("repeating tab stop must be last");
       const marker = entry[0] === "+" || entry[0] === "/" ? entry[0] : "";
-      const number5 = integer(entry.slice(marker.length), 1);
+      const number6 = integer(entry.slice(marker.length), 1);
       if (marker) {
-        repeat = number5;
+        repeat = number6;
         relative = marker === "+";
       } else {
-        if (number5 <= (stops.at(-1) ?? 0)) throw new UsageError("tab stops must be ascending");
-        stops.push(number5);
+        if (number6 <= (stops.at(-1) ?? 0)) throw new UsageError("tab stops must be ascending");
+        stops.push(number6);
       }
     }
   }
@@ -30080,7 +31623,7 @@ function settings6(options3) {
   }
   return limits;
 }
-function number4(text3, label, units = false, zero2 = false) {
+function number5(text3, label, units = false, zero2 = false) {
   const match = /^[\t\n\v\f\r ]*\+?([0-9]*)([a-zA-Z]*)$/u.exec(text3);
   if (!match || !match[1] && (!units || !match[2] || text3 !== match[2])) throw new PublicDiagnostic(`invalid ${label}: '${text3}'`);
   const suffix2 = match[2];
@@ -30099,7 +31642,7 @@ function number4(text3, label, units = false, zero2 = false) {
   if (!Number.isSafeInteger(value2) || value2 < (zero2 ? 0 : 1)) throw new PublicDiagnostic(`invalid ${label}: '${text3}'`);
   return value2;
 }
-function parseArguments(args, limits) {
+function parseArguments2(args, limits) {
   if (args.reduce((total, argument2) => total + import_buffer.Buffer.byteLength(argument2), 0) > limits.maxArgumentBytes) {
     throw new PublicDiagnostic("split argument limit exceeded");
   }
@@ -30118,14 +31661,14 @@ function parseArguments(args, limits) {
         if (!/^[0-9]*$/u.test(value2)) throw new PublicDiagnostic(`invalid start value for numerical suffix: '${value2}'`);
         numericStart = value2.replace(/^0+(?=\d)/u, "") || "0";
       }
-    } else if (option === "a") suffixLength = number4(value2, "suffix length", false, true);
+    } else if (option === "a") suffixLength = number5(value2, "suffix length", false, true);
     else if (option === "additional-suffix") {
       if (value2.includes("/") || value2.includes("\0")) throw new PublicDiagnostic("invalid additional suffix: contains directory separator or NUL");
       additionalSuffix = value2;
     } else {
       if (mode) throw new PublicDiagnostic("cannot split in more than one way");
       mode = option === "l" ? "lines" : option === "b" ? "bytes" : "line-bytes";
-      size = number4(value2, option === "l" ? "number of lines" : "number of bytes", option !== "l");
+      size = number5(value2, option === "l" ? "number of lines" : "number of bytes", option !== "l");
     }
   };
   const long = {
@@ -30472,7 +32015,7 @@ var LineBytes = class {
   }
 };
 async function run3(context2, limits) {
-  const args = parseArguments(context2.args, limits);
+  const args = parseArguments2(context2.args, limits);
   const controller = new AbortController();
   const signal = AbortSignal.any([context2.signal, controller.signal]);
   const budget = new Budget18(limits, signal);
@@ -30725,22 +32268,22 @@ function millisecondsInstant(value2) {
   return boundedInstant(scale >= 0 ? coefficient * 10n ** BigInt(scale) : floorDivide(coefficient, 10n ** BigInt(-scale)));
 }
 function utcMilliseconds(fields3) {
-  const date = /* @__PURE__ */ new Date(0);
-  date.setUTCFullYear(fields3.year, fields3.month - 1, fields3.day);
-  date.setUTCHours(fields3.hour, fields3.minute, fields3.second, 0);
-  const value2 = date.getTime();
+  const date2 = /* @__PURE__ */ new Date(0);
+  date2.setUTCFullYear(fields3.year, fields3.month - 1, fields3.day);
+  date2.setUTCHours(fields3.hour, fields3.minute, fields3.second, 0);
+  const value2 = date2.getTime();
   if (!Number.isFinite(value2)) throw new CommandFailure("date is outside the supported range");
   return value2;
 }
 function utcFields(milliseconds) {
-  const date = new Date(milliseconds);
+  const date2 = new Date(milliseconds);
   return {
-    year: date.getUTCFullYear(),
-    month: date.getUTCMonth() + 1,
-    day: date.getUTCDate(),
-    hour: date.getUTCHours(),
-    minute: date.getUTCMinutes(),
-    second: date.getUTCSeconds()
+    year: date2.getUTCFullYear(),
+    month: date2.getUTCMonth() + 1,
+    day: date2.getUTCDate(),
+    hour: date2.getUTCHours(),
+    minute: date2.getUTCMinutes(),
+    second: date2.getUTCSeconds()
   };
 }
 function sameFields(left, right) {
@@ -30905,7 +32448,7 @@ function offsetText(offset, colons) {
   if (colons === 1 || minutes !== "00") return { value: `${sign}${hours}:${minutes}`, width: 6 };
   return { value: `${sign}${hours}`, width: 3 };
 }
-function formatDate(format2, instant, zone, limits) {
+function formatDate(format3, instant, zone, limits) {
   const fields3 = zone.fields(instant);
   const midnight = utcMilliseconds({ ...fields3, hour: 0, minute: 0, second: 0 });
   const weekday = new Date(midnight).getUTCDay();
@@ -30914,8 +32457,8 @@ function formatDate(format2, instant, zone, limits) {
   const isoYear = thursday.getUTCFullYear();
   const isoWeek = 1 + Math.floor((thursday.getTime() - utcMilliseconds({ year: isoYear, month: 1, day: 1, hour: 0, minute: 0, second: 0 })) / 6048e5);
   const nano = (instant - floorDivide(instant, nanosecondsPerSecond) * nanosecondsPerSecond).toString().padStart(9, "0");
-  const number5 = (value2, width = 2, padding = "0") => value2.toString().padStart(width, padding);
-  const time = `${number5(fields3.hour)}:${number5(fields3.minute)}:${number5(fields3.second)}`;
+  const number6 = (value2, width = 2, padding = "0") => value2.toString().padStart(width, padding);
+  const time = `${number6(fields3.hour)}:${number6(fields3.minute)}:${number6(fields3.second)}`;
   const hour12 = fields3.hour % 12 || 12;
   const meridian = fields3.hour < 12 ? "AM" : "PM";
   const pieces = [];
@@ -30925,32 +32468,32 @@ function formatDate(format2, instant, zone, limits) {
     checkSize(size + 1, limits.maxOutputBytes, "output");
     pieces.push(value2);
   };
-  for (let offset = 0; offset < format2.length; ) {
-    const next = format2.indexOf("%", offset);
+  for (let offset = 0; offset < format3.length; ) {
+    const next = format3.indexOf("%", offset);
     if (next < 0) {
-      append(format2.slice(offset));
+      append(format3.slice(offset));
       break;
     }
-    append(format2.slice(offset, next));
+    append(format3.slice(offset, next));
     offset = next + 1;
     let padding, upper = false, swap = false;
-    while (offset < format2.length && "-_0^#".includes(format2[offset])) {
-      const flag = format2[offset++];
+    while (offset < format3.length && "-_0^#".includes(format3[offset])) {
+      const flag = format3[offset++];
       if (flag === "^") upper = true;
       else if (flag === "#") swap = true;
       else padding = flag === "-" ? "" : flag === "_" ? " " : "0";
     }
     let widthText = "";
-    while (offset < format2.length && /[0-9]/.test(format2[offset])) widthText += format2[offset++];
+    while (offset < format3.length && /[0-9]/.test(format3[offset])) widthText += format3[offset++];
     const width = widthText ? Number(widthText) : void 0;
     if (width !== void 0) checkSize(width, limits.maxFormatWidth, "format width");
     let colons = 0;
-    while (format2[offset] === ":") {
+    while (format3[offset] === ":") {
       colons++;
       offset++;
     }
-    const modifier = format2[offset] === "E" || format2[offset] === "O" ? format2[offset++] : void 0;
-    const code = format2[offset++];
+    const modifier = format3[offset] === "E" || format3[offset] === "O" ? format3[offset++] : void 0;
+    const code = format3[offset++];
     if (!code || colons > 3 || colons && code !== "z") throw new CommandFailure("unsupported date format directive");
     if (code === "%" && (padding !== void 0 || upper || swap || width !== void 0 || modifier)) {
       throw new CommandFailure("only an unmodified %% literal is supported");
@@ -30975,7 +32518,7 @@ function formatDate(format2, instant, zone, limits) {
         value2 = monthNames[fields3.month - 1];
         break;
       case "c":
-        value2 = `${weekdayNames[weekday].slice(0, 3)} ${monthNames[fields3.month - 1].slice(0, 3)} ${number5(fields3.day, 2, " ")} ${time} ${number5(fields3.year, 4)}`;
+        value2 = `${weekdayNames[weekday].slice(0, 3)} ${monthNames[fields3.month - 1].slice(0, 3)} ${number6(fields3.day, 2, " ")} ${time} ${number6(fields3.year, 4)}`;
         break;
       case "C":
         value2 = String(Math.floor(fields3.year / 100));
@@ -30988,15 +32531,15 @@ function formatDate(format2, instant, zone, limits) {
         if (code === "e") defaultPadding = " ";
         break;
       case "D":
-        value2 = `${number5(fields3.month)}/${number5(fields3.day)}/${number5(fields3.year % 100, 2, padding ?? "0")}`;
+        value2 = `${number6(fields3.month)}/${number6(fields3.day)}/${number6(fields3.year % 100, 2, padding ?? "0")}`;
         break;
       case "x":
-        value2 = `${number5(fields3.month)}/${number5(fields3.day)}/${number5(fields3.year % 100)}`;
+        value2 = `${number6(fields3.month)}/${number6(fields3.day)}/${number6(fields3.year % 100)}`;
         break;
       case "F": {
         const yearWidth = width === void 0 && padding === void 0 ? 4 : Math.max(0, (width ?? 0) - 6);
-        const year = padding === "" ? String(fields3.year) : number5(fields3.year, yearWidth, padding ?? "0");
-        append(`${year}-${number5(fields3.month)}-${number5(fields3.day)}`);
+        const year = padding === "" ? String(fields3.year) : number6(fields3.year, yearWidth, padding ?? "0");
+        append(`${year}-${number6(fields3.month)}-${number6(fields3.day)}`);
         continue;
       }
       case "g":
@@ -31053,10 +32596,10 @@ function formatDate(format2, instant, zone, limits) {
         defaultWidth = 1;
         break;
       case "r":
-        value2 = `${number5(hour12)}:${number5(fields3.minute)}:${number5(fields3.second)} ${meridian}`;
+        value2 = `${number6(hour12)}:${number6(fields3.minute)}:${number6(fields3.second)} ${meridian}`;
         break;
       case "R":
-        value2 = `${number5(fields3.hour)}:${number5(fields3.minute)}`;
+        value2 = `${number6(fields3.hour)}:${number6(fields3.minute)}`;
         break;
       case "s":
         value2 = floorDivide(instant, nanosecondsPerSecond).toString();
@@ -31124,8 +32667,8 @@ function formatDate(format2, instant, zone, limits) {
 }
 
 // packages/safe-bash/src/commands/time-env/date.ts
-function parseArguments2(args) {
-  let input3, reference, format2, style2;
+function parseArguments3(args) {
+  let input3, reference, format3, style2;
   let utc = false, ended = false;
   const formatted3 = (value2) => {
     if (style2 !== void 0) throw new CommandFailure("multiple output formats specified");
@@ -31217,15 +32760,15 @@ function parseArguments2(args) {
       }
     } else {
       if (!argument2.startsWith("+")) throw new CommandFailure("expected +FORMAT; clock-setting operands are unsupported");
-      if (format2 !== void 0) throw new CommandFailure("extra format operand");
-      format2 = argument2.slice(1);
+      if (format3 !== void 0) throw new CommandFailure("extra format operand");
+      format3 = argument2.slice(1);
     }
   }
   if (input3 !== void 0 && reference !== void 0) throw new CommandFailure("--date and --reference are mutually exclusive");
-  if (format2 !== void 0 && style2 !== void 0) throw new CommandFailure("multiple output formats specified");
+  if (format3 !== void 0 && style2 !== void 0) throw new CommandFailure("multiple output formats specified");
   return {
     utc,
-    format: format2 ?? style2 ?? "%a %b %e %T %Z %Y",
+    format: format3 ?? style2 ?? "%a %b %e %T %Z %Y",
     ...input3 === void 0 ? {} : { input: input3 },
     ...reference === void 0 ? {} : { reference }
   };
@@ -31233,7 +32776,7 @@ function parseArguments2(args) {
 function createDateCommand(configuration) {
   new TimeZone(configuration.defaultTimeZone);
   return command6("date", configuration, async (context2) => {
-    const parsed = parseArguments2(context2.args);
+    const parsed = parseArguments3(context2.args);
     if (parsed.informational) {
       await emit(context2, parsed.informational === "version" ? "date (safe-bash virtual command)\n" : "Usage: date [-u] [-d DATE | -r FILE] [+FORMAT]\nAlso: -I[date|hours|minutes|seconds|ns], -R, --rfc-3339=PRECISION\nDATE accepts @seconds, ISO calendar/time, RFC dates, now/today/yesterday/tomorrow, and integer seconds/minutes/hours relative to now.\nVirtual TZ defaults to UTC; no clock setting or host-locale parsing.\n", configuration.limits);
       return 0;
@@ -31614,7 +33157,7 @@ function environmentCharset(budget) {
 }
 
 // packages/safe-bash/src/commands/tree/arguments.ts
-function parse13(args, budget) {
+function parse14(args, budget) {
   budget.check(args.length, budget.limits.maxArguments, "argument count");
   let bytes3 = 0;
   for (const arg of args) {
@@ -31983,7 +33526,7 @@ function createTreeCommand(options3 = {}) {
     const budget = new WalkBudget(context2, limits);
     let args;
     try {
-      args = parse13(context2.args, budget);
+      args = parse14(context2.args, budget);
     } catch (error) {
       context2.signal.throwIfAborted();
       if (!(error instanceof UsageError2)) throw error;
@@ -32289,7 +33832,7 @@ function limitMessage(error) {
 // packages/safe-bash/src/commands/file/index.ts
 var profile = "virtual-bash-file-v1";
 var help2 = "Usage: file [-bihL] [--mime-type] [--mime-encoding] [--] FILE...\nClassify bounded VFS content; '-' reads stdin. -h is the default.\nOptions: --brief, --mime, --dereference, --no-dereference, --help, --version\nNo decompression, external magic database, or complete format validation.\n";
-async function parse14(args, budget) {
+async function parse15(args, budget) {
   const result2 = { brief: false, follow: false, mimeType: false, mimeEncoding: false, names: [] };
   let argumentBytes = 0;
   budget.check(args.length, budget.limits.maxArgumentBytes, "argument");
@@ -32437,7 +33980,7 @@ function createFileCommand(options3 = {}) {
     const budget = new SharedBudget(context2, limits);
     let writing = false;
     try {
-      const args = await parse14(context2.args, budget);
+      const args = await parse15(context2.args, budget);
       if (args.action) {
         writing = true;
         await budget.output(context2.stdout, args.action === "help" ? help2 : `file (${profile})
@@ -32665,7 +34208,7 @@ function readerSettings(limits) {
 function usage(message3) {
   throw new FsError("EINVAL", { message: message3 });
 }
-function parse15(args, limits) {
+function parse16(args, limits) {
   if (args.length > limits.maxArgumentBytes) usage("argument count limit exceeded");
   let argumentBytes = 0;
   for (const token of args) {
@@ -33057,7 +34600,7 @@ function createColumnCommand(options3 = {}) {
     let rejection;
     try {
       try {
-        const parsed = parse15(context2.args, limits);
+        const parsed = parse16(context2.args, limits);
         inputs2 = new ColumnInputs(context2, limits);
         const budget = inputs2.budget;
         if (parsed.help) await budget.text(helpText3);
@@ -33872,7 +35415,7 @@ This documented HTML subset is a converter, not a sanitizer or browser HTML5 par
 
 // packages/safe-bash/src/commands/html-to-markdown/render.ts
 init_platform();
-var format = (tag) => tag === "em" || tag === "i" ? "em" : tag === "strong" || tag === "b" ? "strong" : tag === "del" || tag === "s" ? "del" : void 0;
+var format2 = (tag) => tag === "em" || tag === "i" ? "em" : tag === "strong" || tag === "b" ? "strong" : tag === "del" || tag === "s" ? "del" : void 0;
 var inlineAtoms = /* @__PURE__ */ new Set(["a", "img", "code", "br"]);
 var Renderer = class {
   constructor(budget) {
@@ -33951,9 +35494,9 @@ var Renderer = class {
     const append = async (child, target = result2) => {
       this.budget.work(1);
       await this.budget.checkpoint();
-      const style2 = format(child.tag);
+      const style2 = format2(child.tag);
       const previous = target.at(-1);
-      if (style2 && previous && format(previous.tag) === style2) {
+      if (style2 && previous && format2(previous.tag) === style2) {
         for (const nested of child.children) await append(nested, previous.children);
       } else target.push(child);
     };
@@ -33979,9 +35522,9 @@ var Renderer = class {
         this.budget.work(1);
         this.destinations.set(child, url);
       }
-      const style2 = format(child.tag);
+      const style2 = format2(child.tag);
       if (child.tag !== "text" && !blockTags.has(child.tag) && !inlineAtoms.has(child.tag)) {
-        if (!style2 || style2 === format(node.tag)) {
+        if (!style2 || style2 === format2(node.tag)) {
           for (const nested of child.children) await visit(nested);
           return;
         }
@@ -34003,7 +35546,7 @@ var Renderer = class {
     return result2;
   }
   async punctuationBoundary(node, ending) {
-    if (!node || !format(node.tag)) return false;
+    if (!node || !format2(node.tag)) return false;
     const edge = async (parent) => {
       for (let step = 0; step < parent.children.length; step++) {
         this.budget.work(1);
@@ -34012,7 +35555,7 @@ var Renderer = class {
         if (child.tag === "text") {
           if (child.text) return ending ? Array.from(child.text.slice(-2)).at(-1) : String.fromCodePoint(child.text.codePointAt(0));
         } else if (child.tag === "br" || blockTags.has(child.tag)) return " ";
-        else if (format(child.tag) || inlineAtoms.has(child.tag)) return "*";
+        else if (format2(child.tag) || inlineAtoms.has(child.tag)) return "*";
         else {
           const nested = await edge(child);
           if (nested !== void 0) return nested;
@@ -34050,8 +35593,8 @@ var Renderer = class {
   async children(node, maximum = this.budget.limits.maxOutputBytes - this.budget.output) {
     const result2 = new Builder(this.budget, maximum);
     const children = await this.inlineChildren(node);
-    const alternate = (index) => format(node.tag) === "em" || format(children[index - 1]?.tag ?? "") === "em" || format(children[index + 1]?.tag ?? "") === "em";
-    const separate = async (index, ending) => format(children[index]?.tag ?? "") === "strong" && alternate(index) || await this.punctuationBoundary(children[index], ending);
+    const alternate = (index) => format2(node.tag) === "em" || format2(children[index - 1]?.tag ?? "") === "em" || format2(children[index + 1]?.tag ?? "") === "em";
+    const separate = async (index, ending) => format2(children[index]?.tag ?? "") === "strong" && alternate(index) || await this.punctuationBoundary(children[index], ending);
     for (let index = 0; index < children.length; index++) {
       const child = children[index];
       this.budget.work(1);
@@ -34361,10 +35904,10 @@ function blockSize2(value2) {
 function ceiling(value2, divisor) {
   return (value2 + divisor - 1n) / divisor;
 }
-function formatSize(value2, format2) {
+function formatSize(value2, format3) {
   const bytes3 = BigInt(value2);
-  if (!format2.human) return `${ceiling(bytes3, format2.unit)}${format2.suffix}`;
-  const base = BigInt(format2.human);
+  if (!format3.human) return `${ceiling(bytes3, format3.unit)}${format3.suffix}`;
+  const base = BigInt(format3.human);
   let unit2 = 1n;
   let exponent = 0;
   while (bytes3 >= unit2 * base) {
@@ -34377,13 +35920,13 @@ function formatSize(value2, format2) {
     exponent++;
   }
   const tenths = ceiling(bytes3 * 10n, unit2);
-  const number5 = tenths < 100n ? `${tenths / 10n}.${tenths % 10n}` : String(ceiling(bytes3, unit2));
-  const suffix2 = (format2.human === 1e3 ? "kMGTPEZYRQ" : "KMGTPEZYRQ")[exponent - 1];
-  return number5 + suffix2;
+  const number6 = tenths < 100n ? `${tenths / 10n}.${tenths % 10n}` : String(ceiling(bytes3, unit2));
+  const suffix2 = (format3.human === 1e3 ? "kMGTPEZYRQ" : "KMGTPEZYRQ")[exponent - 1];
+  return number6 + suffix2;
 }
 
 // packages/safe-bash/src/commands/du/arguments.ts
-function parse16(budget) {
+function parse17(budget) {
   const { args, env } = budget.context;
   budget.check(args.length, budget.limits.maxArguments, "argument count");
   let bytes3 = 0;
@@ -34397,11 +35940,11 @@ function parse16(budget) {
   const operands = [];
   let all = false, summarize = false, total = false, apparent = false, countLinks = false, nullOutput = false, help5 = false;
   let depth;
-  let format2;
+  let format3;
   let options3 = true;
   const valueOption = (flag, value2) => {
     if (flag === "B" || flag === "block-size") {
-      format2 = blockSize2(value2);
+      format3 = blockSize2(value2);
       return;
     }
     if (!/^\d+$/u.test(value2) || !Number.isSafeInteger(Number(value2))) throw new UsageError3(`invalid maximum depth '${value2}'`);
@@ -34423,18 +35966,18 @@ function parse16(budget) {
         break;
       case "h":
       case "human-readable":
-        format2 = blockSize2("human-readable");
+        format3 = blockSize2("human-readable");
         break;
       case "k":
-        format2 = blockSize2("1024");
+        format3 = blockSize2("1024");
         break;
       case "m":
-        format2 = blockSize2("1048576");
+        format3 = blockSize2("1048576");
         break;
       case "b":
       case "bytes":
         apparent = true;
-        format2 = blockSize2("1");
+        format3 = blockSize2("1");
         break;
       case "apparent-size":
         apparent = true;
@@ -34490,7 +36033,7 @@ function parse16(budget) {
   }
   if (all && summarize) throw new UsageError3("cannot combine --all and --summarize");
   if (summarize && depth !== void 0 && depth !== 0) throw new UsageError3("--summarize conflicts with --max-depth");
-  if (!format2) {
+  if (!format3) {
     let selected;
     for (const name2 of ["DU_BLOCK_SIZE", "BLOCK_SIZE", "BLOCKSIZE"]) {
       if (Object.hasOwn(env, name2)) {
@@ -34503,16 +36046,16 @@ function parse16(budget) {
       budget.check(import_buffer.Buffer.byteLength(selected), budget.limits.maxArgumentBytes - bytes3, "environment bytes");
       budget.step(selected.length + 1);
       try {
-        format2 = blockSize2(selected);
+        format3 = blockSize2(selected);
       } catch (error) {
         if (!(error instanceof UsageError3)) throw error;
-        format2 = blockSize2(Object.hasOwn(env, "POSIXLY_CORRECT") ? "512" : "1024");
+        format3 = blockSize2(Object.hasOwn(env, "POSIXLY_CORRECT") ? "512" : "1024");
       }
-    } else format2 = blockSize2(Object.hasOwn(env, "POSIXLY_CORRECT") ? "512" : "1024");
+    } else format3 = blockSize2(Object.hasOwn(env, "POSIXLY_CORRECT") ? "512" : "1024");
   }
   if (operands.length === 0) operands.push(".");
   for (const operand of operands) budget.text(operand);
-  return { operands, all, summarize, total, apparent, countLinks, nullOutput, depth: summarize ? 0 : depth ?? Number.MAX_SAFE_INTEGER, format: format2, help: help5 };
+  return { operands, all, summarize, total, apparent, countLinks, nullOutput, depth: summarize ? 0 : depth ?? Number.MAX_SAFE_INTEGER, format: format3, help: help5 };
 }
 var helpText5 = `Usage: du [OPTION]... [--] [FILE]...
 Report provider allocation; unknown allocation is an error, never logical size.
@@ -34837,7 +36380,7 @@ function createDuCommand(options3 = {}) {
     const budget = new Budget21(work, limits, context2);
     context2.registerCleanup?.(budget.close);
     try {
-      const args = parse16(budget);
+      const args = parse17(budget);
       if (context2.stdout.ownedOutput) operation2 = createOutputOperation(context2, context2.stdout);
       if (args.help) {
         await budget.emit(work.stdout, helpText5);
@@ -35120,9 +36663,9 @@ async function evaluateCall(operator, values, budget, match) {
         const candidateEnd = nextCharacter(accept, candidate, unicode);
         budget.charge(1 + end2 - offset);
         if (end2 - offset === candidateEnd - candidate) {
-          let equal = true;
-          for (let byte = 0; byte < end2 - offset; byte++) if (subject[offset + byte] !== accept[candidate + byte]) equal = false;
-          if (equal) return smallInteger(position2, budget);
+          let equal2 = true;
+          for (let byte = 0; byte < end2 - offset; byte++) if (subject[offset + byte] !== accept[candidate + byte]) equal2 = false;
+          if (equal2) return smallInteger(position2, budget);
         }
         candidate = candidateEnd;
         await budget.yield();
@@ -35369,7 +36912,7 @@ function settings14(options3) {
 
 // packages/safe-bash/src/commands/which/which.ts
 var USAGE = "usage: which [-as] program ...\n";
-var encoder2 = new TextEncoder();
+var encoder3 = new TextEncoder();
 var descriptions = {
   EACCES: "permission denied",
   EAGAIN: "resource temporarily unavailable",
@@ -35487,7 +37030,7 @@ ${USAGE}`);
   }
   async write(sink, text3) {
     this.check();
-    const bytes3 = encoder2.encode(text3);
+    const bytes3 = encoder3.encode(text3);
     this.check();
     try {
       await writeBytes(sink, bytes3, this.context.signal);
@@ -35827,22 +37370,22 @@ function createDeadline(binding, duration2, maximumChunk) {
 }
 
 // packages/safe-bash/src/commands/timeout/index.ts
-var encoder3 = new TextEncoder();
+var encoder4 = new TextEncoder();
 var records3 = Object.freeze({
-  missingDuration: encoder3.encode("timeout: missing duration\n"),
-  invalidDuration: encoder3.encode("timeout: invalid duration\n"),
-  durationOverflow: encoder3.encode("timeout: duration exceeds supported range\n"),
-  missingCommand: encoder3.encode("timeout: missing command\n"),
-  invalidOption: encoder3.encode("timeout: invalid option\n"),
-  preserveStatus: encoder3.encode("timeout: option --preserve-status is unsupported\n"),
-  signal: encoder3.encode("timeout: option --signal is unsupported\n"),
-  killAfter: encoder3.encode("timeout: option --kill-after is unsupported\n"),
-  foreground: encoder3.encode("timeout: option --foreground is unsupported\n"),
-  verbose: encoder3.encode("timeout: option --verbose is unsupported\n"),
-  invokeUnavailable: encoder3.encode("timeout: command invocation is unavailable\n"),
-  timerSetupFailed: encoder3.encode("timeout: timer setup failed\n"),
-  help: encoder3.encode("Usage: timeout [OPTION] DURATION COMMAND [ARG]...\nRun a virtual-bash command with a cooperative time limit.\n"),
-  version: encoder3.encode("timeout (virtual-bash cooperative profile)\n")
+  missingDuration: encoder4.encode("timeout: missing duration\n"),
+  invalidDuration: encoder4.encode("timeout: invalid duration\n"),
+  durationOverflow: encoder4.encode("timeout: duration exceeds supported range\n"),
+  missingCommand: encoder4.encode("timeout: missing command\n"),
+  invalidOption: encoder4.encode("timeout: invalid option\n"),
+  preserveStatus: encoder4.encode("timeout: option --preserve-status is unsupported\n"),
+  signal: encoder4.encode("timeout: option --signal is unsupported\n"),
+  killAfter: encoder4.encode("timeout: option --kill-after is unsupported\n"),
+  foreground: encoder4.encode("timeout: option --foreground is unsupported\n"),
+  verbose: encoder4.encode("timeout: option --verbose is unsupported\n"),
+  invokeUnavailable: encoder4.encode("timeout: command invocation is unavailable\n"),
+  timerSetupFailed: encoder4.encode("timeout: timer setup failed\n"),
+  help: encoder4.encode("Usage: timeout [OPTION] DURATION COMMAND [ARG]...\nRun a virtual-bash command with a cooperative time limit.\n"),
+  version: encoder4.encode("timeout (virtual-bash cooperative profile)\n")
 });
 function optionsObject(value2) {
   if (value2 === void 0) return void 0;
@@ -36125,7 +37668,7 @@ var Work2 = class {
     return text3.slice(start, end);
   }
   async encodeInto(text3, target, start) {
-    const encoder4 = new TextEncoder();
+    const encoder5 = new TextEncoder();
     let offset = start;
     for (let index = 0; index < text3.length; ) {
       let end = Math.min(text3.length, index + 1024);
@@ -36135,7 +37678,7 @@ var Work2 = class {
       const chunk = text3.slice(index, end);
       const bytes3 = await this.utf8(chunk, target.length - offset);
       await this.charge(bytes3);
-      const encoded2 = encoder4.encodeInto(chunk, target.subarray(offset, offset + bytes3));
+      const encoded2 = encoder5.encodeInto(chunk, target.subarray(offset, offset + bytes3));
       if (encoded2.read !== chunk.length || encoded2.written !== bytes3) throw new Error("apply_patch encoding size mismatch");
       offset += bytes3;
       index = end;
@@ -36308,7 +37851,7 @@ async function targetPath(value2, work) {
   if (absolute2.split("/").length - 1 > work.limits.maxPathComponents) throw new PatchError("maxPathComponents limit exceeded");
   return absolute2;
 }
-async function parse17(text3, work) {
+async function parse18(text3, work) {
   await work.utf8(work.cwd, work.limits.maxPathBytes, 2);
   if (!work.cwd.startsWith("/") || work.cwd.includes("\0")) throw new PatchError("cwd must be an absolute virtual path", 2);
   const lines3 = await patchLines(text3, work);
@@ -36736,7 +38279,7 @@ var Invocation2 = class {
     let summary;
     try {
       try {
-        const files = await parse17(await this.input(), work);
+        const files = await parse18(await this.input(), work);
         const plans = await this.prepare(files);
         const lines3 = ["Success. Updated the following files:\n"];
         let bytes3 = lines3[0].length;
@@ -38044,7 +39587,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
     const quoteLine = this.lineAt(this.position);
     this.position += 2;
     const bytes3 = [];
-    const encoder4 = new TextEncoder();
+    const encoder5 = new TextEncoder();
     const escapes = { a: 7, b: 8, e: 27, E: 27, f: 12, n: 10, r: 13, t: 9, v: 11, "\\": 92, "'": 39, '"': 34, "?": 63 };
     while (this.position < this.source.length) {
       const character = String.fromCodePoint(this.source.codePointAt(this.position));
@@ -38063,7 +39606,7 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         }
       }
       if (character !== "\\") {
-        bytes3.push(...encoder4.encode(character));
+        bytes3.push(...encoder5.encode(character));
         continue;
       }
       const escape = this.source[this.position++];
@@ -38087,16 +39630,16 @@ shell: command substitution: line ${line}: \`${sourceLine}'
         const code = parseInt(digits, 16);
         if (escape === "x") bytes3.push(code);
         else if (this.byteLocale && code > 127) {
-          bytes3.push(...encoder4.encode(`\\${code <= 65535 ? "u" : "U"}${code.toString(16).toUpperCase().padStart(code <= 65535 ? 4 : 8, "0")}`));
+          bytes3.push(...encoder5.encode(`\\${code <= 65535 ? "u" : "U"}${code.toString(16).toUpperCase().padStart(code <= 65535 ? 4 : 8, "0")}`));
         } else {
           if (code > 1114111 || code >= 55296 && code <= 57343) this.error("Unsupported non-scalar ANSI-C Unicode escape");
-          bytes3.push(...encoder4.encode(String.fromCodePoint(code)));
+          bytes3.push(...encoder5.encode(String.fromCodePoint(code)));
         }
       } else if (escape === "c" && this.source[this.position] !== "'" && this.position < this.source.length) {
         const control = this.source[this.position++];
         if (control === "\\" && this.source[this.position] === "\\") this.position++;
         bytes3.push(control === "?" ? 127 : control.toUpperCase().charCodeAt(0) & 31);
-      } else bytes3.push(92, ...encoder4.encode(escape));
+      } else bytes3.push(92, ...encoder5.encode(escape));
     }
     this.error("Unterminated ANSI-C quote", { quote: "'", line: quoteLine });
   }
@@ -38374,7 +39917,7 @@ var Parser4 = class {
       this.advance();
       let nodes = 0;
       const grouped = /* @__PURE__ */ new WeakSet();
-      const admit2 = () => {
+      const admit3 = () => {
         if (nodes >= 4096) this.error("Conditional syntax exceeds 4096 nodes");
         nodes++;
       };
@@ -38385,7 +39928,7 @@ var Parser4 = class {
       const primary = (depth) => {
         if (depth > 64) this.error("Conditional syntax nesting exceeds 64");
         if (this.is("!")) {
-          admit2();
+          admit3();
           this.advance();
           const expression2 = primary(depth + 1);
           if (expression2.kind === "not" && !grouped.has(expression2)) return expression2.operand;
@@ -38399,7 +39942,7 @@ var Parser4 = class {
           grouped.add(expression2);
           return expression2;
         }
-        admit2();
+        admit3();
         this.budget.admit();
         const first = operand();
         if (conditionalBinary.has(this.current.value)) {
@@ -38415,7 +39958,7 @@ var Parser4 = class {
       const conjunction = (depth) => {
         let expression2 = primary(depth);
         while (this.is("&&")) {
-          admit2();
+          admit3();
           this.budget.admit();
           this.advance();
           expression2 = { kind: "and", left: expression2, right: primary(depth) };
@@ -38425,7 +39968,7 @@ var Parser4 = class {
       const disjunction = (depth) => {
         let expression2 = conjunction(depth);
         while (this.is("||")) {
-          admit2();
+          admit3();
           this.budget.admit();
           this.advance();
           expression2 = { kind: "or", left: expression2, right: conjunction(depth) };
@@ -39038,7 +40581,7 @@ async function* expandBraces(word, budget, signal) {
     signal.throwIfAborted();
     if (++work % 128 === 0) await yieldTurn(signal);
   };
-  const admit2 = (bytes3 = 64) => {
+  const admit3 = (bytes3 = 64) => {
     budget.parsing.admit();
     allocation.reserveBytes(bytes3);
   };
@@ -39051,15 +40594,15 @@ async function* expandBraces(word, budget, signal) {
     return left * right;
   };
   const partNode = (part) => {
-    admit2();
+    admit3();
     return { kind: "part", part, count: 1, bytes: part.kind === "text" ? shellValueByteLength(part.byteValue ?? part.value) : 0 };
   };
   const textNode = (value2) => {
-    admit2(value2.length * 2);
+    admit3(value2.length * 2);
     return partNode({ kind: "text", value: value2, quoted: false });
   };
   const product = async (children) => {
-    admit2();
+    admit3();
     let count2 = 1;
     let bytes3 = 0;
     for (const child of children) {
@@ -39073,24 +40616,24 @@ async function* expandBraces(word, budget, signal) {
     if (children.length !== 1 || children[0].kind !== "part") return void 0;
     const part = children[0].part;
     if (part.kind !== "text" || part.quoted || part.byteValue) return void 0;
-    admit2(32);
+    admit3(32);
     const pieces = [];
     let startOffset = 0;
     for (let offset = 0; offset < part.value.length; offset++) {
       if (offset % 1024 === 0) await checkpoint();
       if (part.value[offset] !== "." || part.value[offset + 1] !== ".") continue;
       if (pieces.length === 2) return void 0;
-      admit2(16 + (offset - startOffset) * 2);
+      admit3(16 + (offset - startOffset) * 2);
       pieces.push(part.value.slice(startOffset, offset));
       startOffset = offset + 2;
       offset++;
     }
     if (!pieces.length) return void 0;
-    admit2(16 + (part.value.length - startOffset) * 2);
+    admit3(16 + (part.value.length - startOffset) * 2);
     pieces.push(part.value.slice(startOffset));
     const first = pieces[0];
     const last = pieces[1];
-    admit2(256);
+    admit3(256);
     let start = await integer8(first, checkpoint);
     let end = await integer8(last, checkpoint);
     const numeric4 = start !== void 0 && end !== void 0;
@@ -39107,16 +40650,16 @@ async function* expandBraces(word, budget, signal) {
     const distance = end - start;
     const cardinality = (distance < 0n ? -distance : distance) / step + 1n;
     if (cardinality > BigInt(budget.limits.maxExpansionFields)) budget.fail("maxExpansionFields");
-    const padded = (value2) => value2.length > 1 && value2.startsWith("0") || value2.length > 2 && value2.startsWith("-0");
-    const width = numeric4 && (padded(first) || padded(last)) ? Math.max(first.length, last.length) : 0;
+    const padded2 = (value2) => value2.length > 1 && value2.startsWith("0") || value2.length > 2 && value2.startsWith("-0");
+    const width = numeric4 && (padded2(first) || padded2(last)) ? Math.max(first.length, last.length) : 0;
     const count2 = Number(cardinality);
     const termBytes = numeric4 ? Math.max(width, start.toString().length, end.toString().length) : 1;
     const bytes3 = multiply3(count2, termBytes, "maxExpansionBytes");
-    admit2();
+    admit3();
     return { kind: "range", start, step: distance < 0n ? -step : step, width, numeric: numeric4, count: count2, bytes: bytes3 };
   };
   try {
-    admit2();
+    admit3();
     const frames = [{ branches: [[]] }];
     const append = (node) => {
       frames.at(-1).branches.at(-1).push(node);
@@ -39136,20 +40679,20 @@ async function* expandBraces(word, budget, signal) {
         const character = part.value[offset];
         if (character !== "{" && character !== "}" && character !== ",") continue;
         if (start < offset) {
-          admit2((offset - start) * 2);
+          admit3((offset - start) * 2);
           append(textNode(part.value.slice(start, offset)));
         }
         start = offset + 1;
         if (character === "{") {
-          admit2();
+          admit3();
           frames.push({ branches: [[]] });
         } else if (character === "," && frames.length > 1) {
-          admit2();
+          admit3();
           frames.at(-1).branches.push([]);
         } else if (character === "}" && frames.length > 1) {
           const frame = frames.pop();
           if (frame.branches.length > 1) {
-            admit2(frame.branches.length * 8);
+            admit3(frame.branches.length * 8);
             const children = [];
             for (const branch of frame.branches) children.push(await product(branch));
             let count2 = 0;
@@ -39178,7 +40721,7 @@ async function* expandBraces(word, budget, signal) {
       if (start < part.value.length) {
         if (start === 0) append(partNode(part));
         else {
-          admit2((part.value.length - start) * 2);
+          admit3((part.value.length - start) * 2);
           append(textNode(part.value.slice(start)));
         }
       }
@@ -41569,7 +43112,7 @@ var Restoration = class {
     this.holding?.release();
   }
 };
-async function snapshotState(state, clone, signal, prepare, scope) {
+async function snapshotState(state, clone, signal, prepare2, scope) {
   const monitor = stateMonitor(state);
   if (!monitor) return clone();
   const session = scope ? { ...monitor.session, scope, owner: void 0, guestOwner: void 0, monitors: /* @__PURE__ */ new Set() } : monitor.session;
@@ -41659,8 +43202,8 @@ async function snapshotState(state, clone, signal, prepare, scope) {
       await owner.ledger.checkpoint(signal, 5);
     }
     check();
-    if (prepare) {
-      await prepare(result2.proxy, owner);
+    if (prepare2) {
+      await prepare2(result2.proxy, owner);
       check();
     }
     return result2.proxy;
@@ -42139,6 +43682,9 @@ var Budget25 = class {
   }
   fileSystemOperation() {
     this.cpuCheckpoint();
+    this.fileSystemCleanupOperation();
+  }
+  fileSystemCleanupOperation() {
     if (this.#fileSystemOperations >= this.limits.maxFileSystemOperations) this.fail("maxFileSystemOperations");
     this.#fileSystemOperations++;
   }
@@ -42250,7 +43796,7 @@ var typedSavedVariables = /* @__PURE__ */ new WeakMap();
 var valueScope = /* @__PURE__ */ Symbol("shell value allocation scope");
 var invokedValues = /* @__PURE__ */ new WeakMap();
 function isolateIO(io) {
-  return { ...io, nameExpansionContext: void 0, ...io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number5, descriptor2]) => [number5, { ...descriptor2 }])) } : {} };
+  return { ...io, nameExpansionContext: void 0, ...io.descriptors ? { descriptors: new Map([...io.descriptors].map(([number6, descriptor2]) => [number6, { ...descriptor2 }])) } : {} };
 }
 function activeIO(io) {
   const input3 = io.descriptors?.get(0);
@@ -43008,7 +44554,7 @@ var Runtime = class _Runtime {
     this.cancellationMaxDepth = cancellationMaxDepth;
     this.outcomeFrame = outcomeFrame;
     this.inputProfile = inputProfile;
-    this.fs = scopeFileSystem(fs, () => budget.fileSystemOperation(), signal);
+    this.fs = scopeFileSystem(fs, () => budget.fileSystemOperation(), signal, () => budget.fileSystemCleanupOperation());
     const checkpoint = () => budget.cpuCheckpoint();
     registerYieldCheckpoint(signal, checkpoint);
     registerYieldCheckpoint(commandSignal, checkpoint);
@@ -43568,9 +45114,9 @@ var Runtime = class _Runtime {
   async arrayIndex(binding, index, state, io, owner, create = false) {
     if (!binding?.associative) {
       const selected = index.source === void 0 ? index : literalIndex(index.source, 0, this.budget.parsing);
-      const number5 = numericIndex(selected);
-      if (number5 === void 0) throw new ArrayFailure("index outside 0..2147483647");
-      return number5;
+      const number6 = numericIndex(selected);
+      if (number6 === void 0) throw new ArrayFailure("index outside 0..2147483647");
+      return number6;
     }
     const word = index.word ?? parseArraySubscript(index.source ?? index.decimal, this.budget.parsing, byteLocale(state.variables), state.depth);
     const fields3 = await this.valueWord(word, state, io, false);
@@ -45319,7 +46865,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     this.reconcileGetopts(child, state.variables.OPTIND);
     return child;
   }
-  async shebangStage(incoming, state, io, terminal, prepare, replacementInput, existingScope) {
+  async shebangStage(incoming, state, io, terminal, prepare2, replacementInput, existingScope) {
     const scope = existingScope ?? io[invocationScope].child();
     const ownsScope = existingScope === void 0;
     const runtime = new _Runtime(
@@ -45380,7 +46926,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       if (argumentValues.values.every((value2) => typeof value2 === "string")) Reflect.deleteProperty(context2, "argumentValues");
       const child = await runtime.shebangState(context2, state);
       const childIO = { ...io, ...context2, [invocationScope]: scope };
-      invocationOverride.current = prepare?.(runtime, context2, child, childIO);
+      invocationOverride.current = prepare2?.(runtime, context2, child, childIO);
       const runtimeFrame = {};
       const middleware = this.middleware.map((handler) => (context3, next) => {
         scope.assertOpen();
@@ -45876,7 +47422,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   async letBuiltin(context2, state) {
     this.signal.throwIfAborted();
     const { maxExpansionBytes: bytes3, maxExpansionFields: fields3 } = this.budget.limits;
-    const admit2 = (value3) => {
+    const admit3 = (value3) => {
       if (typeof value3 !== "string" || value3.includes("\0")) throw new CommandFailure2("let: arguments must be strings without NUL", 2);
       if (value3.length > bytes3 || import_buffer.Buffer.byteLength(value3) > bytes3) this.budget.fail("maxExpansionBytes");
     };
@@ -45888,10 +47434,10 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     const { args } = context2;
     if (!Array.isArray(args)) throw new CommandFailure2("let: argument array required", 2);
     if (args.length + 1 > fields3) this.budget.fail("maxExpansionFields");
-    admit2(context2.command);
+    admit3(context2.command);
     for (let index = 0; index < args.length; index++) {
       this.signal.throwIfAborted();
-      admit2(args[index]);
+      admit3(args[index]);
       if ((index + 1) % 128 === 0) await checkpoint();
     }
     if (args[0] === "--help") throw new CommandFailure2("let: --help: unsupported option", 2);
@@ -45920,7 +47466,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
   async getoptsBuiltin(context2, state) {
     this.signal.throwIfAborted();
     const { maxExpansionBytes: bytes3, maxExpansionFields: fields3 } = this.budget.limits;
-    const admit2 = (value2) => {
+    const admit3 = (value2) => {
       if (typeof value2 !== "string") throw new CommandFailure2("getopts: arguments must be strings without NUL", 2);
       if (value2.length > bytes3 || import_buffer.Buffer.byteLength(value2) > bytes3) this.budget.fail("maxExpansionBytes");
       if (value2.includes("\0")) throw new CommandFailure2("getopts: arguments must be strings without NUL", 2);
@@ -45932,10 +47478,10 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     };
     if (!Array.isArray(context2.args)) throw new CommandFailure2("getopts: argument array required", 2);
     if (context2.args.length + 1 > fields3) this.budget.fail("maxExpansionFields");
-    admit2(context2.command);
+    admit3(context2.command);
     for (let index = 0; index < context2.args.length; index++) {
       this.signal.throwIfAborted();
-      admit2(context2.args[index]);
+      admit3(context2.args[index]);
       if ((index + 1) % 128 === 0) await checkpoint();
     }
     const offset = context2.args[0] === "--" ? 1 : 0;
@@ -45974,7 +47520,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       const args = input3?.args ?? supplied;
       if (!input3 || allocation) for (let index = 0; index < args.length; index++) {
         this.signal.throwIfAborted();
-        admit2(args[index]);
+        admit3(args[index]);
         if ((index + 1) % 128 === 0) await checkpoint();
       }
       state.getopts ??= cloneGetoptsBinding(state);
@@ -46125,8 +47671,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
           continue;
         }
         if ((token.startsWith("+") || token.startsWith("-")) && !(command7 === "pushd" && token === "-")) {
-          const number5 = await work.number(token);
-          selected = token.startsWith("+") ? number5 : BigInt(count2) - number5;
+          const number6 = await work.number(token);
+          selected = token.startsWith("+") ? number6 : BigInt(count2) - number6;
           if (command7 === "pushd") boundedIndex(selected);
           continue;
         }
@@ -46306,8 +47852,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       }
     }
     const arguments_ = incoming.slice(offset);
-    const format2 = arguments_.args[0] === "--" ? arguments_.args[1] : arguments_.args[0];
-    if (format2 === void 0 || arguments_.args[0] !== "--" && format2.startsWith("-")) {
+    const format3 = arguments_.args[0] === "--" ? arguments_.args[1] : arguments_.args[0];
+    if (format3 === void 0 || arguments_.args[0] !== "--" && format3.startsWith("-")) {
       await writeDiagnostic(context2.stderr, "printf: usage: printf [-v var] format [arguments]\n");
       return 2;
     }
@@ -48783,17 +50329,17 @@ var Shell = class {
       if (!middleware || typeof middleware.setup !== "function") throw new TypeError("Expected middleware or shell plugin");
       this.#ready = this.#ready.then(async () => {
         let active = true;
-        const admit2 = () => {
+        const admit3 = () => {
           if (this.#disposed && !active) throw new Error("Shell is disposed");
         };
         const host2 = {
           commands: this.commands,
           use: (middleware2) => {
-            admit2();
+            admit3();
             this.#install(middleware2);
           },
           registerFileSystem: (scheme, factory) => {
-            admit2();
+            admit3();
             this.#registerFileSystem(scheme, factory);
           }
         };
@@ -49148,7 +50694,7 @@ init_platform();
 // packages/safe-js/dist/browser/safe-fs.js
 init_platform();
 
-// packages/safe-js/dist/browser/chunks/chunk-GQOAEEHU.js
+// packages/safe-js/dist/browser/chunks/chunk-3EJ7BQOJ.js
 init_platform();
 var platform = Object.freeze({
   errno(_code) {
@@ -51676,17 +53222,17 @@ var WebDavFileSystem = class {
     }
     const sizeText = directory2 ? "0" : scalar2(required("getcontentlength"));
     if (!/^\d+$/.test(sizeText) || !Number.isSafeInteger(Number(sizeText))) throw new Error("invalid content length property");
-    const date = (name2) => {
+    const date2 = (name2) => {
       const property = properties.get(name2);
       if (!property) return void 0;
       const value2 = Date.parse(scalar2(property));
       if (!Number.isFinite(value2)) throw new Error("invalid date property");
       return value2;
     };
-    const birthtimeMs = date("creationdate");
+    const birthtimeMs = date2("creationdate");
     const etag = properties.get("getetag");
     const validator = etag && scalar2(etag);
-    let mtimeMs = date("getlastmodified") ?? 0;
+    let mtimeMs = date2("getlastmodified") ?? 0;
     let atimeMs = 0;
     if (timestampProperty) {
       const timestamps = JSON.parse(scalar2(timestampProperty));
@@ -52992,12 +54538,14 @@ export {
   createTimeoutCommands,
   createTreeCommand,
   createTreeCommands,
+  createUnzipCommand,
   createWgetCommand,
   createWhichCommand,
   createWhichCommands,
   createXmlCommands,
   createYqCommand,
   createYqCommands,
+  createZipCommand,
   curlCommands,
   defaultJqLimits,
   defaultMemoryFileSystemLimits2 as defaultMemoryFileSystemLimits,