@poe-platform/safe-bash 0.1.433 → 0.1.435

package/dist/safe-bash/portable.js

@@ -9222,7 +9222,7 @@ var InvocationScope = class _InvocationScope {
   failures;
   parent;
   #children = /* @__PURE__ */ new Set();
-  #callbacks = [];
+  #callbacks = /* @__PURE__ */ new Map();
   #finalizers = [];
   #work = /* @__PURE__ */ new Set();
   #controller = new AbortController();
@@ -9249,7 +9249,11 @@ var InvocationScope = class _InvocationScope {
   register(cleanup) {
     this.assertOpen();
     if (typeof cleanup !== "function") throw new TypeError("Cleanup must be callable");
-    this.#callbacks.push(cleanup);
+    const registration = /* @__PURE__ */ Symbol();
+    this.#callbacks.set(registration, cleanup);
+    return () => {
+      this.#callbacks.delete(registration);
+    };
   }
   run(operation2) {
     this.assertOpen();
@@ -9282,9 +9286,11 @@ var InvocationScope = class _InvocationScope {
   close() {
     if (!this.#drain) {
       this.#drain = Promise.resolve().then(async () => {
+        const callbacks = [...this.#callbacks.values()];
+        this.#callbacks.clear();
         try {
           await Promise.all([
-            ...this.#callbacks.splice(0).map((cleanup) => this.cleanup(cleanup)),
+            ...callbacks.map((cleanup) => this.cleanup(cleanup)),
             ...[...this.#children].map((child) => child.close()),
             ...this.#work
           ]);
@@ -10606,7 +10612,7 @@ var StateMonitor = class {
     monitors.set(raw, this);
     monitors.set(this.proxy, this);
     if (session.monitors) session.monitors.add(this);
-    else session.scope.register(async () => {
+    else this.#retireCleanup = session.scope.register(async () => {
       await session.scope.drainWork();
       this.closeValues();
     });
@@ -10625,9 +10631,12 @@ var StateMonitor = class {
   #internalEnrollment;
   #restorations;
   #overlays;
+  #retireCleanup;
   closeValues() {
     this.values.close();
     this.positionals.close();
+    this.#retireCleanup?.();
+    this.#retireCleanup = void 0;
   }
   changedValue(target, field, key) {
     if (field === "state") {
@@ -12595,7 +12604,7 @@ var InvocationCancellationOwner = class {
     this.finalized = new Promise((resolve) => {
       this.#resolveFinalized = resolve;
     });
-    parent.register(async () => {
+    this.#retireCleanup = parent.register(async () => {
       this.requestClose();
       await this.finalized;
     });
@@ -12605,6 +12614,7 @@ var InvocationCancellationOwner = class {
   #failures;
   #outcomes;
   #publicPromise;
+  #retireCleanup;
   #resolveFinalized;
   #admissionOpen = true;
   #boundary;
@@ -12681,6 +12691,7 @@ var InvocationCancellationOwner = class {
       this.#outcomes.discard(this.#record);
       this.#closeBoundary();
       this.#resolveFinalized();
+      this.#retireCleanup();
     }
   }
   async #finishOnce(barrier, captured) {
@@ -12693,6 +12704,7 @@ var InvocationCancellationOwner = class {
       return selection;
     } finally {
       this.#resolveFinalized();
+      this.#retireCleanup();
     }
   }
   #closeBoundary() {
@@ -14047,10 +14059,18 @@ var Runtime = class _Runtime {
               if (--file.references === 0 && this.outputFiles.get(path) === file) this.outputFiles.delete(path);
             };
             let target2;
+            let outputScope;
             try {
-              target2 = await openFileOutput({ fs: this.fs, signal: this.signal, registerCleanup: (cleanup) => io[invocationScope].register(cleanup) }, path, append ? "a" : "w", random ? incremental : void 0);
+              outputScope = io[invocationScope].child();
+              target2 = await openFileOutput({ fs: this.fs, signal: this.signal, registerCleanup: (cleanup) => {
+                outputScope.register(cleanup);
+              } }, path, append ? "a" : "w", random ? incremental : void 0);
             } catch (error) {
-              release();
+              try {
+                await outputScope?.close();
+              } finally {
+                release();
+              }
               throw error;
             }
             outputs.add(async (completion) => {
@@ -14066,7 +14086,11 @@ var Runtime = class _Runtime {
                   }
                 }
               } finally {
-                release();
+                try {
+                  await outputScope?.close();
+                } finally {
+                  release();
+                }
               }
             });
             const output2 = this.budget.sink(target2.sink, this.signal);
@@ -14307,7 +14331,9 @@ var Runtime = class _Runtime {
       fs: this.fs,
       signal: this.commandSignal,
       executionScope: this.budget.executionScope,
-      registerCleanup: (cleanup) => scope.register(cleanup),
+      registerCleanup: (cleanup) => {
+        scope.register(cleanup);
+      },
       invoke: (name3, args, options3) => {
         const invocation = this.invoke(name3, args, options3, context2, state, scope);
         void invocation.catch(() => void 0);
@@ -14914,7 +14940,9 @@ ${prefix3} line ${offset + line}: \`${source2.split("\n")[line - 1] ?? ""}'
         stdout: this.budget.sink(incoming.stdout, runtime.signal),
         stderr: this.budget.sink(incoming.stderr, runtime.signal),
         signal: this.commandSignal,
-        registerCleanup: (cleanup) => scope.register(cleanup),
+        registerCleanup: (cleanup) => {
+          scope.register(cleanup);
+        },
         invoke: (name2, args, options3) => {
           const invocation = invocationOverride.current ? invocationOverride.current(name2, args, options3) : runtime.invoke(name2, args, options3, context2, child, scope);
           void invocation.catch(() => void 0);
@@ -18832,10 +18860,32 @@ function extendedSource(source2) {
   }
   return result2;
 }
+var NfaStorage = class {
+  constructor(budget) {
+    this.budget = budget;
+  }
+  budget;
+  used = 0;
+  reserve(bytes3) {
+    this.budget.step(0);
+    if (!Number.isSafeInteger(bytes3) || bytes3 < 0 || bytes3 > this.budget.maxBufferBytes - this.used) {
+      throw new ProgramError("regular expression state buffer limit exceeded");
+    }
+    this.used += bytes3;
+  }
+  release(bytes3) {
+    if (!Number.isSafeInteger(bytes3) || bytes3 < 0 || bytes3 > this.used) throw new ProgramError("invalid regular expression state accounting");
+    this.used -= bytes3;
+  }
+  clear() {
+    this.used = 0;
+  }
+};
 var Pattern = class {
   groupCount;
   code = [];
   anchored;
+  linear;
   constructor(source2, extended = true, ignoreCase = false) {
     if (source2.length > 8192) throw new ProgramError("regular expression exceeds 8192 bytes");
     if (!extended) source2 = extendedSource(source2);
@@ -19002,92 +19052,188 @@ var Pattern = class {
     };
     compile2(root);
     emit2({ kind: "match" });
+    this.linear = this.code.every((instruction) => instruction.kind === "character" || instruction.kind === "begin" || instruction.kind === "end" || instruction.kind === "match");
   }
-  find(text3, budget, from = 0) {
-    for (let start = from; start <= text3.length && (!this.anchored || start === 0); start++) {
-      const positions = /* @__PURE__ */ new Map([[start, [{ pc: 0, captures: [] }]]]);
-      let best;
-      let bestCaptures = [];
-      let queued = 1;
-      const preferCaptures = (captures) => {
-        for (let index = 1; index <= this.groupCount; index++) {
-          const begin = captures[index * 2];
-          const end = captures[index * 2 + 1];
-          const priorBegin = bestCaptures[index * 2];
-          const priorEnd = bestCaptures[index * 2 + 1];
-          const length = begin === void 0 || end === void 0 ? -1 : end - begin;
-          const priorLength = priorBegin === void 0 || priorEnd === void 0 ? -1 : priorEnd - priorBegin;
-          if (length !== priorLength) return length > priorLength;
-        }
-        return false;
-      };
-      for (let position = start; positions.size && position <= text3.length; position++) {
-        budget.step();
-        const pending = positions.get(position)?.reverse() ?? [];
-        positions.delete(position);
-        queued -= pending.length;
-        const visited = /* @__PURE__ */ new Set();
-        let stateBytes = 0;
-        const enqueue = (destination2, thread) => {
-          if (destination2 === position) pending.push(thread);
-          else {
-            const waiting = positions.get(destination2);
-            if (waiting) waiting.push(thread);
-            else positions.set(destination2, [thread]);
-            queued++;
-          }
-          if ((queued + pending.length) * (32 + this.groupCount * 16) > budget.maxBufferBytes) throw new ProgramError("regular expression state buffer limit exceeded");
-        };
-        while (pending.length) {
-          budget.step();
-          const thread = pending.pop();
-          const state = this.groupCount ? `${thread.pc}:${thread.captures.join(",")}` : thread.pc;
-          if (visited.has(state)) continue;
-          visited.add(state);
-          stateBytes += typeof state === "string" ? state.length * 2 + 32 : 16;
-          if (stateBytes > budget.maxBufferBytes) throw new ProgramError("regular expression state buffer limit exceeded");
-          const instruction = this.code[thread.pc];
+  async find(text3, budget, from = 0) {
+    await budget.checkpoint();
+    let units = 0;
+    const work = (count2 = 1) => {
+      budget.step(count2);
+      units += count2;
+      if (units < 64) return void 0;
+      units %= 64;
+      return budget.checkpoint();
+    };
+    if (this.linear) {
+      for (let start = from; start <= text3.length && (!this.anchored || start === 0); start++) {
+        let position = start;
+        for (const instruction of this.code) {
+          const paused = work(2);
+          if (paused) await paused;
           if (instruction.kind === "character") {
-            if (position < text3.length && instruction.accepts(text3[position])) enqueue(position + 1, { pc: thread.pc + 1, captures: thread.captures });
-          } else if (instruction.kind === "backreference") {
-            const begin = thread.captures[instruction.index * 2];
-            const end = thread.captures[instruction.index * 2 + 1];
-            if (begin === void 0 || end === void 0 || position + end - begin > text3.length) continue;
-            let matches3 = true;
-            for (let offset = 0; offset < end - begin; offset++) {
-              budget.step();
-              const expected = text3[begin + offset];
-              const actual = text3[position + offset];
-              if (instruction.ignoreCase ? expected.toLowerCase() !== actual.toLowerCase() : expected !== actual) {
-                matches3 = false;
-                break;
+            if (position >= text3.length || !instruction.accepts(text3[position])) break;
+            position++;
+          } else if (instruction.kind === "begin" && position !== 0 || instruction.kind === "end" && position !== text3.length) break;
+          else if (instruction.kind === "match") {
+            if (position - start > budget.maxBufferBytes) throw new ProgramError("text buffer limit exceeded");
+            const copied = work(position - start);
+            if (copied) await copied;
+            const match = { start, end: position, groups: [text3.slice(start, position)] };
+            await budget.checkpoint();
+            return match;
+          }
+        }
+      }
+      return void 0;
+    }
+    const storage = new NfaStorage(budget);
+    const positionDigits = String(text3.length).length;
+    const instructionDigits = String(this.code.length).length;
+    try {
+      for (let start = from; start <= text3.length && (!this.anchored || start === 0); start++) {
+        storage.reserve(256);
+        const positions = /* @__PURE__ */ new Map([[start, [{ pc: 0, captures: [], bytes: 64 }]]]);
+        let bestEnd;
+        let bestCaptures = [];
+        let bestBytes = 0;
+        try {
+          for (let position = start; positions.size && position <= text3.length; position++) {
+            const advanced = work();
+            if (advanced) await advanced;
+            const pending = positions.get(position);
+            if (!pending) continue;
+            const reversed2 = work(pending.length);
+            if (reversed2) await reversed2;
+            pending.reverse();
+            positions.delete(position);
+            const visited = /* @__PURE__ */ new Set();
+            let stateBytes = 0;
+            const enqueue = (destination2, pc, captures, saveSlot) => {
+              const length = saveSlot === void 0 ? captures.length : Math.max(captures.length, saveSlot + 1);
+              const bytes3 = 64 + length * 8;
+              const waiting = destination2 === position ? pending : positions.get(destination2);
+              storage.reserve(bytes3 + (waiting ? 0 : 64));
+              const saved = saveSlot === void 0 ? captures : [...captures];
+              if (saveSlot !== void 0) saved[saveSlot] = position;
+              const thread = { pc, captures: saved, bytes: bytes3 };
+              if (waiting) waiting.push(thread);
+              else positions.set(destination2, [thread]);
+            };
+            while (pending.length) {
+              const paused = work();
+              if (paused) await paused;
+              const thread = pending.pop();
+              try {
+                let state = thread.pc;
+                let bytes3 = 32;
+                if (this.groupCount) {
+                  const joinedLength = Math.max(0, thread.captures.length - 1) + thread.captures.length * positionDigits;
+                  const stateLength = instructionDigits + 1 + joinedLength;
+                  const serialized2 = work(stateLength);
+                  if (serialized2) await serialized2;
+                  const reserved2 = 32 + joinedLength * 2 + 64 + stateLength * 2;
+                  storage.reserve(reserved2);
+                  state = `${thread.pc}:${thread.captures.join(",")}`;
+                  bytes3 = 64 + state.length * 2;
+                  storage.release(reserved2 - bytes3);
+                } else storage.reserve(bytes3);
+                if (visited.has(state)) {
+                  storage.release(bytes3);
+                  continue;
+                }
+                visited.add(state);
+                stateBytes += bytes3;
+                const instruction = this.code[thread.pc];
+                if (instruction.kind === "character") {
+                  if (position < text3.length && instruction.accepts(text3[position])) enqueue(position + 1, thread.pc + 1, thread.captures);
+                } else if (instruction.kind === "backreference") {
+                  const begin = thread.captures[instruction.index * 2];
+                  const end = thread.captures[instruction.index * 2 + 1];
+                  if (begin === void 0 || end === void 0 || position + end - begin > text3.length) continue;
+                  let matches3 = true;
+                  for (let offset = 0; offset < end - begin; offset++) {
+                    const compared = work();
+                    if (compared) await compared;
+                    const expected = text3[begin + offset];
+                    const actual = text3[position + offset];
+                    if (instruction.ignoreCase ? expected.toLowerCase() !== actual.toLowerCase() : expected !== actual) {
+                      matches3 = false;
+                      break;
+                    }
+                  }
+                  if (matches3) enqueue(position + end - begin, thread.pc + 1, thread.captures);
+                } else if (instruction.kind === "match") {
+                  let preferred2 = bestEnd === void 0 || position > bestEnd;
+                  if (position === bestEnd) for (let index = 1; index <= this.groupCount; index++) {
+                    const compared = work();
+                    if (compared) await compared;
+                    const begin = thread.captures[index * 2];
+                    const end = thread.captures[index * 2 + 1];
+                    const priorBegin = bestCaptures[index * 2];
+                    const priorEnd = bestCaptures[index * 2 + 1];
+                    const length = begin === void 0 || end === void 0 ? -1 : end - begin;
+                    const priorLength = priorBegin === void 0 || priorEnd === void 0 ? -1 : priorEnd - priorBegin;
+                    if (length !== priorLength) {
+                      preferred2 = length > priorLength;
+                      break;
+                    }
+                  }
+                  if (preferred2) {
+                    const retained = 32 + thread.captures.length * 8;
+                    storage.reserve(retained);
+                    bestEnd = position;
+                    bestCaptures = thread.captures;
+                    storage.release(bestBytes);
+                    bestBytes = retained;
+                  }
+                } else if (instruction.kind === "split") {
+                  enqueue(position, instruction.second, thread.captures);
+                  enqueue(position, instruction.first, thread.captures);
+                } else if (instruction.kind === "jump") enqueue(position, instruction.target, thread.captures);
+                else if (instruction.kind === "save") {
+                  const copied = work(Math.max(thread.captures.length, instruction.slot + 1));
+                  if (copied) await copied;
+                  enqueue(position, thread.pc + 1, thread.captures, instruction.slot);
+                } else if (instruction.kind === "begin" ? position === 0 : position === text3.length) enqueue(position, thread.pc + 1, thread.captures);
+              } finally {
+                storage.release(thread.bytes);
               }
             }
-            if (matches3) enqueue(position + end - begin, { pc: thread.pc + 1, captures: thread.captures });
-          } else if (instruction.kind === "match") {
-            if (!best || position > best.end || position === best.end && preferCaptures(thread.captures)) {
-              const groups = [text3.slice(start, position)];
-              for (let index = 1; index <= this.groupCount; index++) {
-                const begin = thread.captures[index * 2];
-                const end = thread.captures[index * 2 + 1];
-                groups.push(begin === void 0 || end === void 0 ? void 0 : text3.slice(begin, end));
-              }
-              best = { start, end: position, groups };
-              bestCaptures = thread.captures;
+            visited.clear();
+            storage.release(stateBytes + 64);
+          }
+          if (bestEnd !== void 0) {
+            let characters = bestEnd - start;
+            for (let index = 1; index <= this.groupCount; index++) {
+              const counted = work();
+              if (counted) await counted;
+              const begin = bestCaptures[index * 2];
+              const end = bestCaptures[index * 2 + 1];
+              if (begin !== void 0 && end !== void 0) characters += end - begin;
             }
-          } else if (instruction.kind === "split") {
-            pending.push({ pc: instruction.second, captures: thread.captures }, { pc: instruction.first, captures: thread.captures });
-          } else if (instruction.kind === "jump") pending.push({ pc: instruction.target, captures: thread.captures });
-          else if (instruction.kind === "save") {
-            const captures = [...thread.captures];
-            captures[instruction.slot] = position;
-            pending.push({ pc: thread.pc + 1, captures });
-          } else if (instruction.kind === "begin" ? position === 0 : position === text3.length) pending.push({ pc: thread.pc + 1, captures: thread.captures });
+            const copied = work(characters);
+            if (copied) await copied;
+            storage.reserve(64 + (this.groupCount + 1) * 40 + characters * 2);
+            const groups = [text3.slice(start, bestEnd)];
+            for (let index = 1; index <= this.groupCount; index++) {
+              const materialized = work();
+              if (materialized) await materialized;
+              const begin = bestCaptures[index * 2];
+              const end = bestCaptures[index * 2 + 1];
+              groups.push(begin === void 0 || end === void 0 ? void 0 : text3.slice(begin, end));
+            }
+            await budget.checkpoint();
+            return { start, end: bestEnd, groups };
+          }
+        } finally {
+          positions.clear();
+          storage.clear();
         }
       }
-      if (best) return best;
+      return void 0;
+    } finally {
+      storage.clear();
     }
-    return void 0;
   }
 };
 async function replacementLength(replacement, match, budget, available2) {
@@ -19149,7 +19295,7 @@ async function substitute(text3, pattern, replacement, budget, global, occurrenc
     while (search <= text3.length) {
       await budget.checkpoint();
       budget.step();
-      const match = pattern.find(text3, budget, search);
+      const match = await pattern.find(text3, budget, search);
       if (!match) break;
       if (match.start === match.end && match.start === previousEnd) {
         search = match.end + 1;
@@ -19482,7 +19628,7 @@ async function execute(program, context2, files, quiet, budget, separator, outpu
         if (terminated) outputState.unterminatedFiles.delete(path);
         else outputState.unterminatedFiles.add(path);
       };
-      const matches3 = async (address) => address.kind === "number" ? number4 === address.number : address.kind === "last" ? (await peekNext()).done === true : getPattern(address.pattern).find(pattern, budget) !== void 0;
+      const matches3 = async (address) => address.kind === "number" ? number4 === 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();
@@ -22920,7 +23066,7 @@ var AwkRuntime = class {
       let search = 0;
       while (search <= value2.length) {
         await this.budget.checkpoint();
-        const match = matcher.find(value2, this.budget, search);
+        const match = await matcher.find(value2, this.budget, search);
         if (!match) break;
         if (match.start === match.end) {
           search = match.end + 1;
@@ -23022,7 +23168,7 @@ var AwkRuntime = class {
       case "string":
         return string(expression.value);
       case "regex":
-        return numeric(expression.pattern.find(this.record, this.budget) ? 1 : 0);
+        return numeric(await expression.pattern.find(this.record, this.budget) ? 1 : 0);
       case "variable":
         return this.get(expression.name);
       case "field":
@@ -23064,7 +23210,7 @@ var AwkRuntime = class {
         if (operator === "&&" && !truth(left)) return numeric(0);
         if (operator === "||" && truth(left)) return numeric(1);
         if (operator === "~" || operator === "!~") {
-          const matched = (await this.regex(expression.right)).find(this.asText(left), this.budget) !== void 0;
+          const matched = await (await this.regex(expression.right)).find(this.asText(left), this.budget) !== void 0;
           return numeric((operator === "~" ? matched : !matched) ? 1 : 0);
         }
         const right = await this.scalarExpression(expression.right);
@@ -23206,7 +23352,7 @@ var AwkRuntime = class {
     }
     if (name2 === "match") {
       const value2 = this.asText(await this.scalarExpression(args[0]));
-      const matched = (await this.regex(args[1])).find(value2, this.budget);
+      const matched = await (await this.regex(args[1])).find(value2, this.budget);
       this.set("RSTART", numeric(matched ? matched.start + 1 : 0));
       this.set("RLENGTH", numeric(matched ? matched.end - matched.start : -1));
       return this.get("RSTART");
@@ -23684,6 +23830,7 @@ var Budget8 = class {
   signal;
   steps = 0;
   nextYield = 1024;
+  lastYield = monotonicNow();
   inputBytes = 0;
   outputBytes = 0;
   results = 0;
@@ -23693,12 +23840,13 @@ var Budget8 = class {
     this.steps += count2;
     if (this.steps > this.limits.maxSteps) throw new JqLimitError("maxSteps");
   }
-  async tick() {
-    this.step();
-    if (this.steps >= this.nextYield) {
-      this.nextYield = this.steps + 1024;
+  async tick(count2 = 1) {
+    this.step(count2);
+    if (this.steps >= this.nextYield || monotonicNow() - this.lastYield >= 25) {
       await yieldTurn(this.signal);
       this.signal.throwIfAborted();
+      this.nextYield = this.steps + 1024;
+      this.lastYield = monotonicNow();
     }
   }
   collection(size) {
@@ -23747,6 +23895,11 @@ function object() {
 function objectKeys(value2) {
   return keyOrders.get(value2)?.slice() ?? Object.keys(value2);
 }
+function* objectKeyIterator(value2) {
+  const keys = keyOrders.get(value2);
+  if (keys) yield* keys;
+  else for (const key in value2) if (Object.hasOwn(value2, key)) yield key;
+}
 function objectSize(value2) {
   return keyOrders.get(value2)?.length ?? Object.keys(value2).length;
 }
@@ -24261,36 +24414,83 @@ function describe(value2, budget) {
   const text3 = bytes3.length < 15 ? bytes3.toString() : `${bytes3.subarray(0, 11).toString()}...`;
   return `${type(value2)} (${text3})`;
 }
-function stringCompare(left, right) {
-  const leftPoints = Array.from(left, (character) => character.codePointAt(0));
-  const rightPoints = Array.from(right, (character) => character.codePointAt(0));
-  for (let index = 0; index < Math.min(leftPoints.length, rightPoints.length); index++) {
-    if (leftPoints[index] !== rightPoints[index]) return leftPoints[index] < rightPoints[index] ? -1 : 1;
+async function stringCompare(left, right, budget) {
+  await budget.tick(1 + Math.ceil(Math.min(left.length, right.length) / 32));
+  let leftOffset = 0;
+  let rightOffset = 0;
+  let points = 0;
+  while (leftOffset < left.length && rightOffset < right.length) {
+    if (points++ % 32 === 0) await budget.tick(0);
+    const leftPoint = left.codePointAt(leftOffset);
+    const rightPoint = right.codePointAt(rightOffset);
+    if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
+    leftOffset += leftPoint > 65535 ? 2 : 1;
+    rightOffset += rightPoint > 65535 ? 2 : 1;
+  }
+  return leftOffset < left.length ? 1 : rightOffset < right.length ? -1 : 0;
+}
+async function stableSort(items, budget, comparator) {
+  await budget.tick(0);
+  budget.collection(items.length);
+  if (items.length < 2) return;
+  await budget.tick(items.length);
+  const scratch = new Array(items.length);
+  let source2 = items;
+  let target = scratch;
+  for (let width = 1; width < items.length; width *= 2) {
+    for (let start = 0; start < items.length; start += width * 2) {
+      const middle = Math.min(start + width, items.length);
+      const end = Math.min(start + width * 2, items.length);
+      let left = start;
+      let right = middle;
+      for (let index = start; index < end; index++) {
+        await budget.tick();
+        if (left < middle && (right >= end || await comparator(source2[left], source2[right]) <= 0)) target[index] = source2[left++];
+        else target[index] = source2[right++];
+      }
+    }
+    const previous = source2;
+    source2 = target;
+    target = previous;
+  }
+  if (source2 !== items) for (let index = 0; index < items.length; index++) {
+    await budget.tick();
+    items[index] = source2[index];
+  }
+}
+async function sortedKeys(value2, budget) {
+  await budget.tick(0);
+  const keys = [];
+  for (const key of objectKeyIterator(value2)) {
+    await budget.tick();
+    budget.collection(keys.length + 1);
+    keys.push(key);
   }
-  return Math.sign(leftPoints.length - rightPoints.length);
+  await stableSort(keys, budget, (left, right) => stringCompare(left, right, budget));
+  return keys;
 }
-function compare2(left, right, budget) {
-  budget.step();
+async function compare2(left, right, budget) {
+  await budget.tick();
   const rank2 = (value2) => value2 === null ? 0 : value2 === false ? 1 : value2 === true ? 2 : isNumber(value2) ? 3 : typeof value2 === "string" ? 4 : Array.isArray(value2) ? 5 : 6;
   const difference = rank2(left) - rank2(right);
   if (difference) return Math.sign(difference);
   if (isNumber(left) && isNumber(right)) return compareNumbers(left, right, budget);
+  if (typeof left === "string" && typeof right === "string") return stringCompare(left, right, budget);
   if (left === right && !Array.isArray(left) && !isObject(left)) return 0;
-  if (typeof left === "string" && typeof right === "string") return stringCompare(left, right);
   if (Array.isArray(left) && Array.isArray(right)) {
     for (let index = 0; index < Math.min(left.length, right.length); index++) {
-      const result2 = compare2(left[index], right[index], budget);
+      const result2 = await compare2(left[index], right[index], budget);
       if (result2) return result2;
     }
     return Math.sign(left.length - right.length);
   }
   if (isObject(left) && isObject(right)) {
-    const keys = objectKeys(left).sort(stringCompare);
-    const otherKeys = objectKeys(right).sort(stringCompare);
-    const keyDifference = compare2(keys, otherKeys, budget);
+    const keys = await sortedKeys(left, budget);
+    const otherKeys = await sortedKeys(right, budget);
+    const keyDifference = await compare2(keys, otherKeys, budget);
     if (keyDifference) return keyDifference;
     for (const key of keys) {
-      const result2 = compare2(left[key], right[key], budget);
+      const result2 = await compare2(left[key], right[key], budget);
       if (result2) return result2;
     }
   }
@@ -24367,12 +24567,12 @@ function contains(value2, sought, budget) {
   if (isObject(value2) && isObject(sought)) return objectKeys(sought).every((key) => Object.hasOwn(value2, key) && contains(value2[key], sought[key], budget));
   return type(value2) === type(sought) && equal(value2, sought, budget);
 }
-function binary(operator, left, right, budget) {
+async function binary(operator, left, right, budget) {
   budget.step();
   if (["==", "!=", "<", "<=", ">", ">="].includes(operator)) {
     if (operator === "==") return equal(left, right, budget);
     if (operator === "!=") return !equal(left, right, budget);
-    const order = compare2(left, right, budget);
+    const order = await compare2(left, right, budget);
     switch (operator) {
       case "<":
         return order < 0;
@@ -24409,7 +24609,7 @@ function binary(operator, left, right, budget) {
     const result2 = copyObject(left);
     for (const key of objectKeys(right)) {
       const value2 = right[key];
-      put(result2, key, Object.hasOwn(left, key) && isObject(left[key]) && isObject(value2) ? binary("*", left[key], value2, budget) : value2);
+      put(result2, key, Object.hasOwn(left, key) && isObject(left[key]) && isObject(value2) ? await binary("*", left[key], value2, budget) : value2);
     }
     budget.collection(objectKeys(result2).length);
     return result2;
@@ -24626,7 +24826,7 @@ var Interpreter = class _Interpreter {
         }
         for await (const right of this.run(ast.right, input3)) {
           for await (const left of this.run(ast.left, input3)) {
-            const result2 = binary(operator, left, right, this.budget);
+            const result2 = await binary(operator, left, right, this.budget);
             this.budget.value(result2);
             yield result2;
           }
@@ -24731,7 +24931,7 @@ var Interpreter = class _Interpreter {
         for await (const path of this.paths(left, input3)) {
           let previous = result3;
           for (const key of path) previous = indexValue(previous, key);
-          const assigned = operator === "=" ? value2 : operator === "//=" ? truth2(previous) ? previous : value2 : binary(operator.slice(0, -1), previous, value2, this.budget);
+          const assigned = operator === "=" ? value2 : operator === "//=" ? truth2(previous) ? previous : value2 : await binary(operator.slice(0, -1), previous, value2, this.budget);
           result3 = this.set(result3, path, assigned);
           this.budget.value(result3);
         }
@@ -24760,10 +24960,10 @@ var Interpreter = class _Interpreter {
         this.budget.value(result2);
       }
     }
-    deletions.sort((first, second) => -compare2(first, second, this.budget));
+    await stableSort(deletions, this.budget, async (first, second) => -await compare2(first, second, this.budget));
     let lastDeletion;
     for (const path of deletions) {
-      if (!lastDeletion || compare2(lastDeletion, path, this.budget) !== 0) result2 = this.set(result2, path, deleted);
+      if (!lastDeletion || await compare2(lastDeletion, path, this.budget) !== 0) result2 = this.set(result2, path, deleted);
       lastDeletion = path;
     }
     this.budget.value(result2);
@@ -24821,7 +25021,7 @@ var Interpreter = class _Interpreter {
     }
     if (name2 === "keys" || name2 === "keys_unsorted") {
       if (Array.isArray(input3)) yield input3.map((_, index) => index);
-      else if (isObject(input3)) yield name2 === "keys" ? objectKeys(input3).sort(stringCompare) : objectKeys(input3);
+      else if (isObject(input3)) yield name2 === "keys" ? await sortedKeys(input3, budget) : objectKeys(input3);
       else throw new JqError("keys requires an object or array");
       return;
     }
@@ -24873,12 +25073,12 @@ var Interpreter = class _Interpreter {
         for (const [, item] of entries(input3, budget)) {
           await budget.tick();
           if (!first && separator !== null) {
-            if (typeof separator !== "string") binary("+", result2, separator, budget);
+            if (typeof separator !== "string") await binary("+", result2, separator, budget);
             if (typeof separator !== "string") throw new JqError("join separator must be a string or null when used");
             append(separator, separatorBytes);
           }
           first = false;
-          if (isObject(item) || Array.isArray(item)) binary("+", result2, item, budget);
+          if (isObject(item) || Array.isArray(item)) await binary("+", result2, item, budget);
           const text3 = item === null ? "" : typeof item === "string" ? item : stringify(item, budget);
           append(text3, budget.value(text3));
         }
@@ -25016,7 +25216,7 @@ var Interpreter = class _Interpreter {
       let result2 = null;
       for (const item of input3) {
         await budget.tick();
-        result2 = binary("+", result2, item, budget);
+        result2 = await binary("+", result2, item, budget);
         budget.value(result2);
       }
       yield result2;
@@ -25031,7 +25231,7 @@ var Interpreter = class _Interpreter {
       if (keyBytes2 > budget.limits.maxValueBytes) throw new JqLimitError("maxValueBytes");
       keyed.push({ value: value2, key });
     }
-    keyed.sort((left, right) => compare2(left.key, right.key, budget));
+    await stableSort(keyed, budget, (left, right) => compare2(left.key, right.key, budget));
     if (name2 === "min" || name2 === "min_by" || name2 === "max" || name2 === "max_by") {
       yield keyed[name2.startsWith("min") ? 0 : keyed.length - 1]?.value ?? null;
       return;
@@ -32014,7 +32214,7 @@ function createNlCommand(limits) {
           if (numbered) blanks = 0;
         } else if (current === "t") numbered = record4.length > 0;
         else if (current === "n") numbered = false;
-        else numbered = current.find(bytes3.toString("latin1"), budget) !== void 0;
+        else numbered = await current.find(bytes3.toString("latin1"), budget) !== void 0;
         if (numbered) {
           if (number4 < -(1n << 63n) || number4 >= 1n << 63n) throw new UsageError("line number overflow");
           let label = number4.toString();