@cueframe/kernel 0.0.1 → 0.1.1

package/dist/nle-export/server.js

@@ -74,9 +74,9 @@ var require_balanced_match = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/brace-expansion@2.0.2/node_modules/brace-expansion/index.js
+// ../../node_modules/.pnpm/brace-expansion@2.1.4/node_modules/brace-expansion/index.js
 var require_brace_expansion = __commonJS({
-  "../../node_modules/.pnpm/brace-expansion@2.0.2/node_modules/brace-expansion/index.js"(exports, module) {
+  "../../node_modules/.pnpm/brace-expansion@2.1.4/node_modules/brace-expansion/index.js"(exports, module) {
     "use strict";
     var balanced = require_balanced_match();
     module.exports = expandTop;
@@ -85,6 +85,8 @@ var require_brace_expansion = __commonJS({
     var escClose = "\0CLOSE" + Math.random() + "\0";
     var escComma = "\0COMMA" + Math.random() + "\0";
     var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    var EXPANSION_MAX = 1e5;
+    var EXPANSION_MAX_LENGTH = 4e6;
     function numeric(str) {
       return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
     }
@@ -114,13 +116,16 @@ var require_brace_expansion = __commonJS({
       parts.push.apply(parts, p);
       return parts;
     }
-    function expandTop(str) {
+    function expandTop(str, options) {
       if (!str)
         return [];
+      options = options || {};
+      var max = options.max == null ? EXPANSION_MAX : options.max;
+      var maxLength = options.maxLength == null ? EXPANSION_MAX_LENGTH : options.maxLength;
       if (str.substr(0, 2) === "{}") {
         str = "\\{\\}" + str.substr(2);
       }
-      return expand(escapeBraces(str), true).map(unescapeBraces);
+      return expand(escapeBraces(str), max, maxLength, true).map(unescapeBraces);
     }
     function embrace(str) {
       return "{" + str + "}";
@@ -134,18 +139,90 @@ var require_brace_expansion = __commonJS({
     function gte(i, y) {
       return i >= y;
     }
-    function expand(str, isTop) {
-      var expansions = [];
-      var m = balanced("{", "}", str);
-      if (!m) return [str];
-      var pre = m.pre;
-      var post = m.post.length ? expand(m.post, false) : [""];
-      if (/\$$/.test(m.pre)) {
-        for (var k = 0; k < post.length; k++) {
-          var expansion = pre + "{" + m.body + "}" + post[k];
-          expansions.push(expansion);
+    function combine(acc, pre, values, max, maxLength, dropEmpties) {
+      var out = [];
+      var length = 0;
+      for (var a = 0; a < acc.length; a++) {
+        for (var v = 0; v < values.length; v++) {
+          if (out.length >= max) return out;
+          var expansion = acc[a] + pre + values[v];
+          if (dropEmpties && !expansion) continue;
+          if (length + expansion.length > maxLength) return out;
+          out.push(expansion);
+          length += expansion.length;
+        }
+      }
+      return out;
+    }
+    function expandSequence(body, isAlphaSequence, max, maxLength) {
+      var n = body.split(/\.\./);
+      var N = [];
+      if (n[0] === void 0 || n[1] === void 0) {
+        return N;
+      }
+      var x = numeric(n[0]);
+      var y = numeric(n[1]);
+      var width = Math.max(n[0].length, n[1].length);
+      var incr = n.length === 3 && n[2] !== void 0 ? Math.max(Math.abs(numeric(n[2])), 1) : 1;
+      var test = lte;
+      var reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      var pad = n.some(isPadded);
+      var length = 0;
+      for (var i = x; test(i, y) && N.length < max; i += incr) {
+        var c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            var need = width - c.length;
+            if (need > 0) {
+              var z = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        if (length + c.length > maxLength) break;
+        N.push(c);
+        length += c.length;
+      }
+      return N;
+    }
+    function expand(str, max, maxLength, isTop) {
+      var acc = [""];
+      var dropEmpties = false;
+      var firstGroup = true;
+      for (; ; ) {
+        const m = balanced("{", "}", str);
+        if (!m) {
+          return combine(acc, str, [""], max, maxLength, dropEmpties);
+        }
+        const pre = m.pre;
+        if (/\$$/.test(pre)) {
+          acc = combine(
+            acc,
+            pre + "{" + m.body + "}",
+            [""],
+            max,
+            maxLength,
+            dropEmpties && !m.post.length
+          );
+          firstGroup = false;
+          if (!m.post.length) break;
+          str = m.post;
+          continue;
         }
-      } else {
         var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
         var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
         var isSequence = isNumericSequence || isAlphaSequence;
@@ -153,74 +230,69 @@ var require_brace_expansion = __commonJS({
         if (!isSequence && !isOptions) {
           if (m.post.match(/,(?!,).*\}/)) {
             str = m.pre + "{" + m.body + escClose + m.post;
-            return expand(str);
+            isTop = true;
+            continue;
           }
-          return [str];
+          return combine(
+            acc,
+            pre + "{" + m.body + "}" + m.post,
+            [""],
+            max,
+            maxLength,
+            dropEmpties
+          );
         }
-        var n;
+        if (firstGroup) {
+          dropEmpties = isTop && !isSequence;
+          firstGroup = false;
+        }
+        var values;
         if (isSequence) {
-          n = m.body.split(/\.\./);
+          values = expandSequence(m.body, isAlphaSequence, max, maxLength);
         } else {
-          n = parseCommaParts(m.body);
-          if (n.length === 1) {
-            n = expand(n[0], false).map(embrace);
+          var n = parseCommaParts(m.body);
+          if (n.length === 1 && n[0] !== void 0) {
+            n = expand(n[0], max, maxLength, false).map(embrace);
             if (n.length === 1) {
-              return post.map(function(p) {
-                return m.pre + n[0] + p;
-              });
+              acc = combine(
+                acc,
+                pre + n[0],
+                [""],
+                max,
+                maxLength,
+                dropEmpties && !m.post.length
+              );
+              if (!m.post.length) break;
+              str = m.post;
+              continue;
             }
           }
-        }
-        var N;
-        if (isSequence) {
-          var x = numeric(n[0]);
-          var y = numeric(n[1]);
-          var width = Math.max(n[0].length, n[1].length);
-          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-          var test = lte;
-          var reverse = y < x;
-          if (reverse) {
-            incr *= -1;
-            test = gte;
-          }
-          var pad = n.some(isPadded);
-          N = [];
-          for (var i = x; test(i, y); i += incr) {
-            var c;
-            if (isAlphaSequence) {
-              c = String.fromCharCode(i);
-              if (c === "\\")
-                c = "";
-            } else {
-              c = String(i);
-              if (pad) {
-                var need = width - c.length;
-                if (need > 0) {
-                  var z = new Array(need + 1).join("0");
-                  if (i < 0)
-                    c = "-" + z + c.slice(1);
-                  else
-                    c = z + c;
-                }
-              }
+          var dropsEmpties = dropEmpties && !m.post.length && !pre;
+          for (var d = 0; dropsEmpties && d < acc.length; d++) {
+            if (acc[d]) {
+              dropsEmpties = false;
             }
-            N.push(c);
           }
-        } else {
-          N = [];
-          for (var j = 0; j < n.length; j++) {
-            N.push.apply(N, expand(n[j], false));
-          }
-        }
-        for (var j = 0; j < N.length; j++) {
-          for (var k = 0; k < post.length; k++) {
-            var expansion = pre + N[j] + post[k];
-            if (!isTop || isSequence || expansion)
-              expansions.push(expansion);
+          values = [];
+          var valuesLength = 0;
+          outer: for (var j = 0; j < n.length; j++) {
+            var expanded = expand(n[j], max, maxLength, false);
+            for (var k = 0; k < expanded.length; k++) {
+              var v = expanded[k];
+              if (dropsEmpties && !v) continue;
+              if (values.length >= max || valuesLength + v.length > maxLength) {
+                break outer;
+              }
+              values.push(v);
+              valuesLength += v.length;
+            }
           }
         }
+        acc = combine(acc, pre, values, max, maxLength, dropEmpties && !m.post.length);
+        if (!m.post.length) break;
+        str = m.post;
       }
-      return expansions;
+      return acc;
     }
   }
 });
@@ -22844,9 +22916,9 @@ var require_fast_fifo = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/b4a@1.8.0/node_modules/b4a/index.js
+// ../../node_modules/.pnpm/b4a@1.8.1/node_modules/b4a/index.js
 var require_b4a = __commonJS({
-  "../../node_modules/.pnpm/b4a@1.8.0/node_modules/b4a/index.js"(exports, module) {
+  "../../node_modules/.pnpm/b4a@1.8.1/node_modules/b4a/index.js"(exports, module) {
     "use strict";
     function isBuffer(value) {
       return Buffer.isBuffer(value) || value instanceof Uint8Array;
@@ -23235,15 +23307,57 @@ var require_text_decoder = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/streamx@2.23.0/node_modules/streamx/index.js
+// ../../node_modules/.pnpm/streamx@2.28.1/node_modules/streamx/lib/errors.js
+var require_errors2 = __commonJS({
+  "../../node_modules/.pnpm/streamx@2.28.1/node_modules/streamx/lib/errors.js"(exports, module) {
+    "use strict";
+    module.exports = class StreamError extends Error {
+      constructor(msg, code, fn = StreamError) {
+        super(msg);
+        this.code = code;
+        if (Error.captureStackTrace) {
+          Error.captureStackTrace(this, fn);
+        }
+      }
+      static isStreamDestroyed(err) {
+        return err && err.code === "STREAM_DESTROYED";
+      }
+      static isPrematureClose(err) {
+        return err && err.code === "PREMATURE_CLOSE";
+      }
+      static isAborted(err) {
+        return err && err.code === "ABORTED";
+      }
+      static isBadArgument(err) {
+        return err && err.code === "BAD_ARGUMENT";
+      }
+      get name() {
+        return "StreamError";
+      }
+      static STREAM_DESTROYED() {
+        return new StreamError("Stream was destroyed", "STREAM_DESTROYED", StreamError.STREAM_DESTROYED);
+      }
+      static PREMATURE_CLOSE(msg = "Premature close") {
+        return new StreamError(msg, "PREMATURE_CLOSE", StreamError.PREMATURE_CLOSE);
+      }
+      static ABORTED() {
+        return new StreamError("Stream aborted", "ABORTED", StreamError.ABORTED);
+      }
+      static BAD_ARGUMENT(msg = "Bad argument") {
+        return new StreamError(msg, "BAD_ARGUMENT", StreamError.BAD_ARGUMENT);
+      }
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/streamx@2.28.1/node_modules/streamx/index.js
 var require_streamx = __commonJS({
-  "../../node_modules/.pnpm/streamx@2.23.0/node_modules/streamx/index.js"(exports, module) {
+  "../../node_modules/.pnpm/streamx@2.28.1/node_modules/streamx/index.js"(exports, module) {
     "use strict";
     var { EventEmitter } = require_default();
-    var STREAM_DESTROYED = new Error("Stream was destroyed");
-    var PREMATURE_CLOSE = new Error("Premature close");
     var FIFO = require_fast_fifo();
     var TextDecoder = require_text_decoder();
+    var StreamError = require_errors2();
     var qmt = typeof queueMicrotask === "undefined" ? (fn) => global.process.nextTick(fn) : queueMicrotask;
     var MAX = (1 << 29) - 1;
     var OPENING = 1;
@@ -23346,6 +23460,9 @@ var require_streamx = __commonJS({
         this.afterWrite = afterWrite.bind(this);
         this.afterUpdateNextTick = updateWriteNT.bind(this);
       }
+      get ending() {
+        return (this.stream._duplexState & WRITE_FINISHING) !== 0;
+      }
       get ended() {
         return (this.stream._duplexState & WRITE_DONE) !== 0;
       }
@@ -23368,8 +23485,11 @@ var require_streamx = __commonJS({
         return data;
       }
       end(data) {
-        if (typeof data === "function") this.stream.once("finish", data);
-        else if (data !== void 0 && data !== null) this.push(data);
+        if (typeof data === "function") {
+          this.stream.once("finish", data);
+        } else if (data !== void 0 && data !== null) {
+          this.push(data);
+        }
         this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
       }
       autoBatch(data, cb) {
@@ -23420,8 +23540,11 @@ var require_streamx = __commonJS({
         return true;
       }
       updateCallback() {
-        if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) this.update();
-        else this.updateNextTick();
+        if ((this.stream._duplexState & WRITE_UPDATE_SYNC_STATUS) === WRITE_PRIMARY) {
+          this.update();
+        } else {
+          this.updateNextTick();
+        }
       }
       updateNextTick() {
         if ((this.stream._duplexState & WRITE_NEXT_TICK) !== 0) return;
@@ -23444,11 +23567,14 @@ var require_streamx = __commonJS({
         this.afterRead = afterRead.bind(this);
         this.afterUpdateNextTick = updateReadNT.bind(this);
       }
+      get ending() {
+        return (this.stream._duplexState & READ_ENDING) !== 0;
+      }
       get ended() {
         return (this.stream._duplexState & READ_DONE) !== 0;
       }
       pipe(pipeTo, cb) {
-        if (this.pipeTo !== null) throw new Error("Can only pipe to one destination");
+        if (this.pipeTo !== null) throw StreamError.BAD_ARGUMENT("Can only pipe to one destination");
         if (typeof cb !== "function") cb = null;
         this.stream._duplexState |= READ_PIPE_DRAINED;
         this.pipeTo = pipeTo;
@@ -23491,7 +23617,9 @@ var require_streamx = __commonJS({
       shift() {
         const data = this.queue.shift();
         this.buffered -= this.byteLength(data);
-        if (this.buffered === 0) this.stream._duplexState &= READ_NOT_QUEUED;
+        if (this.buffered === 0) {
+          this.stream._duplexState &= READ_NOT_QUEUED;
+        }
         return data;
       }
       unshift(data) {
@@ -23508,8 +23636,12 @@ var require_streamx = __commonJS({
         const stream = this.stream;
         if ((stream._duplexState & READ_STATUS) === READ_QUEUED) {
           const data = this.shift();
-          if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
-          if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
+          if (this.pipeTo !== null && this.pipeTo.write(data) === false) {
+            stream._duplexState &= READ_PIPE_NOT_DRAINED;
+          }
+          if ((stream._duplexState & READ_EMIT_DATA) !== 0) {
+            stream.emit("data", data);
+          }
           return data;
         }
         if (this.readAhead === false) {
@@ -23522,8 +23654,12 @@ var require_streamx = __commonJS({
         const stream = this.stream;
         while ((stream._duplexState & READ_STATUS) === READ_QUEUED && (stream._duplexState & READ_FLOWING) !== 0) {
           const data = this.shift();
-          if (this.pipeTo !== null && this.pipeTo.write(data) === false) stream._duplexState &= READ_PIPE_NOT_DRAINED;
-          if ((stream._duplexState & READ_EMIT_DATA) !== 0) stream.emit("data", data);
+          if (this.pipeTo !== null && this.pipeTo.write(data) === false) {
+            stream._duplexState &= READ_PIPE_NOT_DRAINED;
+          }
+          if ((stream._duplexState & READ_EMIT_DATA) !== 0) {
+            stream.emit("data", data);
+          }
         }
       }
       update() {
@@ -23540,7 +23676,9 @@ var require_streamx = __commonJS({
             stream._duplexState |= READ_EMITTED_READABLE;
             stream.emit("readable");
           }
-          if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) this.updateNonPrimary();
+          if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0) {
+            this.updateNonPrimary();
+          }
         } while (this.continueUpdate() === true);
         stream._duplexState &= READ_NOT_UPDATING;
       }
@@ -23549,8 +23687,12 @@ var require_streamx = __commonJS({
         if ((stream._duplexState & READ_ENDING_STATUS) === READ_ENDING) {
           stream._duplexState = (stream._duplexState | READ_DONE) & READ_NOT_ENDING;
           stream.emit("end");
-          if ((stream._duplexState & AUTO_DESTROY) === DONE) stream._duplexState |= DESTROYING;
-          if (this.pipeTo !== null) this.pipeTo.end();
+          if ((stream._duplexState & AUTO_DESTROY) === DONE) {
+            stream._duplexState |= DESTROYING;
+          }
+          if (this.pipeTo !== null) {
+            this.pipeTo.end();
+          }
         }
         if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
           if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
@@ -23570,8 +23712,11 @@ var require_streamx = __commonJS({
         return true;
       }
       updateCallback() {
-        if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) this.update();
-        else this.updateNextTick();
+        if ((this.stream._duplexState & READ_UPDATE_SYNC_STATUS) === READ_PRIMARY) {
+          this.update();
+        } else {
+          this.updateNextTick();
+        }
       }
       updateNextTickIfOpen() {
         if ((this.stream._duplexState & READ_NEXT_TICK_OR_OPENING) !== 0) return;
@@ -23608,7 +23753,7 @@ var require_streamx = __commonJS({
           this.to = null;
           if (this.from !== null) {
             if ((this.from._duplexState & READ_DONE) === 0 || !this.pipeToFinished) {
-              this.from.destroy(this.error || new Error("Writable stream closed prematurely"));
+              this.from.destroy(this.error || StreamError.PREMATURE_CLOSE("Writable stream closed"));
             }
             return;
           }
@@ -23617,7 +23762,7 @@ var require_streamx = __commonJS({
           this.from = null;
           if (this.to !== null) {
             if ((stream._duplexState & READ_DONE) === 0) {
-              this.to.destroy(this.error || new Error("Readable stream closed before ending"));
+              this.to.destroy(this.error || StreamError.PREMATURE_CLOSE("Readable stream closed"));
             }
             return;
           }
@@ -23641,21 +23786,30 @@ var require_streamx = __commonJS({
         stream._duplexState |= DESTROYING;
       }
       stream._duplexState &= WRITE_NOT_FINISHING;
-      if ((stream._duplexState & WRITE_UPDATING) === 0) this.update();
-      else this.updateNextTick();
+      if ((stream._duplexState & WRITE_UPDATING) === 0) {
+        this.update();
+      } else {
+        this.updateNextTick();
+      }
     }
     function afterDestroy(err) {
       const stream = this.stream;
-      if (!err && this.error !== STREAM_DESTROYED) err = this.error;
+      if (!err && !StreamError.isStreamDestroyed(this.error)) err = this.error;
       if (err) stream.emit("error", err);
       stream._duplexState |= DESTROYED;
       stream.emit("close");
       const rs = stream._readableState;
       const ws = stream._writableState;
-      if (rs !== null && rs.pipeline !== null) rs.pipeline.done(stream, err);
+      if (rs !== null && rs.pipeline !== null) {
+        rs.pipeline.done(stream, err);
+      }
       if (ws !== null) {
-        while (ws.drains !== null && ws.drains.length > 0) ws.drains.shift().resolve(false);
-        if (ws.pipeline !== null) ws.pipeline.done(stream, err);
+        while (ws.drains !== null && ws.drains.length > 0) {
+          ws.drains.shift().resolve(false);
+        }
+        if (ws.pipeline !== null) {
+          ws.pipeline.done(stream, err);
+        }
       }
     }
     function afterWrite(err) {
@@ -23674,7 +23828,9 @@ var require_streamx = __commonJS({
     function afterRead(err) {
       if (err) this.stream.destroy(err);
       this.stream._duplexState &= READ_NOT_ACTIVE;
-      if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) this.stream._duplexState &= READ_NO_READ_AHEAD;
+      if (this.readAhead === false && (this.stream._duplexState & READ_RESUMED) === 0) {
+        this.stream._duplexState &= READ_NO_READ_AHEAD;
+      }
       this.updateCallback();
     }
     function updateReadNT() {
@@ -23701,8 +23857,12 @@ var require_streamx = __commonJS({
       const stream = this.stream;
       if (err) stream.destroy(err);
       if ((stream._duplexState & DESTROYING) === 0) {
-        if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) stream._duplexState |= READ_PRIMARY;
-        if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) stream._duplexState |= WRITE_PRIMARY;
+        if ((stream._duplexState & READ_PRIMARY_STATUS) === 0) {
+          stream._duplexState |= READ_PRIMARY;
+        }
+        if ((stream._duplexState & WRITE_PRIMARY_STATUS) === 0) {
+          stream._duplexState |= WRITE_PRIMARY;
+        }
         stream.emit("open");
       }
       stream._duplexState &= NOT_ACTIVE;
@@ -23745,9 +23905,7 @@ var require_streamx = __commonJS({
           if (opts.open) this._open = opts.open;
           if (opts.destroy) this._destroy = opts.destroy;
           if (opts.predestroy) this._predestroy = opts.predestroy;
-          if (opts.signal) {
-            opts.signal.addEventListener("abort", abort.bind(this));
-          }
+          if (opts.signal) opts.signal.addEventListener("abort", abort.bind(this));
         }
         this.on("newListener", newListener);
       }
@@ -23773,7 +23931,7 @@ var require_streamx = __commonJS({
       }
       destroy(err) {
         if ((this._duplexState & DESTROY_STATUS) === 0) {
-          if (!err) err = STREAM_DESTROYED;
+          if (!err) err = StreamError.STREAM_DESTROYED();
           this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
           if (this._readableState !== null) {
             this._readableState.highWaterMark = 0;
@@ -23786,8 +23944,12 @@ var require_streamx = __commonJS({
           this._duplexState |= PREDESTROYING;
           this._predestroy();
           this._duplexState &= NOT_PREDESTROYING;
-          if (this._readableState !== null) this._readableState.updateNextTick();
-          if (this._writableState !== null) this._writableState.updateNextTick();
+          if (this._readableState !== null) {
+            this._readableState.updateNextTick();
+          }
+          if (this._writableState !== null) {
+            this._writableState.updateNextTick();
+          }
         }
       }
     };
@@ -23803,6 +23965,15 @@ var require_streamx = __commonJS({
           if (opts.encoding) this.setEncoding(opts.encoding);
         }
       }
+      static deferred(fn, opts) {
+        const out = new PassThrough(opts);
+        fn().then((src) => {
+          if (src === null) return out.end();
+          if (out.destroying) return;
+          pipeline(src, out, noop);
+        }).catch((err) => out.destroy(err));
+        return out;
+      }
       setEncoding(encoding) {
         const dec = new TextDecoder(encoding);
         const map2 = this._readableState.map || echo;
@@ -23920,9 +24091,13 @@ var require_streamx = __commonJS({
         }
         function ondata(data) {
           if (promiseReject === null) return;
-          if (error) promiseReject(error);
-          else if (data === null && (stream._duplexState & READ_DONE) === 0) promiseReject(STREAM_DESTROYED);
-          else promiseResolve({ value: data, done: data === null });
+          if (error) {
+            promiseReject(error);
+          } else if (data === null && (stream._duplexState & READ_DONE) === 0) {
+            promiseReject(StreamError.STREAM_DESTROYED());
+          } else {
+            promiseResolve({ value: data, done: data === null });
+          }
           promiseReject = promiseResolve = null;
         }
         function destroy(err) {
@@ -24091,7 +24266,7 @@ var require_streamx = __commonJS({
     function pipeline(stream, ...streams) {
       const all = Array.isArray(stream) ? [...stream, ...streams] : [stream, ...streams];
       const done = all.length && typeof all[all.length - 1] === "function" ? all.pop() : null;
-      if (all.length < 2) throw new Error("Pipeline requires at least 2 streams");
+      if (all.length < 2) throw StreamError.BAD_ARGUMENT("Pipeline requires at least 2 streams");
       let src = all[0];
       let dest = null;
       let error = null;
@@ -24116,7 +24291,7 @@ var require_streamx = __commonJS({
           if (!autoDestroy) done(error);
         });
         if (autoDestroy) {
-          dest.on("close", () => done(error || (fin ? null : PREMATURE_CLOSE)));
+          dest.on("close", () => done(error || (fin ? null : StreamError.PREMATURE_CLOSE())));
         }
       }
       return dest;
@@ -24124,8 +24299,12 @@ var require_streamx = __commonJS({
         s.on("error", onerror2);
         s.on("close", onclose);
         function onclose() {
-          if (rd && s._readableState && !s._readableState.ended) return onerror2(PREMATURE_CLOSE);
-          if (wr && s._writableState && !s._writableState.ended) return onerror2(PREMATURE_CLOSE);
+          if (rd && s._readableState && !s._readableState.ended) {
+            return onerror2(StreamError.PREMATURE_CLOSE());
+          }
+          if (wr && s._writableState && !s._writableState.ended) {
+            return onerror2(StreamError.PREMATURE_CLOSE());
+          }
         }
       }
       function onerror(err) {
@@ -24145,21 +24324,27 @@ var require_streamx = __commonJS({
     function isStreamx(stream) {
       return typeof stream._duplexState === "number" && isStream(stream);
     }
+    function isEnding(stream) {
+      return !!stream._readableState && stream._readableState.ending;
+    }
     function isEnded(stream) {
       return !!stream._readableState && stream._readableState.ended;
     }
+    function isFinishing(stream) {
+      return !!stream._writableState && stream._writableState.ending;
+    }
     function isFinished(stream) {
       return !!stream._writableState && stream._writableState.ended;
     }
     function getStreamError(stream, opts = {}) {
       const err = stream._readableState && stream._readableState.error || stream._writableState && stream._writableState.error;
-      return !opts.all && err === STREAM_DESTROYED ? null : err;
+      return !opts.all && StreamError.isStreamDestroyed(err) ? null : err;
     }
     function isReadStreamx(stream) {
       return isStreamx(stream) && stream.readable;
     }
     function isDisturbed(stream) {
-      return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0;
+      return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & DESTROYING) === DESTROYING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0;
     }
     function isTypedArray(data) {
       return typeof data === "object" && data !== null && typeof data.byteLength === "number";
@@ -24170,7 +24355,7 @@ var require_streamx = __commonJS({
     function noop() {
     }
     function abort() {
-      this.destroy(new Error("Stream aborted."));
+      this.destroy(StreamError.ABORTED());
     }
     function isWritev(s) {
       return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev;
@@ -24180,7 +24365,9 @@ var require_streamx = __commonJS({
       pipelinePromise,
       isStream,
       isStreamx,
+      isEnding,
       isEnded,
+      isFinishing,
       isFinished,
       isDisturbed,
       getStreamError,
@@ -24195,9 +24382,9 @@ var require_streamx = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/headers.js
+// ../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/headers.js
 var require_headers = __commonJS({
-  "../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/headers.js"(exports) {
+  "../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/headers.js"(exports) {
     "use strict";
     var b4a = require_b4a();
     var ZEROS = "0000000000000000000";
@@ -24304,6 +24491,7 @@ var require_headers = __commonJS({
         uid,
         gid,
         size,
+        byteOffset: 0,
         mtime: new Date(1e3 * mtime),
         type,
         linkname,
@@ -24457,15 +24645,16 @@ var require_headers = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/extract.js
+// ../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/extract.js
 var require_extract = __commonJS({
-  "../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/extract.js"(exports, module) {
+  "../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/extract.js"(exports, module) {
     "use strict";
     var { Writable, Readable, getStreamError } = require_streamx();
     var FIFO = require_fast_fifo();
     var b4a = require_b4a();
     var headers = require_headers();
     var EMPTY = b4a.alloc(0);
+    var MAX_HEADER_SIZE = 4 * 1024 * 1024;
     var BufferList = class {
       constructor() {
         this.buffered = 0;
@@ -24478,7 +24667,7 @@ var require_extract = __commonJS({
         this.queue.push(buffer);
       }
       shiftFirst(size) {
-        return this._buffered === 0 ? null : this._next(size);
+        return this.buffered === 0 ? null : this._next(size);
       }
       shift(size) {
         if (size > this.buffered) return null;
@@ -24579,6 +24768,7 @@ var require_extract = __commonJS({
           return false;
         }
         if (!this._header) return true;
+        this._header.byteOffset = this._buffer.shifted;
         switch (this._header.type) {
           case "gnu-long-path":
           case "gnu-long-link-path":
@@ -24586,10 +24776,18 @@ var require_extract = __commonJS({
           case "pax-header":
             this._longHeader = true;
             this._missing = this._header.size;
+            if (this._missing > MAX_HEADER_SIZE) {
+              this._continueWrite(new Error("Header exceeds max size"));
+              return false;
+            }
             return true;
         }
         this._locked = true;
         this._applyLongHeaders();
+        if (!(this._header.size >= 0)) {
+          this._continueWrite(new Error("Invalid header"));
+          return false;
+        }
         if (this._header.size === 0 || this._header.type === "directory") {
           this.emit("entry", this._header, this._createStream(), this._unlockBound);
           return true;
@@ -24792,9 +24990,9 @@ var require_extract = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/constants.js
+// ../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/constants.js
 var require_constants2 = __commonJS({
-  "../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/constants.js"(exports, module) {
+  "../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/constants.js"(exports, module) {
     "use strict";
     var constants = {
       // just for envs without fs
@@ -24813,9 +25011,9 @@ var require_constants2 = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/pack.js
+// ../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/pack.js
 var require_pack = __commonJS({
-  "../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/pack.js"(exports, module) {
+  "../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/pack.js"(exports, module) {
     "use strict";
     var { Readable, Writable, getStreamError } = require_streamx();
     var b4a = require_b4a();
@@ -25048,9 +25246,9 @@ var require_pack = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/index.js
+// ../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/index.js
 var require_tar_stream = __commonJS({
-  "../../node_modules/.pnpm/tar-stream@3.1.8/node_modules/tar-stream/index.js"(exports) {
+  "../../node_modules/.pnpm/tar-stream@3.2.1/node_modules/tar-stream/index.js"(exports) {
     "use strict";
     exports.extract = require_extract();
     exports.pack = require_pack();