@poe-platform/safe-bash 0.1.81 → 0.1.82

package/dist/safe-bash/browser.js

@@ -4653,6 +4653,23 @@ function streamCommands() {
 
 // packages/safe-bash/src/commands/text.ts
 init_platform();
+
+// packages/safe-bash/src/commands/sort-admission.ts
+init_platform();
+var SortRecordBudget = class {
+  #records = 0;
+  #bytes = 0;
+  admit(byteLength2) {
+    const bytes2 = byteLength2 + 1;
+    if (this.#records >= 1e5 || bytes2 > bufferLimit - this.#bytes) {
+      throw new FsError("EFBIG", { message: "sort buffer limit exceeded" });
+    }
+    this.#records++;
+    this.#bytes += bytes2;
+  }
+};
+
+// packages/safe-bash/src/commands/text.ts
 var SortWork = class {
   constructor(signal) {
     this.signal = signal;
@@ -4921,20 +4938,25 @@ async function emitRecords(context, records, destination) {
     await context.fs.writeFile(pathOf(context, destination), concatenate(chunks, size), { signal: context.signal });
   }
 }
-async function collectSortRecords(source, delimiter, accept) {
+async function collectSortRecords(source, delimiter, budget, signal, accept) {
   let pending = [];
   let size = 0;
   for await (const chunk of source) {
     let start = 0;
     for (let offset = 0; offset < chunk.length; offset++) {
       if (chunk[offset] !== delimiter) continue;
-      const part = chunk.subarray(start, offset);
-      size += part.length;
+      size += offset - start;
       if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
+      signal.throwIfAborted();
+      budget.admit(size);
+      const part = chunk.subarray(start, offset);
+      let record4;
       if (pending.length) {
         pending.push(part);
-        accept(concatenate(pending, size));
-      } else accept(new Uint8Array(part));
+        record4 = concatenate(pending, size);
+      } else record4 = new Uint8Array(part);
+      const accepted = accept(record4);
+      if ((accepted instanceof Promise ? await accepted : accepted) === false) return false;
       pending = [];
       size = 0;
       start = offset + 1;
@@ -4945,7 +4967,12 @@ async function collectSortRecords(source, delimiter, accept) {
       if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
     }
   }
-  if (size) accept(concatenate(pending, size));
+  if (size) {
+    signal.throwIfAborted();
+    budget.admit(size);
+    return await accept(concatenate(pending, size)) !== false;
+  }
+  return true;
 }
 function textCommands() {
   return [
@@ -5037,30 +5064,26 @@ function textCommands() {
         return result || (simple || parsed.flags.has("s") || parsed.flags.has("u") ? 0 : await compareSortBytes(left, right, work) * direction);
       };
       const records = [];
-      let size = 0;
+      const recordBudget = new SortRecordBudget();
       const exitCode = 0;
       const delimiter = parsed.flags.has("z") ? 0 : 10;
       for (const name2 of parsed.operands.length ? parsed.operands : ["-"]) {
         try {
-          if (!parsed.flags.has("c")) {
-            await collectSortRecords(input(context, name2), delimiter, (bytes2) => {
-              context.signal.throwIfAborted();
-              size += bytes2.length + 1;
-              if (size > bufferLimit) throw new FsError("EFBIG", { message: "sort buffer limit exceeded" });
-              records.push(bytes2);
-            });
-            continue;
-          }
-          for await (const line of lines(input(context, name2), delimiter)) {
+          const complete2 = await collectSortRecords(input(context, name2), delimiter, recordBudget, context.signal, (bytes2) => {
             context.signal.throwIfAborted();
-            size += line.bytes.length + 1;
-            if (size > bufferLimit) throw new FsError("EFBIG", { message: "sort buffer limit exceeded" });
-            if (parsed.flags.has("c") && records.length && (await compare(records.at(-1), line.bytes) > 0 || parsed.flags.has("u") && await keyCompare(records.at(-1), line.bytes) === 0)) {
-              await diagnostic(context, new Error(`disorder at record ${records.length + 1}`));
-              return { exitCode: 1 };
+            if (!parsed.flags.has("c")) {
+              records.push(bytes2);
+              return;
             }
-            records.push(line.bytes);
-          }
+            return (async () => {
+              if (records.length && (await compare(records.at(-1), bytes2) > 0 || parsed.flags.has("u") && await keyCompare(records.at(-1), bytes2) === 0)) {
+                await diagnostic(context, new Error(`disorder at record ${records.length + 1}`));
+                return false;
+              }
+              records.push(bytes2);
+            })();
+          });
+          if (!complete2) return { exitCode: 1 };
         } catch (error) {
           await diagnostic(context, error);
           return { exitCode: 2 };