@poe-platform/safe-bash 0.1.520 → 0.1.522

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

@@ -4411,7 +4411,7 @@ function streamCommands(maxTeeTargets = 64, maxTailFollowHandles = 64) {
             else utf82.write(chunk);
           }
           if (!singleByte) utf82.finish();
-          for (const field of Object.keys(totals)) totals[field] += counts[field];
+          for (const field2 of Object.keys(totals)) totals[field2] += counts[field2];
           await print(counts, parsed.operands.length ? name2 : void 0);
         } catch (error) {
           await diagnostic(context2, error);
@@ -4995,7 +4995,7 @@ function textCommands() {
       const delimiter = parsed.flags.has("z") ? 0 : 10;
       const key = (bytes3) => {
         let offset = 0;
-        for (let field = 0; field < skipFields; field++) {
+        for (let field2 = 0; field2 < skipFields; field2++) {
           while (offset < bytes3.length && (bytes3[offset] === 32 || bytes3[offset] === 9)) offset++;
           while (offset < bytes3.length && bytes3[offset] !== 32 && bytes3[offset] !== 9) offset++;
         }
@@ -5059,13 +5059,13 @@ function textCommands() {
                 if (parsed.flags.has("s")) continue;
                 await writer.write(line.bytes);
               } else {
-                let field = 1;
+                let field2 = 1;
                 let start = 0;
                 let emitted = false;
                 while (true) {
                   const checkpoint = work.charge();
                   if (checkpoint) await checkpoint;
-                  if (selected(field++)) {
+                  if (selected(field2++)) {
                     if (emitted) await writer.text(outputDelimiter ?? delimiter);
                     await writer.write(record4.subarray(start, boundary < 0 ? record4.length : boundary));
                     emitted = true;
@@ -5375,8 +5375,8 @@ async function splitString(source2, environment, work) {
         else finish();
         continue;
       }
-      const controls = { f: "\f", n: "\n", r: "\r", t: "	", v: "\v" };
-      if (Object.hasOwn(controls, escaped3)) append(controls[escaped3]);
+      const controls2 = { f: "\f", n: "\n", r: "\r", t: "	", v: "\v" };
+      if (Object.hasOwn(controls2, escaped3)) append(controls2[escaped3]);
       else if (`"#$'\\`.includes(escaped3)) append(escaped3);
       else throw new EnvSplitError(`invalid sequence '\\${escaped3}' in -S`);
       continue;
@@ -5459,8 +5459,8 @@ async function splitBytes(source2, environment, work) {
         else finish();
         continue;
       }
-      const controls = { 102: 12, 110: 10, 114: 13, 116: 9, 118: 11 };
-      if (Object.hasOwn(controls, escaped3)) append(Uint8Array.of(controls[escaped3]));
+      const controls2 = { 102: 12, 110: 10, 114: 13, 116: 9, 118: 11 };
+      if (Object.hasOwn(controls2, escaped3)) append(Uint8Array.of(controls2[escaped3]));
       else if ([34, 35, 36, 39, 92].includes(escaped3)) append(Uint8Array.of(escaped3));
       else throw new EnvSplitError(`invalid sequence '\\${String.fromCharCode(escaped3)}' in -S`);
       continue;
@@ -6111,6 +6111,144 @@ async function matchTokens(patternTokens, value2, work, start, end) {
   return tokenIndex === patternTokens.length;
 }
 
+// packages/safe-bash/src/commands/find-format.ts
+init_platform();
+var controls = { 97: 7, 98: 8, 102: 12, 110: 10, 114: 13, 116: 9, 118: 11, 92: 92 };
+var FindFormatBudget = class {
+  constructor(context2) {
+    this.context = context2;
+  }
+  context;
+  arguments = 0;
+  steps = 0;
+  bytes = 0;
+  untilYield = 4096;
+  exhausted = false;
+  fail(label) {
+    this.exhausted = true;
+    throw new FsError("EFBIG", { message: `find printf ${label} limit exceeded` });
+  }
+  admitFormat(length) {
+    this.arguments += length;
+    if (this.arguments > 65536) throw new UsageError("printf format byte limit exceeded (65536)");
+  }
+  async step(count2 = 1) {
+    this.context.signal.throwIfAborted();
+    this.steps += count2;
+    if (this.steps > 32 * 1024 * 1024) this.fail("work");
+    this.untilYield -= count2;
+    if (this.untilYield <= 0) {
+      this.untilYield = 4096;
+      await yieldTurn(this.context.signal);
+    }
+  }
+  async write(bytes3) {
+    this.admitOutput(bytes3.length);
+    this.bytes += bytes3.length;
+    for (let offset = 0; offset < bytes3.length; offset += 4096) {
+      const chunk = bytes3.subarray(offset, offset + 4096);
+      await this.step(chunk.length);
+      await output(this.context, chunk);
+    }
+  }
+  admitOutput(length) {
+    if (length > 8 * 1024 * 1024 - this.bytes) this.fail("output");
+  }
+  async text(text3) {
+    this.admitOutput(text3.length);
+    for (let offset = 0; offset < text3.length; ) {
+      let end = Math.min(text3.length, offset + 1024);
+      if (end < text3.length && text3.charCodeAt(end - 1) >= 55296 && text3.charCodeAt(end - 1) <= 56319) end--;
+      const part = text3.slice(offset, end);
+      const length = import_buffer.Buffer.byteLength(part);
+      this.admitOutput(length);
+      await this.write(import_buffer.Buffer.from(part));
+      offset = end;
+    }
+  }
+};
+async function field(entry, code, budget) {
+  if (code === "p") return entry.display;
+  if (code === "P") return entry.relative;
+  if (code === "H") return entry.root;
+  if (code === "s") return String(entry.stat.size);
+  if (code === "d") return String(entry.depth);
+  if (code === "y") return { file: "f", directory: "d", symlink: "l", character: "c" }[entry.stat.type];
+  let end = entry.display.length;
+  while (end > 1 && entry.display[end - 1] === "/") {
+    await budget.step();
+    end--;
+  }
+  let slash = end - 1;
+  while (slash >= 0 && entry.display[slash] !== "/") {
+    await budget.step();
+    slash--;
+  }
+  const start = code === "f" ? slash + 1 : 0;
+  const finish = code === "f" ? end : slash;
+  if (code === "f" && end === 1 && entry.display[0] === "/") return "/";
+  if (code === "h" && slash < 0) return ".";
+  budget.admitOutput(finish - start);
+  for (let offset = start; offset < finish; offset += 4096) await budget.step(Math.min(4096, finish - offset));
+  return entry.display.slice(start, finish);
+}
+async function compileFindFormat(value2, budget) {
+  if (typeof value2 === "string" && value2.length > 65536) budget.admitFormat(value2.length);
+  budget.admitFormat(shellValueByteLength(value2));
+  const source2 = shellValueBytes(value2);
+  const parts = [];
+  let literal = 0;
+  let index = 0;
+  const flush = () => {
+    if (index > literal) parts.push({ start: literal, end: index });
+  };
+  while (index < source2.length) {
+    await budget.step();
+    const byte = source2[index];
+    if (byte !== 37 && byte !== 92) {
+      index++;
+      continue;
+    }
+    flush();
+    const next = source2[++index];
+    if (byte === 37) {
+      if (next === 37) parts.push({ byte: 37 });
+      else if (next !== void 0 && "pfhsdPHy".includes(String.fromCharCode(next))) parts.push({ directive: String.fromCharCode(next) });
+      else throw new UsageError("unsupported printf format directive or modifier");
+      index++;
+    } else {
+      if (next === 99) {
+        literal = source2.length;
+        break;
+      }
+      if (next !== void 0 && Object.hasOwn(controls, next)) {
+        parts.push({ byte: controls[next] });
+        index++;
+      } else if (next !== void 0 && next >= 48 && next <= 55) {
+        let value3 = 0;
+        const end = Math.min(source2.length, index + 3);
+        while (index < end && source2[index] >= 48 && source2[index] <= 55) {
+          await budget.step();
+          value3 = value3 * 8 + source2[index++] - 48;
+        }
+        parts.push({ byte: value3 & 255 });
+      } else throw new UsageError("unsupported printf format escape");
+    }
+    literal = index;
+  }
+  if (literal < source2.length && index > literal) parts.push({ start: literal, end: index });
+  return async (entry) => {
+    for (const part of parts) {
+      await budget.step();
+      if ("directive" in part) await budget.text(await field(entry, part.directive, budget));
+      else if ("byte" in part) {
+        budget.admitOutput(1);
+        await budget.write(Uint8Array.of(part.byte));
+      } else await budget.write(source2.subarray(part.start, part.end));
+    }
+  };
+}
+
 // packages/safe-bash/src/commands/find.ts
 function findCommands(execute5, maxDirectoryEntries) {
   const readDirectory = createDirectoryReader(maxDirectoryEntries);
@@ -6151,7 +6289,7 @@ function findCommands(execute5, maxDirectoryEntries) {
         explicitDepth = true;
         args.splice(index, 1);
         values.splice(index, 1);
-      } else if (["-name", "-iname", "-path", "-ipath", "-type", "-size", "-mtime", "-mmin", "-newer"].includes(args[index])) index += 2;
+      } else if (["-name", "-iname", "-path", "-ipath", "-type", "-size", "-mtime", "-mmin", "-newer", "-printf"].includes(args[index])) index += 2;
       else index++;
     }
     let offset = 0;
@@ -6161,6 +6299,8 @@ function findCommands(execute5, maxDirectoryEntries) {
     let prunes = false;
     const references = /* @__PURE__ */ new Map();
     const flushes = [];
+    const formats2 = [];
+    const formatBudget = new FindFormatBudget(context2);
     const primary = () => {
       const token = args[offset++];
       if (token === void 0) throw new UsageError("missing expression");
@@ -6267,6 +6407,19 @@ function findCommands(execute5, maxDirectoryEntries) {
           return true;
         };
       }
+      if (token === "-printf") {
+        if (args[offset] === void 0) throw new UsageError("-printf requires a format");
+        const operand = values[offset++];
+        let render2;
+        formats2.push(async () => {
+          render2 = await compileFindFormat(operand, formatBudget);
+        });
+        explicitAction = true;
+        return async (entry) => {
+          await render2(entry);
+          return true;
+        };
+      }
       if (token === "-exec") {
         explicitAction = true;
         const command7 = [];
@@ -6324,6 +6477,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();
     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();
@@ -6339,7 +6493,7 @@ function findCommands(execute5, maxDirectoryEntries) {
       context2.signal.throwIfAborted();
       references.set(reference, stat.mtimeMs);
     }
-    const visit = async (display2, depth, ancestors) => {
+    const visit = async (display2, depth, ancestors, root, relative) => {
       context2.signal.throwIfAborted();
       const path = pathOf(context2, display2);
       try {
@@ -6353,7 +6507,7 @@ function findCommands(execute5, maxDirectoryEntries) {
             if (codeOf(error) !== "ENOENT") throw error;
           }
         }
-        const entry = { path, display: display2, stat, symlink, depth, prune: false };
+        const entry = { path, display: display2, stat, symlink, depth, root, relative, prune: false };
         const apply = async () => {
           if (depth >= minDepth && await evaluate(entry) && !explicitAction) await output(context2, `${escapeText(display2, "display")}
 `);
@@ -6364,15 +6518,16 @@ function findCommands(execute5, maxDirectoryEntries) {
           if (ancestors.has(physical)) throw new FsError("ELOOP", { path });
           const next = new Set(ancestors).add(physical);
           const children = await readDirectory(context2, path, true);
-          for (const child of children) await visit(`${display2.replace(/\/$/u, "")}/${child.name}`, depth + 1, next);
+          for (const child of children) await visit(`${display2.replace(/\/$/u, "")}/${child.name}`, depth + 1, next, root, relative ? `${relative}/${child.name}` : child.name);
         }
         if (depthFirst) await apply();
       } catch (error) {
+        if (formatBudget.exhausted) throw error;
         await diagnostic(context2, error);
         exitCode = 1;
       }
     };
-    for (const root of roots) await visit(root, 0, /* @__PURE__ */ new Set());
+    for (const root of roots) await visit(root, 0, /* @__PURE__ */ new Set(), root, "");
     for (const flush of flushes) await flush();
     return { exitCode };
   })];
@@ -10189,7 +10344,7 @@ function unicodeLocale2(context2) {
   return locale.endsWith("utf-8") || locale.endsWith("utf8");
 }
 function quote2(text3, filename = false, unicode = false) {
-  const controls = { "\x07": "\\a", "\b": "\\b", "	": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
+  const controls2 = { "\x07": "\\a", "\b": "\\b", "	": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
   const decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
   const units = [];
   for (let offset = 0; offset < text3.length; ) {
@@ -10244,7 +10399,7 @@ function quote2(text3, filename = false, unicode = false) {
     } else if (!unit2.printable) {
       if (filename && !escaping) result2 += "'$'";
       escaping = true;
-      result2 += controls[unit2.text] ?? Array.from(unit2.text, (character) => `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}`).join("");
+      result2 += controls2[unit2.text] ?? Array.from(unit2.text, (character) => `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}`).join("");
     } else {
       if (filename && escaping) result2 += "''";
       escaping = false;
@@ -12790,9 +12945,9 @@ var Converter = class {
     const nul = line.indexOf("\0");
     if (nul >= 0) line = line.slice(0, nul);
     let start = 0;
-    let field = 0n;
+    let field2 = 0n;
     while (true) {
-      field++;
+      field2++;
       let end = start;
       if (settings17.delimiter !== void 0) {
         while (end < line.length && line[end] !== settings17.delimiter) end++;
@@ -12803,7 +12958,7 @@ var Converter = class {
       backing[end] = 0;
       let text3 = line.slice(start, end);
       await this.tick((settings17.fields?.length ?? 0) + 1);
-      if (settings17.fields ? settings17.fields.some(([low, high]) => low <= field && field <= high) : field === 1n) {
+      if (settings17.fields ? settings17.fields.some(([low, high]) => low <= field2 && field2 <= high) : field2 === 1n) {
         if (settings17.suffix && text3.length > settings17.suffix.length) {
           if (text3.endsWith(settings17.suffix)) {
             text3 = text3.slice(0, -settings17.suffix.length);
@@ -12815,7 +12970,7 @@ var Converter = class {
         let skipped = 0;
         while (blank(text3[skipped])) skipped++;
         if (this.autoPadding) {
-          settings17.padding = skipped > 0 || field > 1n ? BigInt(text3.length) : 0n;
+          settings17.padding = skipped > 0 || field2 > 1n ? BigInt(text3.length) : 0n;
           if (settings17.developer) await this.output.emit(`setting Auto-Padding to ${settings17.padding} characters
 `, true);
         }
@@ -14514,7 +14669,7 @@ function compare3(left, right, format2, budget) {
 // packages/safe-bash/src/commands/text-programs/awk-syntax.ts
 function decodeString(source2) {
   let result2 = "";
-  const controls = { n: "\n", t: "	", r: "\r", b: "\b", f: "\f", v: "\v", a: "\x07", "\\": "\\", '"': '"' };
+  const controls2 = { n: "\n", t: "	", r: "\r", b: "\b", f: "\f", v: "\v", a: "\x07", "\\": "\\", '"': '"' };
   for (let offset = 0; offset < source2.length; offset++) {
     const character = source2[offset];
     if (character !== "\\") {
@@ -14528,7 +14683,7 @@ function decodeString(source2) {
       const following = /^[0-7]{0,2}/u.exec(source2.slice(offset + 1))[0];
       result2 += String.fromCharCode(parseInt(next + following, 8) & 255);
       offset += following.length;
-    } else result2 += controls[next] ?? next;
+    } else result2 += controls2[next] ?? next;
   }
   return result2;
 }
@@ -15419,13 +15574,13 @@ var AwkRuntime = class {
   }
   replaceRecord(record4, fields3) {
     let fieldBytes = 0;
-    for (const field of fields3) {
-      if (field.kind === "string" || field.kind === "numeric") this.budget.check(field.text);
-      fieldBytes += textSize(field);
+    for (const field2 of fields3) {
+      if (field2.kind === "string" || field2.kind === "numeric") this.budget.check(field2.text);
+      fieldBytes += textSize(field2);
     }
     const owned = this.retention.replace(this.record.length + this.fieldBytes, record4.length + fieldBytes, () => ({
       record: import_buffer.Buffer.from(record4, "latin1").toString("latin1"),
-      fields: fields3.map((field, index) => field === this.fields[index] ? field : ownScalar(field))
+      fields: fields3.map((field2, index) => field2 === this.fields[index] ? field2 : ownScalar(field2))
     }));
     this.record = owned.record;
     this.fields = owned.fields;
@@ -17463,7 +17618,7 @@ function createRgCommand(executor, options3 = {}) {
             try {
               const result2 = await searchFile(context2, args, limits, matcher, printer, target, context2.stdin, args.filename ?? (target.recursive || selection.paths.length > 1));
               found ||= result2.found;
-              for (const field of ["searches", "searches_with_match", "bytes_searched", "bytes_printed", "matched_lines", "matches"]) totals[field] += result2.stats[field];
+              for (const field2 of ["searches", "searches_with_match", "bytes_searched", "bytes_printed", "matched_lines", "matches"]) totals[field2] += result2.stats[field2];
               if (args.quiet && found && args.mode !== "json") break;
             } catch (error) {
               if (error instanceof SearchError || error instanceof RegexExecutionError) throw error;
@@ -17980,9 +18135,9 @@ async function reverseNormal(context2, files, columns, maxInputBytes) {
     if (!match) throw new PublicDiagnostic("invalid input: expected hexadecimal address and colon");
     const address = Number.parseInt(match[1], 16);
     if (!Number.isSafeInteger(address) || address !== offset) throw new PublicDiagnostic("invalid input: reverse requires contiguous addresses starting at zero");
-    const field = match[2].split(/ {2,}|\t/u, 1)[0];
-    if (!/^(?:[0-9a-fA-F]{2})+(?: (?:[0-9a-fA-F]{2})+)*$/u.test(field)) throw new PublicDiagnostic("invalid input: malformed hexadecimal data field");
-    const digits = field.replaceAll(" ", "");
+    const field2 = match[2].split(/ {2,}|\t/u, 1)[0];
+    if (!/^(?:[0-9a-fA-F]{2})+(?: (?:[0-9a-fA-F]{2})+)*$/u.test(field2)) throw new PublicDiagnostic("invalid input: malformed hexadecimal data field");
+    const digits = field2.replaceAll(" ", "");
     if (digits.length > columns * 2) throw new PublicDiagnostic("invalid input: data exceeds configured columns");
     const bytes3 = new Uint8Array(digits.length / 2);
     for (let index = 0; index < bytes3.length; index++) bytes3[index] = Number.parseInt(digits.slice(index * 2, index * 2 + 2), 16);
@@ -24961,9 +25116,9 @@ function quoted(text3, style2) {
   }
   return `'${text3.replace(/'/gu, "'\\''")}'`;
 }
-function available(value2, field) {
-  if (value2 === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: `filesystem does not expose ${field}` });
-  if (!Number.isFinite(value2)) throw new FsError("EIO", { syscall: "stat", message: `invalid ${field}` });
+function available(value2, field2) {
+  if (value2 === void 0) throw new FsError("ENOTSUP", { syscall: "stat", message: `filesystem does not expose ${field2}` });
+  if (!Number.isFinite(value2)) throw new FsError("EIO", { syscall: "stat", message: `invalid ${field2}` });
   return value2;
 }
 function timestamp2(milliseconds) {
@@ -26577,7 +26732,7 @@ function unicodeLocale3(context2) {
   return locale.endsWith("utf-8") || locale.endsWith("utf8");
 }
 function quote4(text3, filename = false, unicode = false) {
-  const controls = { "\x07": "\\a", "\b": "\\b", "	": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
+  const controls2 = { "\x07": "\\a", "\b": "\\b", "	": "\\t", "\n": "\\n", "\v": "\\v", "\f": "\\f", "\r": "\\r" };
   const decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
   const units = [];
   for (let offset = 0; offset < text3.length; ) {
@@ -26631,7 +26786,7 @@ function quote4(text3, filename = false, unicode = false) {
     } else if (!unit2.printable) {
       if (filename && !escaping) result2 += "'$'";
       escaping = true;
-      result2 += controls[unit2.text] ?? Array.from(unit2.text, (character) => `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}`).join("");
+      result2 += controls2[unit2.text] ?? Array.from(unit2.text, (character) => `\\${character.charCodeAt(0).toString(8).padStart(3, "0")}`).join("");
     } else {
       if (filename && escaping) result2 += "''";
       escaping = false;
@@ -28653,9 +28808,9 @@ function parse12(context2, budget) {
   let delimiterChoice;
   const apply = (flag, value2) => {
     if (flag === "1" || flag === "2" || flag === "j") {
-      const field = number3(value2, "field") - 1;
-      if (flag !== "2") options3.fields[0] = field;
-      if (flag !== "1") options3.fields[1] = field;
+      const field2 = number3(value2, "field") - 1;
+      if (flag !== "2") options3.fields[0] = field2;
+      if (flag !== "1") options3.fields[1] = field2;
     } else if (flag === "a" || flag === "v") {
       if (value2 !== "1" && value2 !== "2") fail3(`invalid file number: ${value2}`);
       options3.unpaired.add(Number(value2) - 1);
@@ -28791,9 +28946,9 @@ function createJoinCommand(factory = {}) {
         const pair = [left, right], fields3 = [];
         const key = (left ?? right)?.key ?? empty;
         if (Array.isArray(options3.format)) {
-          for (const field of options3.format) {
+          for (const field2 of options3.format) {
             await budget.step();
-            fields3.push(field.file === 0 ? key : pair[field.file - 1]?.fields[field.index] ?? empty);
+            fields3.push(field2.file === 0 ? key : pair[field2.file - 1]?.fields[field2.index] ?? empty);
           }
         } else {
           fields3.push(key);
@@ -31784,13 +31939,13 @@ function serialized(value2, budget) {
     }
   };
   let first = true;
-  for (const [key, field] of Object.entries(value2)) {
+  for (const [key, field2] of Object.entries(value2)) {
     if (!first) add3(1);
     first = false;
     string2(key);
     add3(1);
-    if (typeof field === "string") string2(field);
-    else if (typeof field === "number") add3(String(field).length);
+    if (typeof field2 === "string") string2(field2);
+    else if (typeof field2 === "number") add3(String(field2).length);
     else throw new TypeError("tree JSON fields must be strings or numbers");
   }
   return JSON.stringify(value2).replace(
@@ -39551,8 +39706,8 @@ var ownedInputs = /* @__PURE__ */ new WeakMap();
 function getoptsInputAllocationSize(argumentsCount) {
   return { bytes: 256 + argumentsCount * 8, slots: argumentsCount + 2 };
 }
-async function createGetoptsInput(args, allocation, controls) {
-  const work = new ScanWork(controls);
+async function createGetoptsInput(args, allocation, controls2) {
+  const work = new ScanWork(controls2);
   if (!Array.isArray(args)) throw new GetoptsError("INVALID_INPUT", "Getopts requires an argument array");
   const length = args.length;
   if (length > work.maxArguments) throw new GetoptsError("ARGUMENT_LIMIT", "Getopts argument limit exceeded");
@@ -40071,11 +40226,11 @@ function stagedFailure(state, reason) {
   throwAdmissionFailure(state);
   throw reason;
 }
-function prepareControls(parent, controls) {
-  if (controls === void 0) return Object.freeze([]);
-  if (!Array.isArray(controls)) return stagedFailure(parent, new TypeError("Cancellation controls must be an array"));
+function prepareControls(parent, controls2) {
+  if (controls2 === void 0) return Object.freeze([]);
+  if (!Array.isArray(controls2)) return stagedFailure(parent, new TypeError("Cancellation controls must be an array"));
   const prepared = [];
-  for (const input3 of controls) {
+  for (const input3 of controls2) {
     let role;
     let signal;
     try {
@@ -40093,13 +40248,13 @@ function prepareControls(parent, controls) {
   throwAdmissionFailure(parent);
   return Object.freeze(prepared);
 }
-function makePrepared(parent, localSignal, controls, admission) {
+function makePrepared(parent, localSignal, controls2, admission) {
   const state = {
     parent,
     localSignal,
-    controls,
+    controls: controls2,
     admission,
-    owned: localSignal !== void 0 || controls.length > 0,
+    owned: localSignal !== void 0 || controls2.length > 0,
     replayError: new Error("Prepared cancellation admission was already activated"),
     activated: false
   };
@@ -40119,7 +40274,7 @@ function throwLocalActivationFailure(state) {
   const failure = localActivationFailure(state);
   if (failure.failed) throw failure.reason;
 }
-function prepareChildCancellation(parent, options3, snapshot, controls) {
+function prepareChildCancellation(parent, options3, snapshot, controls2) {
   const parentState = requireLink(parent);
   throwAdmissionFailure(parentState);
   let localSignal;
@@ -40141,7 +40296,7 @@ function prepareChildCancellation(parent, options3, snapshot, controls) {
     throwAdmissionFailure(parentState);
     if (localSignal !== void 0 && signalAborted(localSignal)) throw localSignal.reason;
   }
-  const preparedControls = prepareControls(parentState, controls);
+  const preparedControls = prepareControls(parentState, controls2);
   if (localSignal === void 0 && preparedControls.length === 0) {
     return makePrepared(parentState, void 0, preparedControls, void 0);
   }
@@ -40214,16 +40369,16 @@ function createRootCancellationLink(input3) {
   const admission = validateSnapshot(input3.admission);
   if (admission.depth !== 0) throw new RangeError("Root cancellation depth must be zero");
   if (input3.callerSignal !== void 0 && !nativeSignal(input3.callerSignal)) throw new TypeError("Root caller signal must be an AbortSignal");
-  const controls = input3.controls ?? [];
-  if (!Array.isArray(controls)) throw new TypeError("Cancellation controls must be an array");
-  for (const control of controls) {
+  const controls2 = input3.controls ?? [];
+  if (!Array.isArray(controls2)) throw new TypeError("Cancellation controls must be an array");
+  for (const control of controls2) {
     if (!control || typeof control !== "object" || control.role !== "budget-control" && control.role !== "pipeline-control" || !nativeSignal(control.signal)) throw new TypeError("Invalid cancellation control origin");
   }
-  const required = 1 + Number(input3.callerSignal !== void 0 && !signalAborted(input3.callerSignal)) + controls.filter((control) => !signalAborted(control.signal)).length;
+  const required = 1 + Number(input3.callerSignal !== void 0 && !signalAborted(input3.callerSignal)) + controls2.filter((control) => !signalAborted(control.signal)).length;
   if (admission.resourceLimit < required) throw new CancellationCapacityError();
   const state = initializeState(void 0, admission);
   state.rootCaller = input3.callerSignal === void 0 ? void 0 : Object.freeze({ role: "root-caller", signal: input3.callerSignal, frame: state.boundary });
-  state.controls = Object.freeze(controls.map((control) => Object.freeze({
+  state.controls = Object.freeze(controls2.map((control) => Object.freeze({
     role: control.role,
     signal: control.signal,
     frame: state.boundary
@@ -40932,16 +41087,16 @@ var StateMonitor = class {
     this.#getoptsInput = void 0;
     this.#positionalRevision = {};
   }
-  changedValue(target, field, key) {
-    if (field === "state") {
+  changedValue(target, field2, key) {
+    if (field2 === "state") {
       if (key === "variables") this.values.invalidate();
       if (key === "positional") {
         this.positionals.invalidate();
         this.invalidateGetoptsInput();
       }
-    } else if (field === "variables" && (this.raw.variables === target || this.raw.variables === this.#wrapped.get(target))) {
+    } else if (field2 === "variables" && (this.raw.variables === target || this.raw.variables === this.#wrapped.get(target))) {
       this.values.invalidate(String(key));
-    } else if (field === "positional" && (this.raw.positional === target || this.raw.positional === this.#wrapped.get(target))) {
+    } else if (field2 === "positional" && (this.raw.positional === target || this.raw.positional === this.#wrapped.get(target))) {
       this.positionals.invalidate();
       this.invalidateGetoptsInput();
     }
@@ -41002,8 +41157,8 @@ var StateMonitor = class {
   *overlayFrames() {
     for (let frame = this.#overlays; frame; frame = frame[overlayNext]) yield frame;
   }
-  prepareCollection(value2, field) {
-    return this.wrap(value2, field);
+  prepareCollection(value2, field2) {
+    return this.wrap(value2, field2);
   }
   async prepareTypedPublication(name2, owner, signal) {
     owner.reserve({ metadata: 128, work: 7 });
@@ -41059,7 +41214,7 @@ var StateMonitor = class {
     this.epoch = tickets.epoch;
     this.store?.changed(tickets, name2);
   }
-  wrap(value2, field) {
+  wrap(value2, field2) {
     const previous = this.#wrapped.get(value2);
     if (previous) return previous;
     if (this.#enrollment || this.#internalEnrollment) {
@@ -41067,7 +41222,7 @@ var StateMonitor = class {
     }
     this.#wrapperCount++;
     const monitor = this;
-    const named2 = field === "variables" || field === "exported" || field === "readonlyVariables";
+    const named2 = field2 === "variables" || field2 === "exported" || field2 === "readonlyVariables";
     let proxy;
     if (value2 instanceof Map || value2 instanceof Set) {
       proxy = new Proxy(value2, { get(target, key) {
@@ -41102,8 +41257,8 @@ var StateMonitor = class {
         get(target, key, receiver) {
           const entry = Reflect.get(target, key, receiver);
           if (entry && typeof entry === "object" && key !== "redirectAssignments") {
-            if (field === "state" && key === "functions") return monitor.wrap(entry, "functions");
-            if (field !== "functions") return monitor.wrap(entry, field === "state" ? String(key) : field);
+            if (field2 === "state" && key === "functions") return monitor.wrap(entry, "functions");
+            if (field2 !== "functions") return monitor.wrap(entry, field2 === "state" ? String(key) : field2);
           }
           return entry;
         },
@@ -41111,7 +41266,7 @@ var StateMonitor = class {
           const name2 = named2 ? String(key) : void 0;
           const tickets = monitor.mutation(name2);
           const result2 = Reflect.set(target, key, entry);
-          if (result2) monitor.changedValue(target, field, key);
+          if (result2) monitor.changedValue(target, field2, key);
           monitor.finish(tickets, name2);
           return result2;
         },
@@ -41119,7 +41274,7 @@ var StateMonitor = class {
           const name2 = named2 ? String(key) : void 0;
           const tickets = monitor.mutation(name2);
           const result2 = Reflect.deleteProperty(target, key);
-          if (result2) monitor.changedValue(target, field, key);
+          if (result2) monitor.changedValue(target, field2, key);
           monitor.finish(tickets, name2);
           return result2;
         },
@@ -41127,7 +41282,7 @@ var StateMonitor = class {
           const name2 = named2 ? String(key) : void 0;
           const tickets = monitor.mutation(name2);
           const result2 = Reflect.defineProperty(target, key, descriptor2);
-          if (result2) monitor.changedValue(target, field, key);
+          if (result2) monitor.changedValue(target, field2, key);
           monitor.finish(tickets, name2);
           return result2;
         }
@@ -41536,6 +41691,8 @@ var Budget25 = class {
   iterations = 0;
   bytes = 0;
   sourceBytes = 0;
+  globstarEntries = 0;
+  globstarStates = 0;
   controller = new AbortController();
   signal;
   #wallClockTimer;
@@ -42587,16 +42744,16 @@ var Runtime = class _Runtime {
       resourceLimit: _Runtime.cancellationResourceLimit(budget, 0, maxDepth, 2)
     };
   }
-  static cancellationResourceLimit(budget, depth, maxDepth, controls) {
+  static cancellationResourceLimit(budget, depth, maxDepth, controls2) {
     const remainingCommands = Math.max(0, budget.limits.maxCommands - budget.commands);
     const remainingDepth = Math.max(0, maxDepth - depth);
-    return saturatedSum(saturatedSum(4, controls), saturatedSum(remainingCommands, remainingDepth));
+    return saturatedSum(saturatedSum(4, controls2), saturatedSum(remainingCommands, remainingDepth));
   }
-  cancellationAdmission(depth, controls = 0) {
+  cancellationAdmission(depth, controls2 = 0) {
     return {
       depth,
       maxDepth: this.cancellationMaxDepth,
-      resourceLimit: _Runtime.cancellationResourceLimit(this.budget, depth, this.cancellationMaxDepth, controls)
+      resourceLimit: _Runtime.cancellationResourceLimit(this.budget, depth, this.cancellationMaxDepth, controls2)
     };
   }
   observeRuntimeReturn(rawReturn, frame, downstream = () => void 0) {
@@ -42847,10 +43004,10 @@ var Runtime = class _Runtime {
         await textToken(store.owner, env[key], this.signal);
         publications.set(key, operation2.reserve({ generation: true, version: true, epoch: true, work: 8 }));
       }
-      const controls = operation2.reserve({ epoch: true, work: state.exported.size + keys.length + 5 });
+      const controls2 = operation2.reserve({ epoch: true, work: state.exported.size + keys.length + 5 });
       this.signal.throwIfAborted();
       if (stateMonitor(state).epoch !== epoch2) throw new ArrayFailure("stale state snapshot");
-      stateMonitor(state).publish(controls, void 0, () => {
+      stateMonitor(state).publish(controls2, void 0, () => {
         for (const key of state.exported) delete state.variables[key];
         state.exported = new Set(keys);
       });
@@ -43170,14 +43327,14 @@ var Runtime = class _Runtime {
           const incoming = pipes[index - 1];
           const outgoing = pipes[index];
           const childDepth = this.cancellationDepth + 1;
-          const controls = [
+          const controls2 = [
             { role: "pipeline-control", signal: controllers[index].signal }
           ];
           const prepared = prepareChildCancellation(
             this.cancellation,
             void 0,
-            this.cancellationAdmission(childDepth, controls.length),
-            controls
+            this.cancellationAdmission(childDepth, controls2.length),
+            controls2
           );
           const owner = new InvocationCancellationOwner(io[invocationScope], prepared, this.cancellationState);
           let boundary;
@@ -44451,6 +44608,7 @@ ${functionDisplay(name2, state.functions.get(name2))}`;
       getopts: { cursor: createGetoptsState(), integer: true },
       directoryStack: { entries: [], bytes: 0 },
       dotglob: false,
+      globstar: false,
       positional: [...args],
       arg0,
       profile: context2.command === "sh" ? "sh" : "bash",
@@ -45360,7 +45518,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       if (index < 0n || index > BigInt(count2)) work.fail("directory stack index out of range");
       return Number(index);
     };
-    const field = async (value2) => {
+    const field2 = async (value2) => {
       await work.charge(1);
       return work.scan(value2, "argument");
     };
@@ -45398,11 +45556,11 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     try {
       for (let offset = 0; offset < args.length; offset++) {
         const token = args[offset];
-        const bytes3 = await field(token);
+        const bytes3 = await field2(token);
         if (token === "--") {
           if (command7 === "pushd" && selected === void 0 && offset + 1 < args.length) {
             target = args[offset + 1];
-            targetBytes = await field(target);
+            targetBytes = await field2(target);
             if (!noCd && offset + 2 < args.length) work.fail("too many arguments");
           }
           break;
@@ -45525,7 +45683,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         else if (flag === "u") unset2 = true;
         else {
           await this.diagnostic(context2, `shopt: ${option.startsWith("--") ? option : `-${flag}`}: unsupported option`);
-          await writeDiagnostic(context2.stderr, "shopt: usage: shopt [-pqsu] [--] [dotglob ...]\n");
+          await writeDiagnostic(context2.stderr, "shopt: usage: shopt [-pqsu] [--] [dotglob globstar ...]\n");
           return 2;
         }
       }
@@ -45534,26 +45692,26 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       await this.diagnostic(context2, "shopt: cannot set and unset shell options simultaneously");
       return 1;
     }
-    const emit2 = async () => {
-      if (!quiet) await writeText(context2.stdout, print ? `shopt -${state.dotglob ? "s" : "u"} dotglob
-` : `dotglob             	${state.dotglob ? "on" : "off"}
+    const emit2 = async (name2) => {
+      if (!quiet) await writeText(context2.stdout, print ? `shopt -${state[name2] ? "s" : "u"} ${name2}
+` : `${name2.padEnd(20)}	${state[name2] ? "on" : "off"}
 `);
     };
     if (index === context2.args.length) {
-      if ((!set || state.dotglob) && (!unset2 || !state.dotglob)) await emit2();
+      for (const name2 of ["dotglob", "globstar"]) if ((!set || state[name2]) && (!unset2 || !state[name2])) await emit2(name2);
       return 0;
     }
     let status2 = 0;
     for (; index < context2.args.length; index++) {
       this.signal.throwIfAborted();
       const name2 = context2.args[index];
-      if (name2 !== "dotglob") {
-        await this.diagnostic(context2, `shopt: ${name2}: unsupported shell option name (only dotglob is supported)`);
+      if (name2 !== "dotglob" && name2 !== "globstar") {
+        await this.diagnostic(context2, `shopt: ${name2}: unsupported shell option name (supported: dotglob, globstar)`);
         status2 = 1;
-      } else if (set || unset2) state.dotglob = set;
+      } else if (set || unset2) state[name2] = set;
       else {
-        await emit2();
-        if (!state.dotglob) status2 = 1;
+        await emit2(name2);
+        if (!state[name2]) status2 = 1;
       }
     }
     return status2;
@@ -46130,8 +46288,8 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
             await this.diagnostic(context2, `${names[index]}: readonly variable`);
             return index === names.length - 1 ? 1 : 2;
           }
-          const field = fields3[index];
-          await this.assignVariable(state, names[index], field ? line.value.slice(field.start, index === names.length - 1 && position < end ? end : field.end) : "");
+          const field2 = fields3[index];
+          await this.assignVariable(state, names[index], field2 ? line.value.slice(field2.start, index === names.length - 1 && position < end ? end : field2.end) : "");
         }
       }
       return line.terminated ? 0 : 1;
@@ -46442,10 +46600,10 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
     try {
       const patternFields = await this.word(part.alternate, state, this.parameterOperandIO(part.alternate, state, io), false, true, hereString);
       let patternUnits = 0;
-      for (const field of patternFields) {
-        const pending = stringCheckpoint(work, field.length + 1);
+      for (const field2 of patternFields) {
+        const pending = stringCheckpoint(work, field2.length + 1);
         if (pending) await pending;
-        patternUnits += field.length;
+        patternUnits += field2.length;
       }
       scratch.reserve(patternUnits * 2, 0);
       const pattern = patternFields.join("");
@@ -46597,7 +46755,7 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         const size = shellValueByteLength(value2);
         if (size > this.budget.limits.maxExpansionBytes - expansionBytes) this.budget.fail("maxExpansionBytes");
         expansionBytes += size;
-        const field = fields3.at(-1);
+        const field2 = fields3.at(-1);
         let escapes = 0;
         if (!glob) {
           const special2 = conditionalPattern ? "\\*?[]-^()|+!@" : "\\*?[]-^";
@@ -46606,21 +46764,21 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         scratch?.reserve(32, 0);
         if (owner) owner.reserve({ payload: size + (escapes ? size + escapes : 0), metadata: 64, work: text3.length + 8 });
         if (escapes) {
-          scratch?.reserve((field.patterns ? 32 : 32 * (field.fragments.length + 1)) + (text3.length + escapes) * 2, 0);
-          field.patterns ??= field.fragments.map(shellValueText);
-          field.patterns.push(text3.replace(conditionalPattern ? /[\\*?[\]\-^()|+!@]/gu : /[\\*?[\]\-^]/gu, "\\$&"));
-        } else if (field.patterns) {
+          scratch?.reserve((field2.patterns ? 32 : 32 * (field2.fragments.length + 1)) + (text3.length + escapes) * 2, 0);
+          field2.patterns ??= field2.fragments.map(shellValueText);
+          field2.patterns.push(text3.replace(conditionalPattern ? /[\\*?[\]\-^()|+!@]/gu : /[\\*?[\]\-^]/gu, "\\$&"));
+        } else if (field2.patterns) {
           scratch?.reserve(32, 0);
-          field.patterns.push(text3);
+          field2.patterns.push(text3);
         }
-        if (typeof value2 !== "string" || field.bytes) {
-          if (!scratch) io[valueScope]?.reserve(32 * (field.bytes ? 1 : field.fragments.length + 1), field.bytes ? 1 : field.fragments.length + 1);
+        if (typeof value2 !== "string" || field2.bytes) {
+          if (!scratch) io[valueScope]?.reserve(32 * (field2.bytes ? 1 : field2.fragments.length + 1), field2.bytes ? 1 : field2.fragments.length + 1);
           if (typeof value2 !== "string") io[valueScope]?.hold(value2);
-          field.bytes = true;
+          field2.bytes = true;
         }
         regexAppend?.(text3, !glob);
-        field.fragments.push(value2);
-        field.present ||= present;
+        field2.fragments.push(value2);
+        field2.present ||= present;
       };
       const appendSplit = async (value2) => {
         this.budget.cpuCheckpoint();
@@ -46711,17 +46869,17 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       }
       const result2 = [];
       let resultBytes = 0;
-      for (const field of fields3) {
-        if (!field.present && split4) continue;
-        if (scratch && field.fragments.length > 1 && !field.bytes) scratch.reserve(field.fragments.reduce((bytes3, value2) => bytes3 + shellValueText(value2).length * 2, 0), 0);
-        const assembled = concatShellValues(field.fragments, io[valueScope]);
+      for (const field2 of fields3) {
+        if (!field2.present && split4) continue;
+        if (scratch && field2.fragments.length > 1 && !field2.bytes) scratch.reserve(field2.fragments.reduce((bytes3, value2) => bytes3 + shellValueText(value2).length * 2, 0), 0);
+        const assembled = concatShellValues(field2.fragments, io[valueScope]);
         const projection = shellValueText(assembled);
-        if (field.bytes && field.fragments.length > 1 && !field.patterns) {
-          scratch?.reserve(field.fragments.length * 32, 0);
-          field.patterns = field.fragments.map(shellValueText);
+        if (field2.bytes && field2.fragments.length > 1 && !field2.patterns) {
+          scratch?.reserve(field2.fragments.length * 32, 0);
+          field2.patterns = field2.fragments.map(shellValueText);
         }
-        if (scratch && field.patterns && field.patterns.length > 1) scratch.reserve(field.patterns.reduce((bytes3, text3) => bytes3 + text3.length * 2, 0), 0);
-        const fieldPattern = field.patterns ? field.patterns.join("") : projection;
+        if (scratch && field2.patterns && field2.patterns.length > 1) scratch.reserve(field2.patterns.reduce((bytes3, text3) => bytes3 + text3.length * 2, 0), 0);
+        const fieldPattern = field2.patterns ? field2.patterns.join("") : projection;
         const expanded = split4 ? await this.glob(projection, fieldPattern, state) : [pattern ? fieldPattern : projection];
         for (const text3 of expanded) {
           if (result2.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
@@ -46839,8 +46997,195 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
       holding.release();
     }
   }
+  async recursiveGlob(value2, pattern, state) {
+    const failWalk = (message3) => {
+      const error = new FsError("EFBIG", { syscall: "glob", message: message3 });
+      this.budget.controller.abort(error);
+      throw error;
+    };
+    const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+    const scratch = this.budget.values.scope();
+    work.allocation = scratch;
+    try {
+      const segments = [];
+      let start = 0;
+      for (let end = 0; end <= pattern.length; end++) {
+        const pending = stringCheckpoint(work);
+        if (pending) await pending;
+        if (end !== pattern.length && pattern[end] !== "/") continue;
+        if (end > start) {
+          const bytes3 = (await scanString(pattern, work, start, end)).bytes;
+          if (++this.budget.globstarStates > 1e5) failWalk("globstar traversal state limit exceeded");
+          scratch.reserveBytes(bytes3 * 2 + 64);
+          segments.push(pattern.slice(start, end));
+        }
+        start = end + 1;
+      }
+      const make = (parent, suffix2, bytes3, descend, depth) => {
+        const separator = parent.path && parent.path !== "/" ? "/" : "";
+        const size = parent.bytes + separator.length + bytes3;
+        if (size > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+        if (++this.budget.globstarStates > 1e5) failWalk("globstar traversal state limit exceeded");
+        if (depth > 128) failWalk("globstar directory depth limit exceeded");
+        scratch.reserveBytes(size * 2 + 128);
+        return { path: parent.path + separator + suffix2, bytes: size, descend, depth };
+      };
+      const empty2 = { path: "", bytes: 0, descend: true, depth: 0 };
+      let candidates = [make(empty2, pattern.startsWith("/") ? "/" : "", pattern.startsWith("/") ? 1 : 0, true, 0)];
+      const ignored = (error) => {
+        this.signal.throwIfAborted();
+        return ["ENOENT", "ENOTDIR", "EACCES"].includes(errorCode(error) ?? "");
+      };
+      const read = async (candidate) => {
+        const maxEntries = 1e5 - this.budget.globstarEntries;
+        let entries2;
+        try {
+          entries2 = await interruptible3(this.fs.readdir(pathOf(state, candidate.path || "."), { signal: this.signal, maxEntries }), this.signal);
+        } catch (error) {
+          this.signal.throwIfAborted();
+          if (errorCode(error) === "EFBIG") this.budget.controller.abort(error);
+          throw error;
+        }
+        this.signal.throwIfAborted();
+        if (entries2.length > maxEntries) failWalk("globstar directory entry limit exceeded");
+        this.budget.globstarEntries += entries2.length;
+        return entries2;
+      };
+      let wildcardPrefix = false;
+      for (let index = 0; index < segments.length; index++) {
+        const segment2 = segments[index];
+        const terminal = index === segments.length - 1;
+        const next = /* @__PURE__ */ new Map();
+        const add3 = (candidate) => {
+          const prior = next.get(candidate.path);
+          if (!prior || candidate.descend && !prior.descend) next.set(candidate.path, candidate);
+        };
+        if (segment2 === "**") {
+          const visited = /* @__PURE__ */ new Set();
+          for (const root of candidates) {
+            this.signal.throwIfAborted();
+            try {
+              if ((await interruptible3(this.fs.stat(pathOf(state, root.path || "."), { signal: this.signal }), this.signal)).type !== "directory") continue;
+            } catch (error) {
+              if (ignored(error)) continue;
+              throw error;
+            }
+            if (!terminal || root.path) {
+              add3(terminal && !wildcardPrefix && root.path !== "/" ? make(root, "", 0, root.descend, root.depth) : root);
+            }
+            const queue = root.descend ? [root] : [];
+            while (queue.length) {
+              const directory2 = queue.pop();
+              if (visited.has(directory2.path)) continue;
+              visited.add(directory2.path);
+              let entries2;
+              try {
+                entries2 = await read(directory2);
+              } catch (error) {
+                if (ignored(error)) continue;
+                throw error;
+              }
+              for (const entry of entries2) {
+                const pending = stringCheckpoint(work);
+                if (pending) await pending;
+                if (entry.name === "." || entry.name === ".." || !state.dotglob && entry.name.startsWith(".")) continue;
+                const bytes3 = (await scanString(entry.name, work)).bytes;
+                const child = make(directory2, entry.name, bytes3, entry.type === "directory", directory2.depth + (entry.type === "directory" ? 1 : 0));
+                if (terminal || entry.type === "directory" || entry.type === "symlink" && root.path !== "") add3(child);
+                if (entry.type === "directory") queue.push(child);
+              }
+            }
+          }
+          wildcardPrefix = true;
+        } else if (!/(?:^|[^\\])[*?[]/u.test(segment2)) {
+          const literal = segment2.replace(/\\(.)/gu, "$1");
+          const bytes3 = (await scanString(literal, work)).bytes;
+          for (const candidate of candidates) add3(make(candidate, literal, bytes3, true, candidate.depth));
+        } else {
+          const matches3 = await compilePattern(segment2, work);
+          for (const candidate of candidates) {
+            let entries2;
+            try {
+              entries2 = await read(candidate);
+            } catch (error) {
+              if (ignored(error)) continue;
+              throw error;
+            }
+            for (const entry of entries2) {
+              const pending = stringCheckpoint(work);
+              if (pending) await pending;
+              if (entry.name !== "." && entry.name !== ".." && (state.dotglob || !entry.name.startsWith(".") || segment2.startsWith(".")) && await matches3(entry.name)) {
+                add3(make(candidate, entry.name, (await scanString(entry.name, work)).bytes, true, candidate.depth));
+              }
+            }
+          }
+          wildcardPrefix = true;
+        }
+        candidates = [...next.values()];
+      }
+      const found = [];
+      let outputBytes = 0;
+      for (const candidate of candidates) {
+        this.signal.throwIfAborted();
+        try {
+          const path = pathOf(state, candidate.path);
+          const stat = await interruptible3(value2.endsWith("/") ? this.fs.stat(path, { signal: this.signal }) : this.fs.lstat(path, { signal: this.signal }), this.signal);
+          if (value2.endsWith("/") && stat.type !== "directory") continue;
+          const slash = value2.endsWith("/") && !candidate.path.endsWith("/") ? "/" : "";
+          if (found.length >= this.budget.limits.maxExpansionFields) this.budget.fail("maxExpansionFields");
+          outputBytes += candidate.bytes + slash.length;
+          if (outputBytes > this.budget.limits.maxExpansionBytes) this.budget.fail("maxExpansionBytes");
+          scratch.reserveBytes(candidate.bytes * 2 + slash.length + 8);
+          found.push(candidate.path + slash);
+        } catch (error) {
+          if (!ignored(error)) throw error;
+        }
+      }
+      const compare6 = async (left, right) => {
+        for (let index = 0; index < Math.min(left.length, right.length); index++) {
+          const pending = stringCheckpoint(work);
+          if (pending) await pending;
+          const difference = left.charCodeAt(index) - right.charCodeAt(index);
+          if (difference) return difference;
+        }
+        return left.length - right.length;
+      };
+      const sift = async (root, end) => {
+        while (root * 2 + 1 < end) {
+          let child = root * 2 + 1;
+          if (child + 1 < end && await compare6(found[child], found[child + 1]) < 0) child++;
+          if (await compare6(found[root], found[child]) >= 0) return;
+          const saved = found[root];
+          found[root] = found[child];
+          found[child] = saved;
+          root = child;
+        }
+      };
+      for (let index = Math.floor(found.length / 2) - 1; index >= 0; index--) await sift(index, found.length);
+      for (let end = found.length - 1; end > 0; end--) {
+        const saved = found[0];
+        found[0] = found[end];
+        found[end] = saved;
+        await sift(0, end);
+      }
+      return found.length ? found : [value2];
+    } finally {
+      scratch.close();
+    }
+  }
   async glob(value2, pattern, state) {
     if (!/(?:^|[^\\])[*?[]/u.test(pattern)) return [value2];
+    if (state.globstar) {
+      const work2 = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
+      let start = 0;
+      for (let end = 0; end <= pattern.length; end++) {
+        const pending = stringCheckpoint(work2);
+        if (pending) await pending;
+        if (end !== pattern.length && pattern[end] !== "/") continue;
+        if (end - start === 2 && pattern[start] === "*" && pattern[start + 1] === "*") return this.recursiveGlob(value2, pattern, state);
+        start = end + 1;
+      }
+    }
     const absolute2 = pattern.startsWith("/");
     const work = { remaining: Math.min(Number.MAX_SAFE_INTEGER, this.budget.limits.maxExpansionBytes * 4 + 1024), signal: this.signal, exhausted: () => this.budget.fail("maxExpansionBytes") };
     let candidates = [absolute2 ? "/" : ""];
@@ -47683,6 +48028,7 @@ var Shell = class {
           getopts: { cursor: { index: 0 }, integer: true },
           directoryStack: { entries: [], bytes: 0 },
           dotglob: false,
+          globstar: false,
           status: 0,
           substitutionStatus: 0,
           depth: 0,
@@ -49551,7 +49897,7 @@ function* validDeclaration(content, expectedEncoding) {
     if ((offset - start) % 512) yield (offset - start) % 512;
     return offset - start;
   };
-  const field = function* (name2) {
+  const field2 = function* (name2) {
     if (content.slice(offset, offset + name2.length).toLowerCase() !== name2) return void 0;
     offset += name2.length;
     yield name2.length;
@@ -49569,18 +49915,18 @@ function* validDeclaration(content, expectedEncoding) {
     if (offset >= content.length) return void 0;
     return content.slice(start, offset++);
   };
-  if (!(yield* whitespace2()) || (yield* field("version")) !== "1.0") return false;
+  if (!(yield* whitespace2()) || (yield* field2("version")) !== "1.0") return false;
   let spacing = yield* whitespace2();
   if (content.slice(offset, offset + 8).toLowerCase() === "encoding") {
     if (!spacing) return false;
-    const encoding = yield* field("encoding");
+    const encoding = yield* field2("encoding");
     if (encoding === void 0 || encoding.length > 8 || !["utf-8", "utf-16", "utf-16le", "utf-16be"].includes(encoding.toLowerCase())) return false;
     if (expectedEncoding !== void 0 && encoding.toLowerCase() !== expectedEncoding.toLowerCase()) return false;
     spacing = yield* whitespace2();
   }
   if (content.slice(offset, offset + 10).toLowerCase() === "standalone") {
     if (!spacing) return false;
-    const standalone = yield* field("standalone");
+    const standalone = yield* field2("standalone");
     if (standalone === void 0 || standalone.length > 3 || !["yes", "no"].includes(standalone.toLowerCase())) return false;
     yield* whitespace2();
   }
@@ -51436,11 +51782,11 @@ var GuestDiagnostic = class extends PublicDiagnostic {
 function errorInfo(error) {
   if (typeof error === "string") return { name: "Error", code: "", message: error };
   if (typeof error !== "object" || error === null) return { name: "Error", code: "", message: "SafeJS execution failed" };
-  const field = (name2) => {
+  const field2 = (name2) => {
     const descriptor2 = Object.getOwnPropertyDescriptor(error, name2);
     return descriptor2 && "value" in descriptor2 && typeof descriptor2.value === "string" ? descriptor2.value : "";
   };
-  return { name: field("name"), code: field("code"), message: field("message") || "SafeJS execution failed" };
+  return { name: field2("name"), code: field2("code"), message: field2("message") || "SafeJS execution failed" };
 }
 function statusField(error, name2) {
   if (typeof error !== "object" || error === null) return "";