@poe-platform/safe-bash 0.1.81 → 0.1.83

package/dist/safe-bash/browser.js

@@ -2623,6 +2623,69 @@ var predicateRequirements = [
   { id: "access", description: "Inspect path access permissions", capabilities: ["access"] }
 ];
 
+// packages/safe-bash/src/commands/record-buffer.ts
+init_platform();
+var segmentSize = 4096;
+var RecordBuffer = class {
+  constructor(capacity, finalizationCapacity = capacity * 2) {
+    this.capacity = capacity;
+    this.finalizationCapacity = finalizationCapacity;
+  }
+  capacity;
+  finalizationCapacity;
+  #segments = [];
+  #size = 0;
+  #allocated = 0;
+  get size() {
+    return this.#size;
+  }
+  #admit(length) {
+    if (length > this.capacity - this.#size) {
+      throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
+    }
+  }
+  append(bytes2, start = 0, end = bytes2.length) {
+    this.#admit(end - start);
+    let offset = start;
+    while (offset < end) {
+      let segment = this.#segments.at(-1);
+      const used = this.#size % segmentSize;
+      if (!segment || used === 0) {
+        segment = new Uint8Array(Math.min(segmentSize, this.capacity - this.#allocated));
+        this.#segments.push(segment);
+        this.#allocated += segment.length;
+      }
+      const length = Math.min(end - offset, segment.length - used);
+      segment.set(bytes2.subarray(offset, offset + length), used);
+      this.#size += length;
+      offset += length;
+    }
+  }
+  finish(admit2, bytes2, start = 0, end = bytes2?.length ?? 0) {
+    this.#admit(end - start);
+    const size = this.#size + end - start;
+    admit2?.(size);
+    if (size > this.finalizationCapacity - this.#allocated) {
+      throw new FsError("EFBIG", { message: "line finalization buffer limit exceeded" });
+    }
+    const result = new Uint8Array(size);
+    let offset = 0;
+    for (const segment of this.#segments) {
+      const length = Math.min(segment.length, this.#size - offset);
+      result.set(segment.subarray(0, length), offset);
+      offset += length;
+    }
+    if (bytes2 && end > start) result.set(bytes2.subarray(start, end), offset);
+    this.clear();
+    return result;
+  }
+  clear() {
+    this.#segments = [];
+    this.#size = 0;
+    this.#allocated = 0;
+  }
+};
+
 // packages/safe-bash/src/commands/internal.ts
 var encoder2 = new TextEncoder();
 var decoder2 = new TextDecoder();
@@ -2796,29 +2859,22 @@ function concatenate(chunks, size = chunks.reduce((sum, chunk) => sum + chunk.le
   }
   return result;
 }
-async function* lines(source, separator = 10) {
-  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] !== separator) continue;
-      const part = chunk.slice(start, offset);
-      size += part.length;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-      pending.push(part);
-      yield { bytes: concatenate(pending, size), terminated: true };
-      pending = [];
-      size = 0;
-      start = offset + 1;
-    }
-    if (start < chunk.length) {
-      pending.push(new Uint8Array(chunk.subarray(start)));
-      size += chunk.length - start;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
+async function* lines(source, separator = 10, admit2) {
+  const pending = new RecordBuffer(bufferLimit);
+  try {
+    for await (const chunk of source) {
+      let start = 0;
+      for (let offset = 0; offset < chunk.length; offset++) {
+        if (chunk[offset] !== separator) continue;
+        yield { bytes: pending.finish(admit2, chunk, start, offset), terminated: true };
+        start = offset + 1;
+      }
+      pending.append(chunk, start);
     }
+    if (pending.size) yield { bytes: pending.finish(admit2), terminated: false };
+  } finally {
+    pending.clear();
   }
-  if (size) yield { bytes: concatenate(pending, size), terminated: false };
 }
 function emptyInput() {
   return toByteSource("");
@@ -4653,6 +4709,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,31 +4994,28 @@ 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) {
-  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;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-      if (pending.length) {
-        pending.push(part);
-        accept(concatenate(pending, size));
-      } else accept(new Uint8Array(part));
-      pending = [];
-      size = 0;
-      start = offset + 1;
-    }
-    if (start < chunk.length) {
-      pending.push(new Uint8Array(chunk.subarray(start)));
-      size += chunk.length - start;
-      if (size > bufferLimit) throw new FsError("EFBIG", { message: "line buffer limit exceeded" });
-    }
-  }
-  if (size) accept(concatenate(pending, size));
+async function collectSortRecords(source, delimiter, budget, signal, accept) {
+  const pending = new RecordBuffer(bufferLimit);
+  const admit2 = (length) => {
+    signal.throwIfAborted();
+    budget.admit(length);
+  };
+  try {
+    for await (const chunk of source) {
+      let start = 0;
+      for (let offset = 0; offset < chunk.length; offset++) {
+        if (chunk[offset] !== delimiter) continue;
+        const accepted = accept(pending.finish(admit2, chunk, start, offset));
+        if ((accepted instanceof Promise ? await accepted : accepted) === false) return false;
+        start = offset + 1;
+      }
+      pending.append(chunk, start);
+    }
+    if (pending.size) return await accept(pending.finish(admit2)) !== false;
+    return true;
+  } finally {
+    pending.clear();
+  }
 }
 function textCommands() {
   return [
@@ -5037,30 +5107,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 };
@@ -5215,7 +5281,7 @@ function textCommands() {
                 if (start >= 0) await writer.write(line.bytes.subarray(start, end));
               }
             } else {
-              const decoder3 = new TextDecoder();
+              const decoder3 = new TextDecoder("utf-8", { ignoreBOM: true });
               let index = 0;
               let emitted = false;
               let previousIncluded = false;