@poe-platform/safe-bash 0.1.802 → 0.1.804

package/dist/safe-bash/command-chunks/chunk-4R5ADJM5.js

@@ -0,0 +1,178 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-mktemp/src/command.ts
+init_buffer();
+import { creationUmask } from "../../safe-bash-contracts/runtime-control.js";
+import { randomInteger } from "../../safe-bash-metadata-engine/random.js";
+import { FsError, validatePath } from "../../safe-bash-contracts/index.js";
+import { codeOf, diagnostic, pathOf, syncCommandEvaluators, UsageError } from "../../safe-bash-io-engine/internal.js";
+import { gnuInformationSync } from "../../safe-bash-io-engine/gnu-information.js";
+import { MetadataBudget, metadataCommand, settings } from "../../safe-bash-metadata-engine/index.js";
+var mktempEncoder = new TextEncoder();
+function parse(args) {
+  let directory = false;
+  let dryRun = false;
+  let quiet = false;
+  let useTmpdir = false;
+  let deprecatedTmpdir = false;
+  let tmpdir;
+  let suffix;
+  let literal = false;
+  const operands = [];
+  for (let index = 0; index < args.length; index++) {
+    const argument = args[index];
+    if (literal || argument === "-" || !argument.startsWith("-")) operands.push(argument);
+    else if (argument === "--") literal = true;
+    else if (argument === "--directory") directory = true;
+    else if (argument === "--dry-run") dryRun = true;
+    else if (argument === "--quiet") quiet = true;
+    else if (argument === "--tmpdir" || argument.startsWith("--tmpdir=")) {
+      useTmpdir = true;
+      tmpdir = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : "";
+    } else if (argument === "--suffix" || argument.startsWith("--suffix=")) {
+      suffix = argument.includes("=") ? argument.slice(argument.indexOf("=") + 1) : args[++index];
+      if (suffix === void 0) throw new UsageError("--suffix requires an argument");
+    } else if (!argument.startsWith("--")) {
+      for (let offset = 1; offset < argument.length; offset++) {
+        const option = argument[offset];
+        if (option === "d") directory = true;
+        else if (option === "u") dryRun = true;
+        else if (option === "q") quiet = true;
+        else if (option === "t") {
+          useTmpdir = true;
+          deprecatedTmpdir = true;
+        } else if (option === "p") {
+          tmpdir = argument.slice(offset + 1) || args[++index];
+          if (tmpdir === void 0) throw new UsageError("-p requires an argument");
+          useTmpdir = true;
+          break;
+        } else throw new UsageError(`unrecognized option '${argument}'`);
+      }
+    } else throw new UsageError(`unrecognized option '${argument}'`);
+  }
+  if (operands.length > 1) throw new UsageError("too many templates");
+  let template = operands[0] ?? "tmp.XXXXXXXXXX";
+  if (deprecatedTmpdir && !template.includes("XXX")) template += ".XXXXXXXXXX";
+  if (operands.length === 0) useTmpdir = true;
+  validatePath(template);
+  if (deprecatedTmpdir && template.includes("/")) throw new UsageError("template contains directory separator");
+  validatePath(suffix ?? "");
+  if (suffix?.includes("/") || suffix !== void 0 && !template.endsWith("X")) throw new UsageError("suffix requires a template ending in X and cannot contain '/'");
+  const name = template.slice(template.lastIndexOf("/") + 1);
+  if (name.length + (suffix?.length ?? 0) > 255 || mktempEncoder.encode(name).byteLength + mktempEncoder.encode(suffix ?? "").byteLength > 255) throw new FsError("ENAMETOOLONG", { path: template });
+  const end = name.lastIndexOf("X") + 1;
+  let start = end;
+  while (start > 0 && name[start - 1] === "X") start--;
+  if (end - start < 3) throw new UsageError("template must contain at least three consecutive X characters in its last component");
+  if (useTmpdir && template.startsWith("/")) throw new UsageError("template must be relative with --tmpdir/-p");
+  const tail = suffix ?? name.slice(end);
+  return { directory, dryRun, quiet, useTmpdir, deprecatedTmpdir, tmpdir, template, prefix: template.slice(0, template.length - name.length + start), count: end - start, tail };
+}
+var alphabet = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+function sampleTemplateChars(count) {
+  let out = "";
+  for (let index = 0; index < count; index++) out += alphabet[randomInteger(alphabet.length)];
+  return out;
+}
+function evalSyncMktemp(opArgs, env, statTypeSync, writeFileSync, mkdirSync) {
+  const gnuInfo = gnuInformationSync("mktemp", opArgs);
+  if (gnuInfo !== void 0) return gnuInfo;
+  try {
+    const parsed = parse(opArgs);
+    const parent = parsed.deprecatedTmpdir && env.TMPDIR || parsed.tmpdir || env.TMPDIR || "/tmp";
+    validatePath(parent);
+    if (!statTypeSync) return void 0;
+    if (parsed.useTmpdir && !parsed.dryRun && statTypeSync(parent || ".") !== "directory") return void 0;
+    for (let attempt = 0; attempt < 32; attempt++) {
+      const random = sampleTemplateChars(parsed.count);
+      const generated = `${parsed.prefix}${random}${parsed.tail}`;
+      const display = parsed.useTmpdir ? `${parent.replace(/\/+$/u, "")}/${generated}` : generated;
+      const st = statTypeSync(display);
+      if (st !== "missing") continue;
+      if (!parsed.dryRun) {
+        if (parsed.directory) {
+          if (!mkdirSync || !mkdirSync(display)) return void 0;
+        } else {
+          if (!writeFileSync || !writeFileSync(display, new Uint8Array(0))) return void 0;
+        }
+      }
+      return `${display}
+`;
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
+syncCommandEvaluators.evalSyncMktemp = evalSyncMktemp;
+function createMktempCommand(configuration = {}) {
+  const configured = settings(configuration);
+  const configuredUmask = configuration.umask === void 0 ? void 0 : configured.umask;
+  return metadataCommand("mktemp", async (context) => {
+    const budget = new MetadataBudget(context, configured.limits);
+    const parsed = parse(context.args);
+    const parent = parsed.deprecatedTmpdir && context.env.TMPDIR || parsed.tmpdir || context.env.TMPDIR || "/tmp";
+    validatePath(parent);
+    try {
+      if (!parsed.dryRun) {
+        if (context.fs.capabilities.readOnly) throw new FsError("EROFS", { syscall: "mktemp" });
+      }
+      for (let attempt = 0; attempt < configured.limits.maxAttempts; attempt++) {
+        await budget.step();
+        const random = sampleTemplateChars(parsed.count);
+        const generated = `${parsed.prefix}${random}${parsed.tail}`;
+        const display = parsed.useTmpdir ? `${parent.replace(/\/+$/u, "")}/${generated}` : generated;
+        const path = pathOf(context, display);
+        if (mktempEncoder.encode(display).byteLength + 1 > configured.limits.maxOutputBytes) throw new FsError("EFBIG", { message: "temporary pathname output exceeds limit" });
+        if (parsed.dryRun) {
+          try {
+            await context.fs.lstat(path, { signal: context.signal });
+            continue;
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) !== "ENOENT") throw error;
+          }
+        } else {
+          const capabilities = await context.fs.capabilitiesFor?.(path, { signal: context.signal }) ?? context.fs.capabilities;
+          if (capabilities.readOnly === true) throw new FsError("EROFS", { syscall: "mktemp" });
+          if (capabilities.permissions !== true) throw new FsError("ENOTSUP", { syscall: "mktemp", message: "private temporary creation requires declared permission support" });
+          if (parsed.useTmpdir && parent === "/tmp" && !parsed.tmpdir && !context.env.TMPDIR) {
+            try {
+              await context.fs.stat(parent, { signal: context.signal });
+            } catch (error) {
+              context.signal.throwIfAborted();
+              if (codeOf(error) !== "ENOENT") throw error;
+              await context.fs.mkdir(parent, { recursive: true, mode: 511, signal: context.signal });
+            }
+          }
+          try {
+            const mask = configuredUmask ?? Reflect.get(context.fs, creationUmask);
+            const activeUmask = typeof mask === "number" ? mask : configured.umask;
+            const mode = (parsed.directory ? 448 : 384) & ~activeUmask;
+            if (parsed.directory) await context.fs.mkdir(path, { mode, recursive: false, signal: context.signal });
+            else await context.fs.writeFile(path, new Uint8Array(), { mode, flag: "wx", signal: context.signal });
+          } catch (error) {
+            context.signal.throwIfAborted();
+            if (codeOf(error) !== "EEXIST") throw error;
+            continue;
+          }
+        }
+        await budget.output(`${display}
+`);
+        return { exitCode: 0 };
+      }
+      throw new FsError("EEXIST", { syscall: "mktemp", message: "temporary name collision limit exceeded" });
+    } catch (error) {
+      context.signal.throwIfAborted();
+      if (!parsed.quiet) await diagnostic(context, error);
+      return { exitCode: 1 };
+    }
+  });
+}
+
+export {
+  evalSyncMktemp,
+  createMktempCommand
+};

package/dist/safe-bash/command-chunks/{chunk-P2N33UMN.js → chunk-5MIKM54M.js}

@@ -1,9 +1,6 @@
-import {
-  AwkRetention
-} from "./chunk-2H4JTFIL.js";
 import {
   AwkRuntime
-} from "./chunk-RMWQAAO5.js";
+} from "./chunk-7IR4NRNE.js";
 import {
   AwkParser,
   builtinArities,
@@ -18,6 +15,9 @@ import {
 import {
   quoteAwk
 } from "./chunk-EQ4HV54N.js";
+import {
+  AwkRetention
+} from "./chunk-2H4JTFIL.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-DB453IE6.js → chunk-6FZQUOSJ.js}

@@ -1,6 +1,6 @@
 import {
   Reader
-} from "./chunk-7K6JYKPJ.js";
+} from "./chunk-6M2ELGEN.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-WPYIOKE3.js → chunk-6GKYHPJG.js}

@@ -2,10 +2,10 @@ import {
   chunkBytes,
   stagingLimit,
   transform
-} from "./chunk-2JRBIDAD.js";
+} from "./chunk-I63DBZXZ.js";
 import {
   formats
-} from "./chunk-5E4WAO4O.js";
+} from "./chunk-JD5QNRNO.js";
 import {
   codeOf,
   pathOf

package/dist/safe-bash/command-chunks/{chunk-7K6JYKPJ.js → chunk-6M2ELGEN.js}

@@ -41,6 +41,19 @@ var Reader = class _Reader {
   isPooledMemory = false;
   activeReads = 0;
   static fromMemoryView(chunk, budget, retention) {
+    budget.step();
+    const length = chunk.byteLength;
+    if (length > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+    let batch;
+    if (length > 0) {
+      retention.admit(0, length);
+      try {
+        batch = getCachedLatin1Batch(chunk);
+      } catch (error) {
+        retention.release(length);
+        throw error;
+      }
+    }
     let reader = memoryReaderPool.reader;
     if (reader !== void 0) {
       memoryReaderPool.reader = void 0;
@@ -62,22 +75,11 @@ var Reader = class _Reader {
       reader.ended = true;
       reader.isPooledMemory = true;
     }
-    budget.step();
-    const length = chunk.byteLength;
-    if (length > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
     if (length > 0) {
-      retention.admit(0, length);
-      try {
-        const batch = getCachedLatin1Batch(chunk);
-        const block = chunk;
-        reader.blocks[0] = block;
-        reader.blockStrings[0] = batch?.text;
-        reader.blockEnds[0] = batch?.ends;
-        reader.blocksLen = 1;
-      } catch (error) {
-        retention.release(length);
-        throw error;
-      }
+      reader.blocks[0] = chunk;
+      reader.blockStrings[0] = batch?.text;
+      reader.blockEnds[0] = batch?.ends;
+      reader.blocksLen = 1;
       reader.buffered = length;
       reader.ownedBytes = length;
     }

package/dist/safe-bash/command-chunks/{chunk-PXEIT2O4.js → chunk-6UR7V3ET.js}

@@ -121,17 +121,24 @@ var TimeZone = class {
     checkCalendar(fields, restrictYear);
     return { ...fields, offset, zone };
   }
-  instant(fields, fraction = 0n) {
+  instant(fields, fraction = 0n, disambiguation = "reject") {
     checkCalendar(fields);
     const wall = utcMilliseconds(fields);
     if (this.fixedOffset !== void 0) return boundedInstant(BigInt(wall) * 1000000n - BigInt(this.fixedOffset) * nanosecondsPerSecond + fraction);
     const offsets = /* @__PURE__ */ new Set();
     for (const days of [-2, -1, 0, 1, 2]) offsets.add(this.observedFields(BigInt(wall + days * 864e5) * 1000000n, false).offset);
     const candidates = [];
+    const shifted = [];
     for (const offset of offsets) {
       const candidate = BigInt(wall) * 1000000n - BigInt(offset) * nanosecondsPerSecond + fraction;
+      shifted.push(candidate);
       if (sameFields(this.observedFields(candidate, false), fields)) candidates.push(candidate);
     }
+    if (disambiguation === "compatible") {
+      const choices = candidates.length ? candidates : shifted;
+      const selected = choices.reduce((left, right) => candidates.length ? left < right ? left : right : left > right ? left : right);
+      return boundedInstant(selected);
+    }
     if (candidates.length === 0) throw new CommandFailure("nonexistent local time in virtual TZ");
     if (candidates.length !== 1) throw new CommandFailure("ambiguous local time; specify an explicit UTC offset");
     return boundedInstant(candidates[0]);

package/dist/safe-bash/command-chunks/{chunk-6KJ3LPI2.js → chunk-6XBS5B46.js}

@@ -1,9 +1,15 @@
 import {
   curlRequestTarget
 } from "./chunk-N4PFUSRM.js";
+import {
+  withSignal
+} from "./chunk-GOB777HR.js";
 import {
   CurlError
 } from "./chunk-GRBWW4SG.js";
+import {
+  scheduleNetworkDeadline
+} from "./chunk-KWESKQHR.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";
@@ -32,8 +38,10 @@ function requestBody(source, signal) {
 function createFetchTransport(options = {}) {
   const fetchRequest = options.fetch ?? globalThis.fetch;
   if (typeof fetchRequest !== "function") throw new TypeError("Fetch is unavailable");
-  return async (input) => {
+  const transport = async (input) => {
     input.signal.throwIfAborted();
+    if (input.connectTimeoutMs !== void 0) throw new CurlError(2, "Fetch transport cannot enforce exact connection timeout");
+    if (input.insecure) throw new CurlError(2, "Fetch transport cannot disable TLS verification");
     if (input.ca !== void 0) throw new CurlError(2, "Fetch transport cannot enforce request CA trust");
     if (input.httpVersion !== void 0) throw new CurlError(2, "Transport cannot enforce requested HTTP version");
     if (input.ignoreContentLength) throw new CurlError(2, "Transport cannot enforce ignored Content-Length");
@@ -58,12 +66,26 @@ function createFetchTransport(options = {}) {
       ...body ? { duplex: "half" } : {}
     });
     let response;
+    const cancelDeadline = scheduleNetworkDeadline(input.responseHeaderTimeoutMs && input.responseHeaderTimeoutMs > 0 ? input.responseHeaderTimeoutMs : Infinity, () => stopped.abort(new CurlError(28, "Response headers timed out")));
     const dispose = async () => {
+      cancelDeadline();
       stopped.abort();
       if (response?.body) await response.body.cancel().catch(() => void 0);
     };
-    input.registerCleanup?.(dispose);
-    response = await fetchRequest(request);
+    try {
+      input.registerCleanup?.(dispose);
+      response = await withSignal(async () => {
+        signal.throwIfAborted();
+        const received = await fetchRequest(request);
+        if (signal.aborted) {
+          void received.body?.cancel().catch(() => void 0);
+          signal.throwIfAborted();
+        }
+        return received;
+      }, signal);
+    } finally {
+      cancelDeadline();
+    }
     const reader = response.body?.getReader();
     const responseBody = reader ? (async function* () {
       try {
@@ -87,6 +109,7 @@ function createFetchTransport(options = {}) {
       dispose
     };
   };
+  return Object.assign(transport, { supportsResponseHeaderTimeout: true });
 }
 
 export {

package/dist/safe-bash/command-chunks/{chunk-5PWJG2UK.js → chunk-6YXLZX7L.js}

@@ -1,10 +1,10 @@
 import {
   createArchive,
   manifest
-} from "./chunk-WNE7FPVR.js";
+} from "./chunk-I64TLTIW.js";
 import {
   readArchive
-} from "./chunk-TIOCQVUQ.js";
+} from "./chunk-CON26Q2O.js";
 import {
   Reader,
   autodetected,

package/dist/safe-bash/command-chunks/{chunk-EK6YNAXT.js → chunk-753YOR54.js}

@@ -5,7 +5,7 @@ import {
 // packages/safe-bash-zip-engine/src/zip/safety.ts
 init_buffer();
 import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
-import { readBytes } from "../../safe-bash-contracts/index.js";
+import { collectBytes, readBytes } from "../../safe-bash-contracts/index.js";
 import { writeFileOutput } from "../../safe-bash-contracts/filesystem-output.js";
 import { checkPath, fail, hasIdentity as hasPosixIdentity, sameIdentity as samePosixIdentity } from "../../safe-bash-io-engine/commands/archive/internal.js";
 function hasZipIdentity(stat) {
@@ -122,7 +122,22 @@ var ZipScope = class {
   async *input(path, fifo = false, expected) {
     const { fs } = this.context;
     if (expected) {
-      if (!hasZipIdentity(expected)) fail("ZIP source requires known backing identity");
+      const capabilities2 = await this.operation(() => fs.capabilitiesFor?.(path, { signal: this.context.signal }) ?? fs.capabilities);
+      if (!hasZipIdentity(expected) || !fs.openReadFile || capabilities2.retainedRead !== true) {
+        const { signal: signal3 } = this.context;
+        const canonical = await this.operation(() => fs.realpath(path, { signal: signal3 }));
+        const before = await this.operation(() => fs.stat(path, { signal: signal3 }));
+        if (!unchangedZipSource(expected, before)) fail(`source changed while opening: ${path}`);
+        let size = 0;
+        for await (const bytes of this.input(path)) {
+          if (bytes.length > expected.size - size) fail(`source changed while reading: ${path}`);
+          size += bytes.length;
+          yield bytes;
+        }
+        const current = await this.operation(() => fs.stat(path, { signal: signal3 }));
+        if (size !== expected.size || !unchangedZipSource(expected, current) || canonical !== await this.operation(() => fs.realpath(path, { signal: signal3 }))) fail(`source changed while reading: ${path}`);
+        return;
+      }
       const controller2 = new AbortController();
       const signal2 = AbortSignal.any([this.context.signal, controller2.signal]);
       let handle;
@@ -145,9 +160,9 @@ var ZipScope = class {
       this.readers.add(close);
       try {
         await (acquisition = this.operation(async () => {
-          const capabilities2 = await (fs.capabilitiesFor?.(path, { signal: signal2 }) ?? fs.capabilities);
+          const capabilities3 = await (fs.capabilitiesFor?.(path, { signal: signal2 }) ?? fs.capabilities);
           signal2.throwIfAborted();
-          if (capabilities2.retainedRead !== true || !fs.openReadFile) fail("ZIP source requires retained reads");
+          if (capabilities3.retainedRead !== true || !fs.openReadFile) fail("ZIP source requires retained reads");
           handle = await fs.openReadFile(path, { signal: signal2 });
         }));
         if (this.inputDrain) fail("ZIP inputs are closed");
@@ -297,7 +312,18 @@ async function publishZip(scope, prepared) {
     }
     return;
   }
-  if (capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true || !fs.publishStagedFile) fail("ZIP publication requires atomic owned file staging");
+  if (capabilities.atomicFileStaging !== true && capabilities.trustedOwnedStaging !== true || !fs.publishStagedFile) {
+    if (prepared.existing || capabilities.exclusiveCreate !== true || prepared.validate || prepared.stagingName !== void 0 || prepared.mtimeMs !== void 0) fail("ZIP publication requires atomic owned file staging");
+    const maxBytes = Math.min(scope.limits.maxArchiveBytes, scope.limits.maxBufferedFileBytes);
+    const bytes = prepared.bytes ?? await collectBytes(prepared.source, { signal, ...Number.isFinite(maxBytes) ? { maxBytes } : {} });
+    if (bytes.length > maxBytes) fail("buffered archive byte limit exceeded");
+    const parent = await scope.operation(() => fs.realpath(prepared.parentName, { signal }));
+    if (parent !== prepared.parent) fail("archive parent changed before publication");
+    const write = (data) => scope.operation(() => fs.writeFile(prepared.output, data, { signal, flag: "wx" }));
+    if (prepared.source) await writeFileOutput(scope.context, bytes, write);
+    else await write(bytes);
+    return;
+  }
   await stageZip(scope, {
     ...prepared,
     reservedPath: prepared.output,

package/dist/safe-bash/command-chunks/{chunk-RMWQAAO5.js → chunk-7IR4NRNE.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-5BSTFCXG.js";
 import {
   AwkPipes
-} from "./chunk-DB453IE6.js";
+} from "./chunk-6FZQUOSJ.js";
 import {
   AwkArray,
   SCALAR_ONE,
@@ -22,7 +22,7 @@ import {
 } from "./chunk-6BNTBWIK.js";
 import {
   Reader
-} from "./chunk-7K6JYKPJ.js";
+} from "./chunk-6M2ELGEN.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-FZTK4MFI.js → chunk-7NM73SVK.js}

@@ -1,6 +1,13 @@
 import {
   configuredTable
-} from "./chunk-LAOM65EE.js";
+} from "./chunk-IEO4XVN6.js";
+import {
+  cell,
+  decode,
+  fields,
+  validateScalar,
+  whitespace
+} from "./chunk-MTQH74CF.js";
 import {
   ColumnInputs,
   diagnostics
@@ -11,13 +18,6 @@ import {
   settings,
   usage
 } from "./chunk-AHEQ2THG.js";
-import {
-  cell,
-  decode,
-  fields,
-  validateScalar,
-  whitespace
-} from "./chunk-MTQH74CF.js";
 import {
   init_buffer
 } from "./chunk-HX3SHTCE.js";

package/dist/safe-bash/command-chunks/{chunk-NXEQ3ESQ.js → chunk-7QD5YY4F.js}

@@ -30,7 +30,11 @@ var XmlQueryLimitError = class extends XmlQueryError {
 };
 function resolveXmlQueryLimits(options = {}) {
   const limits = { ...defaultXmlQueryLimits, ...options };
-  for (const [name, value] of Object.entries(limits)) {
+  for (const name of Object.keys(limits)) {
+    if (Object.hasOwn(defaultXmlQueryLimits, name) && limits[name] === void 0) {
+      limits[name] = defaultXmlQueryLimits[name];
+    }
+    const value = limits[name];
     if (!Object.hasOwn(defaultXmlQueryLimits, name) || value !== Infinity && !Number.isSafeInteger(value) || value < 1) {
       throw new RangeError(`${name} must be a positive safe integer XML limit`);
     }
@@ -42,21 +46,12 @@ var XmlBudget = class {
     this.limits = limits;
     this.signal = signal;
     this.checkpointTurn = checkpointTurn;
-    this.aborted = Boolean(signal?.aborted);
-    this.pollSignal = Boolean(signal && (typeof signal.addEventListener !== "function" || Object.prototype.hasOwnProperty.call(signal, "aborted")));
-    if (signal && !this.aborted && !this.pollSignal) {
-      signal.addEventListener("abort", () => {
-        this.aborted = true;
-      }, { once: true });
-    }
   }
   limits;
   signal;
   checkpointTurn;
   steps = 0;
   checkpoint = 0;
-  aborted = false;
-  pollSignal;
   outputBytes = 0;
   inputBytes = 0;
   /** Charge synchronous work only when it cannot start an asynchronous checkpoint. */
@@ -66,7 +61,7 @@ var XmlBudget = class {
     return true;
   }
   tick(work = 1) {
-    if (this.aborted || this.pollSignal && this.signal.aborted) this.signal.throwIfAborted();
+    if (this.signal.aborted) this.signal.throwIfAborted();
     this.steps += work;
     if (this.steps > this.limits.maxSteps) throw new XmlQueryLimitError("maxSteps");
     this.checkpoint += work;

package/dist/safe-bash/command-chunks/{chunk-EMPU65ZK.js → chunk-A5LBSJGH.js}

@@ -45,6 +45,7 @@ function resolveYqLimits(overrides = {}) {
     maxSteps: yqCaps.maxSteps
   };
   for (const [key, value] of Object.entries(overrides)) {
+    if (Object.hasOwn(limits, key) && value === void 0) continue;
     if (!Object.hasOwn(limits, key) || value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
       throw new TypeError("yq limits must be nonnegative safe integers or Infinity with supported names");
     }