@aident-ai/cli 0.3.0 → 0.3.1-staging.ci.34903740288.1

package/dist/dsh.mjs

@@ -1,3 +1,2452 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// ../../node_modules/queue-tick/queue-microtask.js
+var require_queue_microtask = __commonJS(function(exports, module) {
+  module.exports = typeof queueMicrotask === "function" ? queueMicrotask : (fn) => Promise.resolve().then(fn);
+});
+
+// ../../node_modules/queue-tick/process-next-tick.js
+var require_process_next_tick = __commonJS(function(exports, module) {
+  module.exports = typeof process !== "undefined" && typeof process.nextTick === "function" ? process.nextTick.bind(process) : require_queue_microtask();
+});
+
+// ../../node_modules/fast-fifo/fixed-size.js
+var require_fixed_size = __commonJS(function(exports, module) {
+  module.exports = class FixedFIFO {
+    constructor(hwm) {
+      if (!(hwm > 0) || (hwm - 1 & hwm) !== 0)
+        throw new Error("Max size for a FixedFIFO should be a power of two");
+      this.buffer = new Array(hwm);
+      this.mask = hwm - 1;
+      this.top = 0;
+      this.btm = 0;
+      this.next = null;
+    }
+    clear() {
+      this.top = this.btm = 0;
+      this.next = null;
+      this.buffer.fill(undefined);
+    }
+    push(data) {
+      if (this.buffer[this.top] !== undefined)
+        return false;
+      this.buffer[this.top] = data;
+      this.top = this.top + 1 & this.mask;
+      return true;
+    }
+    shift() {
+      const last = this.buffer[this.btm];
+      if (last === undefined)
+        return;
+      this.buffer[this.btm] = undefined;
+      this.btm = this.btm + 1 & this.mask;
+      return last;
+    }
+    peek() {
+      return this.buffer[this.btm];
+    }
+    isEmpty() {
+      return this.buffer[this.btm] === undefined;
+    }
+  };
+});
+
+// ../../node_modules/fast-fifo/index.js
+var require_fast_fifo = __commonJS(function(exports, module) {
+  var FixedFIFO = require_fixed_size();
+  module.exports = class FastFIFO {
+    constructor(hwm) {
+      this.hwm = hwm || 16;
+      this.head = new FixedFIFO(this.hwm);
+      this.tail = this.head;
+      this.length = 0;
+    }
+    clear() {
+      this.head = this.tail;
+      this.head.clear();
+      this.length = 0;
+    }
+    push(val) {
+      this.length++;
+      if (!this.head.push(val)) {
+        const prev = this.head;
+        this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+        this.head.push(val);
+      }
+    }
+    shift() {
+      if (this.length !== 0)
+        this.length--;
+      const val = this.tail.shift();
+      if (val === undefined && this.tail.next) {
+        const next = this.tail.next;
+        this.tail.next = null;
+        this.tail = next;
+        return this.tail.shift();
+      }
+      return val;
+    }
+    peek() {
+      const val = this.tail.peek();
+      if (val === undefined && this.tail.next)
+        return this.tail.next.peek();
+      return val;
+    }
+    isEmpty() {
+      return this.length === 0;
+    }
+  };
+});
+
+// ../../node_modules/b4a/index.js
+var require_b4a = __commonJS(function(exports, module) {
+  function isBuffer(value) {
+    return Buffer.isBuffer(value) || value instanceof Uint8Array;
+  }
+  function isEncoding(encoding) {
+    return Buffer.isEncoding(encoding);
+  }
+  function alloc(size, fill, encoding) {
+    return Buffer.alloc(size, fill, encoding);
+  }
+  function allocUnsafe(size) {
+    return Buffer.allocUnsafe(size);
+  }
+  function allocUnsafeSlow(size) {
+    return Buffer.allocUnsafeSlow(size);
+  }
+  function byteLength(string, encoding) {
+    return Buffer.byteLength(string, encoding);
+  }
+  function compare(a, b) {
+    return Buffer.compare(a, b);
+  }
+  function concat(buffers, totalLength) {
+    return Buffer.concat(buffers, totalLength);
+  }
+  function copy(source, target, targetStart, start, end) {
+    return toBuffer(source).copy(target, targetStart, start, end);
+  }
+  function equals(a, b) {
+    return toBuffer(a).equals(b);
+  }
+  function fill(buffer, value, offset, end, encoding) {
+    return toBuffer(buffer).fill(value, offset, end, encoding);
+  }
+  function from(value, encodingOrOffset, length) {
+    return Buffer.from(value, encodingOrOffset, length);
+  }
+  function includes(buffer, value, byteOffset, encoding) {
+    return toBuffer(buffer).includes(value, byteOffset, encoding);
+  }
+  function indexOf(buffer, value, byfeOffset, encoding) {
+    return toBuffer(buffer).indexOf(value, byfeOffset, encoding);
+  }
+  function lastIndexOf(buffer, value, byteOffset, encoding) {
+    return toBuffer(buffer).lastIndexOf(value, byteOffset, encoding);
+  }
+  function swap16(buffer) {
+    return toBuffer(buffer).swap16();
+  }
+  function swap32(buffer) {
+    return toBuffer(buffer).swap32();
+  }
+  function swap64(buffer) {
+    return toBuffer(buffer).swap64();
+  }
+  function toBuffer(buffer) {
+    if (Buffer.isBuffer(buffer))
+      return buffer;
+    return Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  function toString(buffer, encoding, start, end) {
+    return toBuffer(buffer).toString(encoding, start, end);
+  }
+  function write(buffer, string, offset, length, encoding) {
+    return toBuffer(buffer).write(string, offset, length, encoding);
+  }
+  function writeDoubleLE(buffer, value, offset) {
+    return toBuffer(buffer).writeDoubleLE(value, offset);
+  }
+  function writeFloatLE(buffer, value, offset) {
+    return toBuffer(buffer).writeFloatLE(value, offset);
+  }
+  function writeUInt32LE(buffer, value, offset) {
+    return toBuffer(buffer).writeUInt32LE(value, offset);
+  }
+  function writeInt32LE(buffer, value, offset) {
+    return toBuffer(buffer).writeInt32LE(value, offset);
+  }
+  function readDoubleLE(buffer, offset) {
+    return toBuffer(buffer).readDoubleLE(offset);
+  }
+  function readFloatLE(buffer, offset) {
+    return toBuffer(buffer).readFloatLE(offset);
+  }
+  function readUInt32LE(buffer, offset) {
+    return toBuffer(buffer).readUInt32LE(offset);
+  }
+  function readInt32LE(buffer, offset) {
+    return toBuffer(buffer).readInt32LE(offset);
+  }
+  function writeDoubleBE(buffer, value, offset) {
+    return toBuffer(buffer).writeDoubleBE(value, offset);
+  }
+  function writeFloatBE(buffer, value, offset) {
+    return toBuffer(buffer).writeFloatBE(value, offset);
+  }
+  function writeUInt32BE(buffer, value, offset) {
+    return toBuffer(buffer).writeUInt32BE(value, offset);
+  }
+  function writeInt32BE(buffer, value, offset) {
+    return toBuffer(buffer).writeInt32BE(value, offset);
+  }
+  function readDoubleBE(buffer, offset) {
+    return toBuffer(buffer).readDoubleBE(offset);
+  }
+  function readFloatBE(buffer, offset) {
+    return toBuffer(buffer).readFloatBE(offset);
+  }
+  function readUInt32BE(buffer, offset) {
+    return toBuffer(buffer).readUInt32BE(offset);
+  }
+  function readInt32BE(buffer, offset) {
+    return toBuffer(buffer).readInt32BE(offset);
+  }
+  module.exports = {
+    isBuffer,
+    isEncoding,
+    alloc,
+    allocUnsafe,
+    allocUnsafeSlow,
+    byteLength,
+    compare,
+    concat,
+    copy,
+    equals,
+    fill,
+    from,
+    includes,
+    indexOf,
+    lastIndexOf,
+    swap16,
+    swap32,
+    swap64,
+    toBuffer,
+    toString,
+    write,
+    writeDoubleLE,
+    writeFloatLE,
+    writeUInt32LE,
+    writeInt32LE,
+    readDoubleLE,
+    readFloatLE,
+    readUInt32LE,
+    readInt32LE,
+    writeDoubleBE,
+    writeFloatBE,
+    writeUInt32BE,
+    writeInt32BE,
+    readDoubleBE,
+    readFloatBE,
+    readUInt32BE,
+    readInt32BE
+  };
+});
+
+// ../../node_modules/text-decoder/lib/pass-through-decoder.js
+var require_pass_through_decoder = __commonJS(function(exports, module) {
+  var b4a = require_b4a();
+  module.exports = class PassThroughDecoder {
+    constructor(encoding) {
+      this.encoding = encoding;
+    }
+    get remaining() {
+      return 0;
+    }
+    decode(tail) {
+      return b4a.toString(tail, this.encoding);
+    }
+    flush() {
+      return "";
+    }
+  };
+});
+
+// ../../node_modules/text-decoder/lib/utf8-decoder.js
+var require_utf8_decoder = __commonJS(function(exports, module) {
+  var b4a = require_b4a();
+  module.exports = class UTF8Decoder {
+    constructor() {
+      this.codePoint = 0;
+      this.bytesSeen = 0;
+      this.bytesNeeded = 0;
+      this.lowerBoundary = 128;
+      this.upperBoundary = 191;
+    }
+    get remaining() {
+      return this.bytesSeen;
+    }
+    decode(data) {
+      if (this.bytesNeeded === 0) {
+        let isBoundary = true;
+        for (let i = Math.max(0, data.byteLength - 4), n = data.byteLength;i < n && isBoundary; i++) {
+          isBoundary = data[i] <= 127;
+        }
+        if (isBoundary)
+          return b4a.toString(data, "utf8");
+      }
+      let result = "";
+      for (let i = 0, n = data.byteLength;i < n; i++) {
+        const byte = data[i];
+        if (this.bytesNeeded === 0) {
+          if (byte <= 127) {
+            result += String.fromCharCode(byte);
+          } else {
+            this.bytesSeen = 1;
+            if (byte >= 194 && byte <= 223) {
+              this.bytesNeeded = 2;
+              this.codePoint = byte & 31;
+            } else if (byte >= 224 && byte <= 239) {
+              if (byte === 224)
+                this.lowerBoundary = 160;
+              else if (byte === 237)
+                this.upperBoundary = 159;
+              this.bytesNeeded = 3;
+              this.codePoint = byte & 15;
+            } else if (byte >= 240 && byte <= 244) {
+              if (byte === 240)
+                this.lowerBoundary = 144;
+              if (byte === 244)
+                this.upperBoundary = 143;
+              this.bytesNeeded = 4;
+              this.codePoint = byte & 7;
+            } else {
+              result += "�";
+            }
+          }
+          continue;
+        }
+        if (byte < this.lowerBoundary || byte > this.upperBoundary) {
+          this.codePoint = 0;
+          this.bytesNeeded = 0;
+          this.bytesSeen = 0;
+          this.lowerBoundary = 128;
+          this.upperBoundary = 191;
+          result += "�";
+          continue;
+        }
+        this.lowerBoundary = 128;
+        this.upperBoundary = 191;
+        this.codePoint = this.codePoint << 6 | byte & 63;
+        this.bytesSeen++;
+        if (this.bytesSeen !== this.bytesNeeded)
+          continue;
+        result += String.fromCodePoint(this.codePoint);
+        this.codePoint = 0;
+        this.bytesNeeded = 0;
+        this.bytesSeen = 0;
+      }
+      return result;
+    }
+    flush() {
+      const result = this.bytesNeeded > 0 ? "�" : "";
+      this.codePoint = 0;
+      this.bytesNeeded = 0;
+      this.bytesSeen = 0;
+      this.lowerBoundary = 128;
+      this.upperBoundary = 191;
+      return result;
+    }
+  };
+});
+
+// ../../node_modules/text-decoder/index.js
+var require_text_decoder = __commonJS(function(exports, module) {
+  var PassThroughDecoder = require_pass_through_decoder();
+  var UTF8Decoder = require_utf8_decoder();
+  module.exports = class TextDecoder {
+    constructor(encoding = "utf8") {
+      this.encoding = normalizeEncoding(encoding);
+      switch (this.encoding) {
+        case "utf8":
+          this.decoder = new UTF8Decoder;
+          break;
+        case "utf16le":
+        case "base64":
+          throw new Error("Unsupported encoding: " + this.encoding);
+        default:
+          this.decoder = new PassThroughDecoder(this.encoding);
+      }
+    }
+    get remaining() {
+      return this.decoder.remaining;
+    }
+    push(data) {
+      if (typeof data === "string")
+        return data;
+      return this.decoder.decode(data);
+    }
+    write(data) {
+      return this.push(data);
+    }
+    end(data) {
+      let result = "";
+      if (data)
+        result = this.push(data);
+      result += this.decoder.flush();
+      return result;
+    }
+  };
+  function normalizeEncoding(encoding) {
+    encoding = encoding.toLowerCase();
+    switch (encoding) {
+      case "utf8":
+      case "utf-8":
+        return "utf8";
+      case "ucs2":
+      case "ucs-2":
+      case "utf16le":
+      case "utf-16le":
+        return "utf16le";
+      case "latin1":
+      case "binary":
+        return "latin1";
+      case "base64":
+      case "ascii":
+      case "hex":
+        return encoding;
+      default:
+        throw new Error("Unknown encoding: " + encoding);
+    }
+  }
+});
+
+// ../../node_modules/streamx/index.js
+var require_streamx = __commonJS(function(exports, module) {
+  var { EventEmitter } = __require("events");
+  var STREAM_DESTROYED = new Error("Stream was destroyed");
+  var PREMATURE_CLOSE = new Error("Premature close");
+  var queueTick = require_process_next_tick();
+  var FIFO = require_fast_fifo();
+  var TextDecoder = require_text_decoder();
+  var MAX = (1 << 29) - 1;
+  var OPENING = 1;
+  var PREDESTROYING = 2;
+  var DESTROYING = 4;
+  var DESTROYED = 8;
+  var NOT_OPENING = MAX ^ OPENING;
+  var NOT_PREDESTROYING = MAX ^ PREDESTROYING;
+  var READ_ACTIVE = 1 << 4;
+  var READ_UPDATING = 2 << 4;
+  var READ_PRIMARY = 4 << 4;
+  var READ_QUEUED = 8 << 4;
+  var READ_RESUMED = 16 << 4;
+  var READ_PIPE_DRAINED = 32 << 4;
+  var READ_ENDING = 64 << 4;
+  var READ_EMIT_DATA = 128 << 4;
+  var READ_EMIT_READABLE = 256 << 4;
+  var READ_EMITTED_READABLE = 512 << 4;
+  var READ_DONE = 1024 << 4;
+  var READ_NEXT_TICK = 2048 << 4;
+  var READ_NEEDS_PUSH = 4096 << 4;
+  var READ_READ_AHEAD = 8192 << 4;
+  var READ_FLOWING = READ_RESUMED | READ_PIPE_DRAINED;
+  var READ_ACTIVE_AND_NEEDS_PUSH = READ_ACTIVE | READ_NEEDS_PUSH;
+  var READ_PRIMARY_AND_ACTIVE = READ_PRIMARY | READ_ACTIVE;
+  var READ_EMIT_READABLE_AND_QUEUED = READ_EMIT_READABLE | READ_QUEUED;
+  var READ_RESUMED_READ_AHEAD = READ_RESUMED | READ_READ_AHEAD;
+  var READ_NOT_ACTIVE = MAX ^ READ_ACTIVE;
+  var READ_NON_PRIMARY = MAX ^ READ_PRIMARY;
+  var READ_NON_PRIMARY_AND_PUSHED = MAX ^ (READ_PRIMARY | READ_NEEDS_PUSH);
+  var READ_PUSHED = MAX ^ READ_NEEDS_PUSH;
+  var READ_PAUSED = MAX ^ READ_RESUMED;
+  var READ_NOT_QUEUED = MAX ^ (READ_QUEUED | READ_EMITTED_READABLE);
+  var READ_NOT_ENDING = MAX ^ READ_ENDING;
+  var READ_PIPE_NOT_DRAINED = MAX ^ READ_FLOWING;
+  var READ_NOT_NEXT_TICK = MAX ^ READ_NEXT_TICK;
+  var READ_NOT_UPDATING = MAX ^ READ_UPDATING;
+  var READ_NO_READ_AHEAD = MAX ^ READ_READ_AHEAD;
+  var READ_PAUSED_NO_READ_AHEAD = MAX ^ READ_RESUMED_READ_AHEAD;
+  var WRITE_ACTIVE = 1 << 18;
+  var WRITE_UPDATING = 2 << 18;
+  var WRITE_PRIMARY = 4 << 18;
+  var WRITE_QUEUED = 8 << 18;
+  var WRITE_UNDRAINED = 16 << 18;
+  var WRITE_DONE = 32 << 18;
+  var WRITE_EMIT_DRAIN = 64 << 18;
+  var WRITE_NEXT_TICK = 128 << 18;
+  var WRITE_WRITING = 256 << 18;
+  var WRITE_FINISHING = 512 << 18;
+  var WRITE_CORKED = 1024 << 18;
+  var WRITE_NOT_ACTIVE = MAX ^ (WRITE_ACTIVE | WRITE_WRITING);
+  var WRITE_NON_PRIMARY = MAX ^ WRITE_PRIMARY;
+  var WRITE_NOT_FINISHING = MAX ^ (WRITE_ACTIVE | WRITE_FINISHING);
+  var WRITE_DRAINED = MAX ^ WRITE_UNDRAINED;
+  var WRITE_NOT_QUEUED = MAX ^ WRITE_QUEUED;
+  var WRITE_NOT_NEXT_TICK = MAX ^ WRITE_NEXT_TICK;
+  var WRITE_NOT_UPDATING = MAX ^ WRITE_UPDATING;
+  var WRITE_NOT_CORKED = MAX ^ WRITE_CORKED;
+  var ACTIVE = READ_ACTIVE | WRITE_ACTIVE;
+  var NOT_ACTIVE = MAX ^ ACTIVE;
+  var DONE = READ_DONE | WRITE_DONE;
+  var DESTROY_STATUS = DESTROYING | DESTROYED | PREDESTROYING;
+  var OPEN_STATUS = DESTROY_STATUS | OPENING;
+  var AUTO_DESTROY = DESTROY_STATUS | DONE;
+  var NON_PRIMARY = WRITE_NON_PRIMARY & READ_NON_PRIMARY;
+  var ACTIVE_OR_TICKING = WRITE_NEXT_TICK | READ_NEXT_TICK;
+  var TICKING = ACTIVE_OR_TICKING & NOT_ACTIVE;
+  var IS_OPENING = OPEN_STATUS | TICKING;
+  var READ_PRIMARY_STATUS = OPEN_STATUS | READ_ENDING | READ_DONE;
+  var READ_STATUS = OPEN_STATUS | READ_DONE | READ_QUEUED;
+  var READ_ENDING_STATUS = OPEN_STATUS | READ_ENDING | READ_QUEUED;
+  var READ_READABLE_STATUS = OPEN_STATUS | READ_EMIT_READABLE | READ_QUEUED | READ_EMITTED_READABLE;
+  var SHOULD_NOT_READ = OPEN_STATUS | READ_ACTIVE | READ_ENDING | READ_DONE | READ_NEEDS_PUSH | READ_READ_AHEAD;
+  var READ_BACKPRESSURE_STATUS = DESTROY_STATUS | READ_ENDING | READ_DONE;
+  var READ_UPDATE_SYNC_STATUS = READ_UPDATING | OPEN_STATUS | READ_NEXT_TICK | READ_PRIMARY;
+  var READ_NEXT_TICK_OR_OPENING = READ_NEXT_TICK | OPENING;
+  var WRITE_PRIMARY_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_DONE;
+  var WRITE_QUEUED_AND_UNDRAINED = WRITE_QUEUED | WRITE_UNDRAINED;
+  var WRITE_QUEUED_AND_ACTIVE = WRITE_QUEUED | WRITE_ACTIVE;
+  var WRITE_DRAIN_STATUS = WRITE_QUEUED | WRITE_UNDRAINED | OPEN_STATUS | WRITE_ACTIVE;
+  var WRITE_STATUS = OPEN_STATUS | WRITE_ACTIVE | WRITE_QUEUED | WRITE_CORKED;
+  var WRITE_PRIMARY_AND_ACTIVE = WRITE_PRIMARY | WRITE_ACTIVE;
+  var WRITE_ACTIVE_AND_WRITING = WRITE_ACTIVE | WRITE_WRITING;
+  var WRITE_FINISHING_STATUS = OPEN_STATUS | WRITE_FINISHING | WRITE_QUEUED_AND_ACTIVE | WRITE_DONE;
+  var WRITE_BACKPRESSURE_STATUS = WRITE_UNDRAINED | DESTROY_STATUS | WRITE_FINISHING | WRITE_DONE;
+  var WRITE_UPDATE_SYNC_STATUS = WRITE_UPDATING | OPEN_STATUS | WRITE_NEXT_TICK | WRITE_PRIMARY;
+  var WRITE_DROP_DATA = WRITE_FINISHING | WRITE_DONE | DESTROY_STATUS;
+  var asyncIterator = Symbol.asyncIterator || Symbol("asyncIterator");
+
+  class WritableState {
+    constructor(stream, { highWaterMark = 16384, map = null, mapWritable, byteLength, byteLengthWritable } = {}) {
+      this.stream = stream;
+      this.queue = new FIFO;
+      this.highWaterMark = highWaterMark;
+      this.buffered = 0;
+      this.error = null;
+      this.pipeline = null;
+      this.drains = null;
+      this.byteLength = byteLengthWritable || byteLength || defaultByteLength;
+      this.map = mapWritable || map;
+      this.afterWrite = afterWrite.bind(this);
+      this.afterUpdateNextTick = updateWriteNT.bind(this);
+    }
+    get ended() {
+      return (this.stream._duplexState & WRITE_DONE) !== 0;
+    }
+    push(data) {
+      if ((this.stream._duplexState & WRITE_DROP_DATA) !== 0)
+        return false;
+      if (this.map !== null)
+        data = this.map(data);
+      this.buffered += this.byteLength(data);
+      this.queue.push(data);
+      if (this.buffered < this.highWaterMark) {
+        this.stream._duplexState |= WRITE_QUEUED;
+        return true;
+      }
+      this.stream._duplexState |= WRITE_QUEUED_AND_UNDRAINED;
+      return false;
+    }
+    shift() {
+      const data = this.queue.shift();
+      this.buffered -= this.byteLength(data);
+      if (this.buffered === 0)
+        this.stream._duplexState &= WRITE_NOT_QUEUED;
+      return data;
+    }
+    end(data) {
+      if (typeof data === "function")
+        this.stream.once("finish", data);
+      else if (data !== undefined && data !== null)
+        this.push(data);
+      this.stream._duplexState = (this.stream._duplexState | WRITE_FINISHING) & WRITE_NON_PRIMARY;
+    }
+    autoBatch(data, cb) {
+      const buffer = [];
+      const stream = this.stream;
+      buffer.push(data);
+      while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED_AND_ACTIVE) {
+        buffer.push(stream._writableState.shift());
+      }
+      if ((stream._duplexState & OPEN_STATUS) !== 0)
+        return cb(null);
+      stream._writev(buffer, cb);
+    }
+    update() {
+      const stream = this.stream;
+      stream._duplexState |= WRITE_UPDATING;
+      do {
+        while ((stream._duplexState & WRITE_STATUS) === WRITE_QUEUED) {
+          const data = this.shift();
+          stream._duplexState |= WRITE_ACTIVE_AND_WRITING;
+          stream._write(data, this.afterWrite);
+        }
+        if ((stream._duplexState & WRITE_PRIMARY_AND_ACTIVE) === 0)
+          this.updateNonPrimary();
+      } while (this.continueUpdate() === true);
+      stream._duplexState &= WRITE_NOT_UPDATING;
+    }
+    updateNonPrimary() {
+      const stream = this.stream;
+      if ((stream._duplexState & WRITE_FINISHING_STATUS) === WRITE_FINISHING) {
+        stream._duplexState = stream._duplexState | WRITE_ACTIVE;
+        stream._final(afterFinal.bind(this));
+        return;
+      }
+      if ((stream._duplexState & DESTROY_STATUS) === DESTROYING) {
+        if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
+          stream._duplexState |= ACTIVE;
+          stream._destroy(afterDestroy.bind(this));
+        }
+        return;
+      }
+      if ((stream._duplexState & IS_OPENING) === OPENING) {
+        stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
+        stream._open(afterOpen.bind(this));
+      }
+    }
+    continueUpdate() {
+      if ((this.stream._duplexState & WRITE_NEXT_TICK) === 0)
+        return false;
+      this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
+      return true;
+    }
+    updateCallback() {
+      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;
+      this.stream._duplexState |= WRITE_NEXT_TICK;
+      if ((this.stream._duplexState & WRITE_UPDATING) === 0)
+        queueTick(this.afterUpdateNextTick);
+    }
+  }
+
+  class ReadableState {
+    constructor(stream, { highWaterMark = 16384, map = null, mapReadable, byteLength, byteLengthReadable } = {}) {
+      this.stream = stream;
+      this.queue = new FIFO;
+      this.highWaterMark = highWaterMark === 0 ? 1 : highWaterMark;
+      this.buffered = 0;
+      this.readAhead = highWaterMark > 0;
+      this.error = null;
+      this.pipeline = null;
+      this.byteLength = byteLengthReadable || byteLength || defaultByteLength;
+      this.map = mapReadable || map;
+      this.pipeTo = null;
+      this.afterRead = afterRead.bind(this);
+      this.afterUpdateNextTick = updateReadNT.bind(this);
+    }
+    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 (typeof cb !== "function")
+        cb = null;
+      this.stream._duplexState |= READ_PIPE_DRAINED;
+      this.pipeTo = pipeTo;
+      this.pipeline = new Pipeline(this.stream, pipeTo, cb);
+      if (cb)
+        this.stream.on("error", noop);
+      if (isStreamx(pipeTo)) {
+        pipeTo._writableState.pipeline = this.pipeline;
+        if (cb)
+          pipeTo.on("error", noop);
+        pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
+      } else {
+        const onerror = this.pipeline.done.bind(this.pipeline, pipeTo);
+        const onclose = this.pipeline.done.bind(this.pipeline, pipeTo, null);
+        pipeTo.on("error", onerror);
+        pipeTo.on("close", onclose);
+        pipeTo.on("finish", this.pipeline.finished.bind(this.pipeline));
+      }
+      pipeTo.on("drain", afterDrain.bind(this));
+      this.stream.emit("piping", pipeTo);
+      pipeTo.emit("pipe", this.stream);
+    }
+    push(data) {
+      const stream = this.stream;
+      if (data === null) {
+        this.highWaterMark = 0;
+        stream._duplexState = (stream._duplexState | READ_ENDING) & READ_NON_PRIMARY_AND_PUSHED;
+        return false;
+      }
+      if (this.map !== null) {
+        data = this.map(data);
+        if (data === null) {
+          stream._duplexState &= READ_PUSHED;
+          return this.buffered < this.highWaterMark;
+        }
+      }
+      this.buffered += this.byteLength(data);
+      this.queue.push(data);
+      stream._duplexState = (stream._duplexState | READ_QUEUED) & READ_PUSHED;
+      return this.buffered < this.highWaterMark;
+    }
+    shift() {
+      const data = this.queue.shift();
+      this.buffered -= this.byteLength(data);
+      if (this.buffered === 0)
+        this.stream._duplexState &= READ_NOT_QUEUED;
+      return data;
+    }
+    unshift(data) {
+      const pending = [this.map !== null ? this.map(data) : data];
+      while (this.buffered > 0)
+        pending.push(this.shift());
+      for (let i = 0;i < pending.length - 1; i++) {
+        const data = pending[i];
+        this.buffered += this.byteLength(data);
+        this.queue.push(data);
+      }
+      this.push(pending[pending.length - 1]);
+    }
+    read() {
+      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);
+        return data;
+      }
+      if (this.readAhead === false) {
+        stream._duplexState |= READ_READ_AHEAD;
+        this.updateNextTick();
+      }
+      return null;
+    }
+    drain() {
+      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);
+      }
+    }
+    update() {
+      const stream = this.stream;
+      stream._duplexState |= READ_UPDATING;
+      do {
+        this.drain();
+        while (this.buffered < this.highWaterMark && (stream._duplexState & SHOULD_NOT_READ) === READ_READ_AHEAD) {
+          stream._duplexState |= READ_ACTIVE_AND_NEEDS_PUSH;
+          stream._read(this.afterRead);
+          this.drain();
+        }
+        if ((stream._duplexState & READ_READABLE_STATUS) === READ_EMIT_READABLE_AND_QUEUED) {
+          stream._duplexState |= READ_EMITTED_READABLE;
+          stream.emit("readable");
+        }
+        if ((stream._duplexState & READ_PRIMARY_AND_ACTIVE) === 0)
+          this.updateNonPrimary();
+      } while (this.continueUpdate() === true);
+      stream._duplexState &= READ_NOT_UPDATING;
+    }
+    updateNonPrimary() {
+      const stream = this.stream;
+      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 & DESTROY_STATUS) === DESTROYING) {
+        if ((stream._duplexState & ACTIVE_OR_TICKING) === 0) {
+          stream._duplexState |= ACTIVE;
+          stream._destroy(afterDestroy.bind(this));
+        }
+        return;
+      }
+      if ((stream._duplexState & IS_OPENING) === OPENING) {
+        stream._duplexState = (stream._duplexState | ACTIVE) & NOT_OPENING;
+        stream._open(afterOpen.bind(this));
+      }
+    }
+    continueUpdate() {
+      if ((this.stream._duplexState & READ_NEXT_TICK) === 0)
+        return false;
+      this.stream._duplexState &= READ_NOT_NEXT_TICK;
+      return true;
+    }
+    updateCallback() {
+      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;
+      this.stream._duplexState |= READ_NEXT_TICK;
+      if ((this.stream._duplexState & READ_UPDATING) === 0)
+        queueTick(this.afterUpdateNextTick);
+    }
+    updateNextTick() {
+      if ((this.stream._duplexState & READ_NEXT_TICK) !== 0)
+        return;
+      this.stream._duplexState |= READ_NEXT_TICK;
+      if ((this.stream._duplexState & READ_UPDATING) === 0)
+        queueTick(this.afterUpdateNextTick);
+    }
+  }
+
+  class TransformState {
+    constructor(stream) {
+      this.data = null;
+      this.afterTransform = afterTransform.bind(stream);
+      this.afterFinal = null;
+    }
+  }
+
+  class Pipeline {
+    constructor(src, dst, cb) {
+      this.from = src;
+      this.to = dst;
+      this.afterPipe = cb;
+      this.error = null;
+      this.pipeToFinished = false;
+    }
+    finished() {
+      this.pipeToFinished = true;
+    }
+    done(stream, err) {
+      if (err)
+        this.error = err;
+      if (stream === this.to) {
+        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"));
+          }
+          return;
+        }
+      }
+      if (stream === this.from) {
+        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"));
+          }
+          return;
+        }
+      }
+      if (this.afterPipe !== null)
+        this.afterPipe(this.error);
+      this.to = this.from = this.afterPipe = null;
+    }
+  }
+  function afterDrain() {
+    this.stream._duplexState |= READ_PIPE_DRAINED;
+    this.updateCallback();
+  }
+  function afterFinal(err) {
+    const stream = this.stream;
+    if (err)
+      stream.destroy(err);
+    if ((stream._duplexState & DESTROY_STATUS) === 0) {
+      stream._duplexState |= WRITE_DONE;
+      stream.emit("finish");
+    }
+    if ((stream._duplexState & AUTO_DESTROY) === DONE) {
+      stream._duplexState |= DESTROYING;
+    }
+    stream._duplexState &= WRITE_NOT_FINISHING;
+    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)
+      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 (ws !== null) {
+      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) {
+    const stream = this.stream;
+    if (err)
+      stream.destroy(err);
+    stream._duplexState &= WRITE_NOT_ACTIVE;
+    if (this.drains !== null)
+      tickDrains(this.drains);
+    if ((stream._duplexState & WRITE_DRAIN_STATUS) === WRITE_UNDRAINED) {
+      stream._duplexState &= WRITE_DRAINED;
+      if ((stream._duplexState & WRITE_EMIT_DRAIN) === WRITE_EMIT_DRAIN) {
+        stream.emit("drain");
+      }
+    }
+    this.updateCallback();
+  }
+  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;
+    this.updateCallback();
+  }
+  function updateReadNT() {
+    if ((this.stream._duplexState & READ_UPDATING) === 0) {
+      this.stream._duplexState &= READ_NOT_NEXT_TICK;
+      this.update();
+    }
+  }
+  function updateWriteNT() {
+    if ((this.stream._duplexState & WRITE_UPDATING) === 0) {
+      this.stream._duplexState &= WRITE_NOT_NEXT_TICK;
+      this.update();
+    }
+  }
+  function tickDrains(drains) {
+    for (let i = 0;i < drains.length; i++) {
+      if (--drains[i].writes === 0) {
+        drains.shift().resolve(true);
+        i--;
+      }
+    }
+  }
+  function afterOpen(err) {
+    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;
+      stream.emit("open");
+    }
+    stream._duplexState &= NOT_ACTIVE;
+    if (stream._writableState !== null) {
+      stream._writableState.updateCallback();
+    }
+    if (stream._readableState !== null) {
+      stream._readableState.updateCallback();
+    }
+  }
+  function afterTransform(err, data) {
+    if (data !== undefined && data !== null)
+      this.push(data);
+    this._writableState.afterWrite(err);
+  }
+  function newListener(name) {
+    if (this._readableState !== null) {
+      if (name === "data") {
+        this._duplexState |= READ_EMIT_DATA | READ_RESUMED_READ_AHEAD;
+        this._readableState.updateNextTick();
+      }
+      if (name === "readable") {
+        this._duplexState |= READ_EMIT_READABLE;
+        this._readableState.updateNextTick();
+      }
+    }
+    if (this._writableState !== null) {
+      if (name === "drain") {
+        this._duplexState |= WRITE_EMIT_DRAIN;
+        this._writableState.updateNextTick();
+      }
+    }
+  }
+
+  class Stream extends EventEmitter {
+    constructor(opts) {
+      super();
+      this._duplexState = 0;
+      this._readableState = null;
+      this._writableState = null;
+      if (opts) {
+        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));
+        }
+      }
+      this.on("newListener", newListener);
+    }
+    _open(cb) {
+      cb(null);
+    }
+    _destroy(cb) {
+      cb(null);
+    }
+    _predestroy() {}
+    get readable() {
+      return this._readableState !== null ? true : undefined;
+    }
+    get writable() {
+      return this._writableState !== null ? true : undefined;
+    }
+    get destroyed() {
+      return (this._duplexState & DESTROYED) !== 0;
+    }
+    get destroying() {
+      return (this._duplexState & DESTROY_STATUS) !== 0;
+    }
+    destroy(err) {
+      if ((this._duplexState & DESTROY_STATUS) === 0) {
+        if (!err)
+          err = STREAM_DESTROYED;
+        this._duplexState = (this._duplexState | DESTROYING) & NON_PRIMARY;
+        if (this._readableState !== null) {
+          this._readableState.highWaterMark = 0;
+          this._readableState.error = err;
+        }
+        if (this._writableState !== null) {
+          this._writableState.highWaterMark = 0;
+          this._writableState.error = err;
+        }
+        this._duplexState |= PREDESTROYING;
+        this._predestroy();
+        this._duplexState &= NOT_PREDESTROYING;
+        if (this._readableState !== null)
+          this._readableState.updateNextTick();
+        if (this._writableState !== null)
+          this._writableState.updateNextTick();
+      }
+    }
+  }
+
+  class Readable extends Stream {
+    constructor(opts) {
+      super(opts);
+      this._duplexState |= OPENING | WRITE_DONE | READ_READ_AHEAD;
+      this._readableState = new ReadableState(this, opts);
+      if (opts) {
+        if (this._readableState.readAhead === false)
+          this._duplexState &= READ_NO_READ_AHEAD;
+        if (opts.read)
+          this._read = opts.read;
+        if (opts.eagerOpen)
+          this._readableState.updateNextTick();
+        if (opts.encoding)
+          this.setEncoding(opts.encoding);
+      }
+    }
+    setEncoding(encoding) {
+      const dec = new TextDecoder(encoding);
+      const map = this._readableState.map || echo;
+      this._readableState.map = mapOrSkip;
+      return this;
+      function mapOrSkip(data) {
+        const next = dec.push(data);
+        return next === "" && (data.byteLength !== 0 || dec.remaining > 0) ? null : map(next);
+      }
+    }
+    _read(cb) {
+      cb(null);
+    }
+    pipe(dest, cb) {
+      this._readableState.updateNextTick();
+      this._readableState.pipe(dest, cb);
+      return dest;
+    }
+    read() {
+      this._readableState.updateNextTick();
+      return this._readableState.read();
+    }
+    push(data) {
+      this._readableState.updateNextTickIfOpen();
+      return this._readableState.push(data);
+    }
+    unshift(data) {
+      this._readableState.updateNextTickIfOpen();
+      return this._readableState.unshift(data);
+    }
+    resume() {
+      this._duplexState |= READ_RESUMED_READ_AHEAD;
+      this._readableState.updateNextTick();
+      return this;
+    }
+    pause() {
+      this._duplexState &= this._readableState.readAhead === false ? READ_PAUSED_NO_READ_AHEAD : READ_PAUSED;
+      return this;
+    }
+    static _fromAsyncIterator(ite, opts) {
+      let destroy;
+      const rs = new Readable({
+        ...opts,
+        read(cb) {
+          ite.next().then(push).then(cb.bind(null, null)).catch(cb);
+        },
+        predestroy() {
+          destroy = ite.return();
+        },
+        destroy(cb) {
+          if (!destroy)
+            return cb(null);
+          destroy.then(cb.bind(null, null)).catch(cb);
+        }
+      });
+      return rs;
+      function push(data) {
+        if (data.done)
+          rs.push(null);
+        else
+          rs.push(data.value);
+      }
+    }
+    static from(data, opts) {
+      if (isReadStreamx(data))
+        return data;
+      if (data[asyncIterator])
+        return this._fromAsyncIterator(data[asyncIterator](), opts);
+      if (!Array.isArray(data))
+        data = data === undefined ? [] : [data];
+      let i = 0;
+      return new Readable({
+        ...opts,
+        read(cb) {
+          this.push(i === data.length ? null : data[i++]);
+          cb(null);
+        }
+      });
+    }
+    static isBackpressured(rs) {
+      return (rs._duplexState & READ_BACKPRESSURE_STATUS) !== 0 || rs._readableState.buffered >= rs._readableState.highWaterMark;
+    }
+    static isPaused(rs) {
+      return (rs._duplexState & READ_RESUMED) === 0;
+    }
+    [asyncIterator]() {
+      const stream = this;
+      let error = null;
+      let promiseResolve = null;
+      let promiseReject = null;
+      this.on("error", (err) => {
+        error = err;
+      });
+      this.on("readable", onreadable);
+      this.on("close", onclose);
+      return {
+        [asyncIterator]() {
+          return this;
+        },
+        next() {
+          return new Promise(function(resolve, reject) {
+            promiseResolve = resolve;
+            promiseReject = reject;
+            const data = stream.read();
+            if (data !== null)
+              ondata(data);
+            else if ((stream._duplexState & DESTROYED) !== 0)
+              ondata(null);
+          });
+        },
+        return() {
+          return destroy(null);
+        },
+        throw(err) {
+          return destroy(err);
+        }
+      };
+      function onreadable() {
+        if (promiseResolve !== null)
+          ondata(stream.read());
+      }
+      function onclose() {
+        if (promiseResolve !== null)
+          ondata(null);
+      }
+      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 });
+        promiseReject = promiseResolve = null;
+      }
+      function destroy(err) {
+        stream.destroy(err);
+        return new Promise((resolve, reject) => {
+          if (stream._duplexState & DESTROYED)
+            return resolve({ value: undefined, done: true });
+          stream.once("close", function() {
+            if (err)
+              reject(err);
+            else
+              resolve({ value: undefined, done: true });
+          });
+        });
+      }
+    }
+  }
+
+  class Writable extends Stream {
+    constructor(opts) {
+      super(opts);
+      this._duplexState |= OPENING | READ_DONE;
+      this._writableState = new WritableState(this, opts);
+      if (opts) {
+        if (opts.writev)
+          this._writev = opts.writev;
+        if (opts.write)
+          this._write = opts.write;
+        if (opts.final)
+          this._final = opts.final;
+        if (opts.eagerOpen)
+          this._writableState.updateNextTick();
+      }
+    }
+    cork() {
+      this._duplexState |= WRITE_CORKED;
+    }
+    uncork() {
+      this._duplexState &= WRITE_NOT_CORKED;
+      this._writableState.updateNextTick();
+    }
+    _writev(batch, cb) {
+      cb(null);
+    }
+    _write(data, cb) {
+      this._writableState.autoBatch(data, cb);
+    }
+    _final(cb) {
+      cb(null);
+    }
+    static isBackpressured(ws) {
+      return (ws._duplexState & WRITE_BACKPRESSURE_STATUS) !== 0;
+    }
+    static drained(ws) {
+      if (ws.destroyed)
+        return Promise.resolve(false);
+      const state = ws._writableState;
+      const pending = isWritev(ws) ? Math.min(1, state.queue.length) : state.queue.length;
+      const writes = pending + (ws._duplexState & WRITE_WRITING ? 1 : 0);
+      if (writes === 0)
+        return Promise.resolve(true);
+      if (state.drains === null)
+        state.drains = [];
+      return new Promise((resolve) => {
+        state.drains.push({ writes, resolve });
+      });
+    }
+    write(data) {
+      this._writableState.updateNextTick();
+      return this._writableState.push(data);
+    }
+    end(data) {
+      this._writableState.updateNextTick();
+      this._writableState.end(data);
+      return this;
+    }
+  }
+
+  class Duplex extends Readable {
+    constructor(opts) {
+      super(opts);
+      this._duplexState = OPENING | this._duplexState & READ_READ_AHEAD;
+      this._writableState = new WritableState(this, opts);
+      if (opts) {
+        if (opts.writev)
+          this._writev = opts.writev;
+        if (opts.write)
+          this._write = opts.write;
+        if (opts.final)
+          this._final = opts.final;
+      }
+    }
+    cork() {
+      this._duplexState |= WRITE_CORKED;
+    }
+    uncork() {
+      this._duplexState &= WRITE_NOT_CORKED;
+      this._writableState.updateNextTick();
+    }
+    _writev(batch, cb) {
+      cb(null);
+    }
+    _write(data, cb) {
+      this._writableState.autoBatch(data, cb);
+    }
+    _final(cb) {
+      cb(null);
+    }
+    write(data) {
+      this._writableState.updateNextTick();
+      return this._writableState.push(data);
+    }
+    end(data) {
+      this._writableState.updateNextTick();
+      this._writableState.end(data);
+      return this;
+    }
+  }
+
+  class Transform extends Duplex {
+    constructor(opts) {
+      super(opts);
+      this._transformState = new TransformState(this);
+      if (opts) {
+        if (opts.transform)
+          this._transform = opts.transform;
+        if (opts.flush)
+          this._flush = opts.flush;
+      }
+    }
+    _write(data, cb) {
+      if (this._readableState.buffered >= this._readableState.highWaterMark) {
+        this._transformState.data = data;
+      } else {
+        this._transform(data, this._transformState.afterTransform);
+      }
+    }
+    _read(cb) {
+      if (this._transformState.data !== null) {
+        const data = this._transformState.data;
+        this._transformState.data = null;
+        cb(null);
+        this._transform(data, this._transformState.afterTransform);
+      } else {
+        cb(null);
+      }
+    }
+    destroy(err) {
+      super.destroy(err);
+      if (this._transformState.data !== null) {
+        this._transformState.data = null;
+        this._transformState.afterTransform();
+      }
+    }
+    _transform(data, cb) {
+      cb(null, data);
+    }
+    _flush(cb) {
+      cb(null);
+    }
+    _final(cb) {
+      this._transformState.afterFinal = cb;
+      this._flush(transformAfterFlush.bind(this));
+    }
+  }
+
+  class PassThrough extends Transform {
+  }
+  function transformAfterFlush(err, data) {
+    const cb = this._transformState.afterFinal;
+    if (err)
+      return cb(err);
+    if (data !== null && data !== undefined)
+      this.push(data);
+    this.push(null);
+    cb(null);
+  }
+  function pipelinePromise(...streams) {
+    return new Promise((resolve, reject) => {
+      return pipeline(...streams, (err) => {
+        if (err)
+          return reject(err);
+        resolve();
+      });
+    });
+  }
+  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");
+    let src = all[0];
+    let dest = null;
+    let error = null;
+    for (let i = 1;i < all.length; i++) {
+      dest = all[i];
+      if (isStreamx(src)) {
+        src.pipe(dest, onerror);
+      } else {
+        errorHandle(src, true, i > 1, onerror);
+        src.pipe(dest);
+      }
+      src = dest;
+    }
+    if (done) {
+      let fin = false;
+      const autoDestroy = isStreamx(dest) || !!(dest._writableState && dest._writableState.autoDestroy);
+      dest.on("error", (err) => {
+        if (error === null)
+          error = err;
+      });
+      dest.on("finish", () => {
+        fin = true;
+        if (!autoDestroy)
+          done(error);
+      });
+      if (autoDestroy) {
+        dest.on("close", () => done(error || (fin ? null : PREMATURE_CLOSE)));
+      }
+    }
+    return dest;
+    function errorHandle(s, rd, wr, onerror) {
+      s.on("error", onerror);
+      s.on("close", onclose);
+      function onclose() {
+        if (rd && s._readableState && !s._readableState.ended)
+          return onerror(PREMATURE_CLOSE);
+        if (wr && s._writableState && !s._writableState.ended)
+          return onerror(PREMATURE_CLOSE);
+      }
+    }
+    function onerror(err) {
+      if (!err || error)
+        return;
+      error = err;
+      for (const s of all) {
+        s.destroy(err);
+      }
+    }
+  }
+  function echo(s) {
+    return s;
+  }
+  function isStream(stream) {
+    return !!stream._readableState || !!stream._writableState;
+  }
+  function isStreamx(stream) {
+    return typeof stream._duplexState === "number" && isStream(stream);
+  }
+  function isEnded(stream) {
+    return !!stream._readableState && stream._readableState.ended;
+  }
+  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;
+  }
+  function isReadStreamx(stream) {
+    return isStreamx(stream) && stream.readable;
+  }
+  function isDisturbed(stream) {
+    return (stream._duplexState & OPENING) !== OPENING || (stream._duplexState & ACTIVE_OR_TICKING) !== 0;
+  }
+  function isTypedArray(data) {
+    return typeof data === "object" && data !== null && typeof data.byteLength === "number";
+  }
+  function defaultByteLength(data) {
+    return isTypedArray(data) ? data.byteLength : 1024;
+  }
+  function noop() {}
+  function abort() {
+    this.destroy(new Error("Stream aborted."));
+  }
+  function isWritev(s) {
+    return s._writev !== Writable.prototype._writev && s._writev !== Duplex.prototype._writev;
+  }
+  module.exports = {
+    pipeline,
+    pipelinePromise,
+    isStream,
+    isStreamx,
+    isEnded,
+    isFinished,
+    isDisturbed,
+    getStreamError,
+    Stream,
+    Writable,
+    Readable,
+    Duplex,
+    Transform,
+    PassThrough
+  };
+});
+
+// ../../node_modules/tar-stream/headers.js
+var require_headers = __commonJS(function(exports) {
+  var b4a = require_b4a();
+  var ZEROS = "0000000000000000000";
+  var SEVENS = "7777777777777777777";
+  var ZERO_OFFSET = 48;
+  var USTAR_MAGIC = b4a.from([117, 115, 116, 97, 114, 0]);
+  var USTAR_VER = b4a.from([ZERO_OFFSET, ZERO_OFFSET]);
+  var GNU_MAGIC = b4a.from([117, 115, 116, 97, 114, 32]);
+  var GNU_VER = b4a.from([32, 0]);
+  var MASK = 4095;
+  var MAGIC_OFFSET = 257;
+  var VERSION_OFFSET = 263;
+  exports.decodeLongPath = function decodeLongPath(buf, encoding) {
+    return decodeStr(buf, 0, buf.length, encoding);
+  };
+  exports.encodePax = function encodePax(opts) {
+    let result = "";
+    if (opts.name)
+      result += addLength(" path=" + opts.name + `
+`);
+    if (opts.linkname)
+      result += addLength(" linkpath=" + opts.linkname + `
+`);
+    const pax = opts.pax;
+    if (pax) {
+      for (const key in pax) {
+        result += addLength(" " + key + "=" + pax[key] + `
+`);
+      }
+    }
+    return b4a.from(result);
+  };
+  exports.decodePax = function decodePax(buf) {
+    const result = {};
+    while (buf.length) {
+      let i = 0;
+      while (i < buf.length && buf[i] !== 32)
+        i++;
+      const len = parseInt(b4a.toString(buf.subarray(0, i)), 10);
+      if (!len)
+        return result;
+      const b = b4a.toString(buf.subarray(i + 1, len - 1));
+      const keyIndex = b.indexOf("=");
+      if (keyIndex === -1)
+        return result;
+      result[b.slice(0, keyIndex)] = b.slice(keyIndex + 1);
+      buf = buf.subarray(len);
+    }
+    return result;
+  };
+  exports.encode = function encode(opts) {
+    const buf = b4a.alloc(512);
+    let name = opts.name;
+    let prefix = "";
+    if (opts.typeflag === 5 && name[name.length - 1] !== "/")
+      name += "/";
+    if (b4a.byteLength(name) !== name.length)
+      return null;
+    while (b4a.byteLength(name) > 100) {
+      const i = name.indexOf("/");
+      if (i === -1)
+        return null;
+      prefix += prefix ? "/" + name.slice(0, i) : name.slice(0, i);
+      name = name.slice(i + 1);
+    }
+    if (b4a.byteLength(name) > 100 || b4a.byteLength(prefix) > 155)
+      return null;
+    if (opts.linkname && b4a.byteLength(opts.linkname) > 100)
+      return null;
+    b4a.write(buf, name);
+    b4a.write(buf, encodeOct(opts.mode & MASK, 6), 100);
+    b4a.write(buf, encodeOct(opts.uid, 6), 108);
+    b4a.write(buf, encodeOct(opts.gid, 6), 116);
+    encodeSize(opts.size, buf, 124);
+    b4a.write(buf, encodeOct(opts.mtime.getTime() / 1000 | 0, 11), 136);
+    buf[156] = ZERO_OFFSET + toTypeflag(opts.type);
+    if (opts.linkname)
+      b4a.write(buf, opts.linkname, 157);
+    b4a.copy(USTAR_MAGIC, buf, MAGIC_OFFSET);
+    b4a.copy(USTAR_VER, buf, VERSION_OFFSET);
+    if (opts.uname)
+      b4a.write(buf, opts.uname, 265);
+    if (opts.gname)
+      b4a.write(buf, opts.gname, 297);
+    b4a.write(buf, encodeOct(opts.devmajor || 0, 6), 329);
+    b4a.write(buf, encodeOct(opts.devminor || 0, 6), 337);
+    if (prefix)
+      b4a.write(buf, prefix, 345);
+    b4a.write(buf, encodeOct(cksum(buf), 6), 148);
+    return buf;
+  };
+  exports.decode = function decode(buf, filenameEncoding, allowUnknownFormat) {
+    let typeflag = buf[156] === 0 ? 0 : buf[156] - ZERO_OFFSET;
+    let name = decodeStr(buf, 0, 100, filenameEncoding);
+    const mode = decodeOct(buf, 100, 8);
+    const uid = decodeOct(buf, 108, 8);
+    const gid = decodeOct(buf, 116, 8);
+    const size = decodeOct(buf, 124, 12);
+    const mtime = decodeOct(buf, 136, 12);
+    const type = toType(typeflag);
+    const linkname = buf[157] === 0 ? null : decodeStr(buf, 157, 100, filenameEncoding);
+    const uname = decodeStr(buf, 265, 32);
+    const gname = decodeStr(buf, 297, 32);
+    const devmajor = decodeOct(buf, 329, 8);
+    const devminor = decodeOct(buf, 337, 8);
+    const c = cksum(buf);
+    if (c === 8 * 32)
+      return null;
+    if (c !== decodeOct(buf, 148, 8))
+      throw new Error("Invalid tar header. Maybe the tar is corrupted or it needs to be gunzipped?");
+    if (isUSTAR(buf)) {
+      if (buf[345])
+        name = decodeStr(buf, 345, 155, filenameEncoding) + "/" + name;
+    } else if (isGNU(buf)) {} else {
+      if (!allowUnknownFormat) {
+        throw new Error("Invalid tar header: unknown format.");
+      }
+    }
+    if (typeflag === 0 && name && name[name.length - 1] === "/")
+      typeflag = 5;
+    return {
+      name,
+      mode,
+      uid,
+      gid,
+      size,
+      mtime: new Date(1000 * mtime),
+      type,
+      linkname,
+      uname,
+      gname,
+      devmajor,
+      devminor,
+      pax: null
+    };
+  };
+  function isUSTAR(buf) {
+    return b4a.equals(USTAR_MAGIC, buf.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6));
+  }
+  function isGNU(buf) {
+    return b4a.equals(GNU_MAGIC, buf.subarray(MAGIC_OFFSET, MAGIC_OFFSET + 6)) && b4a.equals(GNU_VER, buf.subarray(VERSION_OFFSET, VERSION_OFFSET + 2));
+  }
+  function clamp(index, len, defaultValue) {
+    if (typeof index !== "number")
+      return defaultValue;
+    index = ~~index;
+    if (index >= len)
+      return len;
+    if (index >= 0)
+      return index;
+    index += len;
+    if (index >= 0)
+      return index;
+    return 0;
+  }
+  function toType(flag) {
+    switch (flag) {
+      case 0:
+        return "file";
+      case 1:
+        return "link";
+      case 2:
+        return "symlink";
+      case 3:
+        return "character-device";
+      case 4:
+        return "block-device";
+      case 5:
+        return "directory";
+      case 6:
+        return "fifo";
+      case 7:
+        return "contiguous-file";
+      case 72:
+        return "pax-header";
+      case 55:
+        return "pax-global-header";
+      case 27:
+        return "gnu-long-link-path";
+      case 28:
+      case 30:
+        return "gnu-long-path";
+    }
+    return null;
+  }
+  function toTypeflag(flag) {
+    switch (flag) {
+      case "file":
+        return 0;
+      case "link":
+        return 1;
+      case "symlink":
+        return 2;
+      case "character-device":
+        return 3;
+      case "block-device":
+        return 4;
+      case "directory":
+        return 5;
+      case "fifo":
+        return 6;
+      case "contiguous-file":
+        return 7;
+      case "pax-header":
+        return 72;
+    }
+    return 0;
+  }
+  function indexOf(block, num, offset, end) {
+    for (;offset < end; offset++) {
+      if (block[offset] === num)
+        return offset;
+    }
+    return end;
+  }
+  function cksum(block) {
+    let sum = 8 * 32;
+    for (let i = 0;i < 148; i++)
+      sum += block[i];
+    for (let j = 156;j < 512; j++)
+      sum += block[j];
+    return sum;
+  }
+  function encodeOct(val, n) {
+    val = val.toString(8);
+    if (val.length > n)
+      return SEVENS.slice(0, n) + " ";
+    return ZEROS.slice(0, n - val.length) + val + " ";
+  }
+  function encodeSizeBin(num, buf, off) {
+    buf[off] = 128;
+    for (let i = 11;i > 0; i--) {
+      buf[off + i] = num & 255;
+      num = Math.floor(num / 256);
+    }
+  }
+  function encodeSize(num, buf, off) {
+    if (num.toString(8).length > 11) {
+      encodeSizeBin(num, buf, off);
+    } else {
+      b4a.write(buf, encodeOct(num, 11), off);
+    }
+  }
+  function parse256(buf) {
+    let positive;
+    if (buf[0] === 128)
+      positive = true;
+    else if (buf[0] === 255)
+      positive = false;
+    else
+      return null;
+    const tuple = [];
+    let i;
+    for (i = buf.length - 1;i > 0; i--) {
+      const byte = buf[i];
+      if (positive)
+        tuple.push(byte);
+      else
+        tuple.push(255 - byte);
+    }
+    let sum = 0;
+    const l = tuple.length;
+    for (i = 0;i < l; i++) {
+      sum += tuple[i] * Math.pow(256, i);
+    }
+    return positive ? sum : -1 * sum;
+  }
+  function decodeOct(val, offset, length) {
+    val = val.subarray(offset, offset + length);
+    offset = 0;
+    if (val[offset] & 128) {
+      return parse256(val);
+    } else {
+      while (offset < val.length && val[offset] === 32)
+        offset++;
+      const end = clamp(indexOf(val, 32, offset, val.length), val.length, val.length);
+      while (offset < end && val[offset] === 0)
+        offset++;
+      if (end === offset)
+        return 0;
+      return parseInt(b4a.toString(val.subarray(offset, end)), 8);
+    }
+  }
+  function decodeStr(val, offset, length, encoding) {
+    return b4a.toString(val.subarray(offset, indexOf(val, 0, offset, offset + length)), encoding);
+  }
+  function addLength(str) {
+    const len = b4a.byteLength(str);
+    let digits = Math.floor(Math.log(len) / Math.log(10)) + 1;
+    if (len + digits >= Math.pow(10, digits))
+      digits++;
+    return len + digits + str;
+  }
+});
+
+// ../../node_modules/tar-stream/extract.js
+var require_extract = __commonJS(function(exports, module) {
+  var { Writable, Readable, getStreamError } = require_streamx();
+  var FIFO = require_fast_fifo();
+  var b4a = require_b4a();
+  var headers = require_headers();
+  var EMPTY = b4a.alloc(0);
+
+  class BufferList {
+    constructor() {
+      this.buffered = 0;
+      this.shifted = 0;
+      this.queue = new FIFO;
+      this._offset = 0;
+    }
+    push(buffer) {
+      this.buffered += buffer.byteLength;
+      this.queue.push(buffer);
+    }
+    shiftFirst(size) {
+      return this._buffered === 0 ? null : this._next(size);
+    }
+    shift(size) {
+      if (size > this.buffered)
+        return null;
+      if (size === 0)
+        return EMPTY;
+      let chunk = this._next(size);
+      if (size === chunk.byteLength)
+        return chunk;
+      const chunks = [chunk];
+      while ((size -= chunk.byteLength) > 0) {
+        chunk = this._next(size);
+        chunks.push(chunk);
+      }
+      return b4a.concat(chunks);
+    }
+    _next(size) {
+      const buf = this.queue.peek();
+      const rem = buf.byteLength - this._offset;
+      if (size >= rem) {
+        const sub = this._offset ? buf.subarray(this._offset, buf.byteLength) : buf;
+        this.queue.shift();
+        this._offset = 0;
+        this.buffered -= rem;
+        this.shifted += rem;
+        return sub;
+      }
+      this.buffered -= size;
+      this.shifted += size;
+      return buf.subarray(this._offset, this._offset += size);
+    }
+  }
+
+  class Source extends Readable {
+    constructor(self, header, offset) {
+      super();
+      this.header = header;
+      this.offset = offset;
+      this._parent = self;
+    }
+    _read(cb) {
+      if (this.header.size === 0) {
+        this.push(null);
+      }
+      if (this._parent._stream === this) {
+        this._parent._update();
+      }
+      cb(null);
+    }
+    _predestroy() {
+      this._parent.destroy(getStreamError(this));
+    }
+    _detach() {
+      if (this._parent._stream === this) {
+        this._parent._stream = null;
+        this._parent._missing = overflow(this.header.size);
+        this._parent._update();
+      }
+    }
+    _destroy(cb) {
+      this._detach();
+      cb(null);
+    }
+  }
+
+  class Extract extends Writable {
+    constructor(opts) {
+      super(opts);
+      if (!opts)
+        opts = {};
+      this._buffer = new BufferList;
+      this._offset = 0;
+      this._header = null;
+      this._stream = null;
+      this._missing = 0;
+      this._longHeader = false;
+      this._callback = noop;
+      this._locked = false;
+      this._finished = false;
+      this._pax = null;
+      this._paxGlobal = null;
+      this._gnuLongPath = null;
+      this._gnuLongLinkPath = null;
+      this._filenameEncoding = opts.filenameEncoding || "utf-8";
+      this._allowUnknownFormat = !!opts.allowUnknownFormat;
+      this._unlockBound = this._unlock.bind(this);
+    }
+    _unlock(err) {
+      this._locked = false;
+      if (err) {
+        this.destroy(err);
+        this._continueWrite(err);
+        return;
+      }
+      this._update();
+    }
+    _consumeHeader() {
+      if (this._locked)
+        return false;
+      this._offset = this._buffer.shifted;
+      try {
+        this._header = headers.decode(this._buffer.shift(512), this._filenameEncoding, this._allowUnknownFormat);
+      } catch (err) {
+        this._continueWrite(err);
+        return false;
+      }
+      if (!this._header)
+        return true;
+      switch (this._header.type) {
+        case "gnu-long-path":
+        case "gnu-long-link-path":
+        case "pax-global-header":
+        case "pax-header":
+          this._longHeader = true;
+          this._missing = this._header.size;
+          return true;
+      }
+      this._locked = true;
+      this._applyLongHeaders();
+      if (this._header.size === 0 || this._header.type === "directory") {
+        this.emit("entry", this._header, this._createStream(), this._unlockBound);
+        return true;
+      }
+      this._stream = this._createStream();
+      this._missing = this._header.size;
+      this.emit("entry", this._header, this._stream, this._unlockBound);
+      return true;
+    }
+    _applyLongHeaders() {
+      if (this._gnuLongPath) {
+        this._header.name = this._gnuLongPath;
+        this._gnuLongPath = null;
+      }
+      if (this._gnuLongLinkPath) {
+        this._header.linkname = this._gnuLongLinkPath;
+        this._gnuLongLinkPath = null;
+      }
+      if (this._pax) {
+        if (this._pax.path)
+          this._header.name = this._pax.path;
+        if (this._pax.linkpath)
+          this._header.linkname = this._pax.linkpath;
+        if (this._pax.size)
+          this._header.size = parseInt(this._pax.size, 10);
+        this._header.pax = this._pax;
+        this._pax = null;
+      }
+    }
+    _decodeLongHeader(buf) {
+      switch (this._header.type) {
+        case "gnu-long-path":
+          this._gnuLongPath = headers.decodeLongPath(buf, this._filenameEncoding);
+          break;
+        case "gnu-long-link-path":
+          this._gnuLongLinkPath = headers.decodeLongPath(buf, this._filenameEncoding);
+          break;
+        case "pax-global-header":
+          this._paxGlobal = headers.decodePax(buf);
+          break;
+        case "pax-header":
+          this._pax = this._paxGlobal === null ? headers.decodePax(buf) : Object.assign({}, this._paxGlobal, headers.decodePax(buf));
+          break;
+      }
+    }
+    _consumeLongHeader() {
+      this._longHeader = false;
+      this._missing = overflow(this._header.size);
+      const buf = this._buffer.shift(this._header.size);
+      try {
+        this._decodeLongHeader(buf);
+      } catch (err) {
+        this._continueWrite(err);
+        return false;
+      }
+      return true;
+    }
+    _consumeStream() {
+      const buf = this._buffer.shiftFirst(this._missing);
+      if (buf === null)
+        return false;
+      this._missing -= buf.byteLength;
+      const drained = this._stream.push(buf);
+      if (this._missing === 0) {
+        this._stream.push(null);
+        if (drained)
+          this._stream._detach();
+        return drained && this._locked === false;
+      }
+      return drained;
+    }
+    _createStream() {
+      return new Source(this, this._header, this._offset);
+    }
+    _update() {
+      while (this._buffer.buffered > 0 && !this.destroying) {
+        if (this._missing > 0) {
+          if (this._stream !== null) {
+            if (this._consumeStream() === false)
+              return;
+            continue;
+          }
+          if (this._longHeader === true) {
+            if (this._missing > this._buffer.buffered)
+              break;
+            if (this._consumeLongHeader() === false)
+              return false;
+            continue;
+          }
+          const ignore = this._buffer.shiftFirst(this._missing);
+          if (ignore !== null)
+            this._missing -= ignore.byteLength;
+          continue;
+        }
+        if (this._buffer.buffered < 512)
+          break;
+        if (this._stream !== null || this._consumeHeader() === false)
+          return;
+      }
+      this._continueWrite(null);
+    }
+    _continueWrite(err) {
+      const cb = this._callback;
+      this._callback = noop;
+      cb(err);
+    }
+    _write(data, cb) {
+      this._callback = cb;
+      this._buffer.push(data);
+      this._update();
+    }
+    _final(cb) {
+      this._finished = this._missing === 0 && this._buffer.buffered === 0;
+      cb(this._finished ? null : new Error("Unexpected end of data"));
+    }
+    _predestroy() {
+      this._continueWrite(null);
+    }
+    _destroy(cb) {
+      if (this._stream)
+        this._stream.destroy(getStreamError(this));
+      cb(null);
+    }
+    [Symbol.asyncIterator]() {
+      let error = null;
+      let promiseResolve = null;
+      let promiseReject = null;
+      let entryStream = null;
+      let entryCallback = null;
+      const extract = this;
+      this.on("entry", onentry);
+      this.on("error", (err) => {
+        error = err;
+      });
+      this.on("close", onclose);
+      return {
+        [Symbol.asyncIterator]() {
+          return this;
+        },
+        next() {
+          return new Promise(onnext);
+        },
+        return() {
+          return destroy(null);
+        },
+        throw(err) {
+          return destroy(err);
+        }
+      };
+      function consumeCallback(err) {
+        if (!entryCallback)
+          return;
+        const cb = entryCallback;
+        entryCallback = null;
+        cb(err);
+      }
+      function onnext(resolve, reject) {
+        if (error) {
+          return reject(error);
+        }
+        if (entryStream) {
+          resolve({ value: entryStream, done: false });
+          entryStream = null;
+          return;
+        }
+        promiseResolve = resolve;
+        promiseReject = reject;
+        consumeCallback(null);
+        if (extract._finished && promiseResolve) {
+          promiseResolve({ value: undefined, done: true });
+          promiseResolve = promiseReject = null;
+        }
+      }
+      function onentry(header, stream, callback) {
+        entryCallback = callback;
+        stream.on("error", noop);
+        if (promiseResolve) {
+          promiseResolve({ value: stream, done: false });
+          promiseResolve = promiseReject = null;
+        } else {
+          entryStream = stream;
+        }
+      }
+      function onclose() {
+        consumeCallback(error);
+        if (!promiseResolve)
+          return;
+        if (error)
+          promiseReject(error);
+        else
+          promiseResolve({ value: undefined, done: true });
+        promiseResolve = promiseReject = null;
+      }
+      function destroy(err) {
+        extract.destroy(err);
+        consumeCallback(err);
+        return new Promise((resolve, reject) => {
+          if (extract.destroyed)
+            return resolve({ value: undefined, done: true });
+          extract.once("close", function() {
+            if (err)
+              reject(err);
+            else
+              resolve({ value: undefined, done: true });
+          });
+        });
+      }
+    }
+  }
+  module.exports = function extract(opts) {
+    return new Extract(opts);
+  };
+  function noop() {}
+  function overflow(size) {
+    size &= 511;
+    return size && 512 - size;
+  }
+});
+
+// ../../node_modules/tar-stream/constants.js
+var require_constants = __commonJS(function(exports, module) {
+  var constants = {
+    S_IFMT: 61440,
+    S_IFDIR: 16384,
+    S_IFCHR: 8192,
+    S_IFBLK: 24576,
+    S_IFIFO: 4096,
+    S_IFLNK: 40960
+  };
+  try {
+    module.exports = __require("fs").constants || constants;
+  } catch {
+    module.exports = constants;
+  }
+});
+
+// ../../node_modules/tar-stream/pack.js
+var require_pack = __commonJS(function(exports, module) {
+  var { Readable, Writable, getStreamError } = require_streamx();
+  var b4a = require_b4a();
+  var constants = require_constants();
+  var headers = require_headers();
+  var DMODE = 493;
+  var FMODE = 420;
+  var END_OF_TAR = b4a.alloc(1024);
+
+  class Sink extends Writable {
+    constructor(pack, header, callback) {
+      super({ mapWritable, eagerOpen: true });
+      this.written = 0;
+      this.header = header;
+      this._callback = callback;
+      this._linkname = null;
+      this._isLinkname = header.type === "symlink" && !header.linkname;
+      this._isVoid = header.type !== "file" && header.type !== "contiguous-file";
+      this._finished = false;
+      this._pack = pack;
+      this._openCallback = null;
+      if (this._pack._stream === null)
+        this._pack._stream = this;
+      else
+        this._pack._pending.push(this);
+    }
+    _open(cb) {
+      this._openCallback = cb;
+      if (this._pack._stream === this)
+        this._continueOpen();
+    }
+    _continuePack(err) {
+      if (this._callback === null)
+        return;
+      const callback = this._callback;
+      this._callback = null;
+      callback(err);
+    }
+    _continueOpen() {
+      if (this._pack._stream === null)
+        this._pack._stream = this;
+      const cb = this._openCallback;
+      this._openCallback = null;
+      if (cb === null)
+        return;
+      if (this._pack.destroying)
+        return cb(new Error("pack stream destroyed"));
+      if (this._pack._finalized)
+        return cb(new Error("pack stream is already finalized"));
+      this._pack._stream = this;
+      if (!this._isLinkname) {
+        this._pack._encode(this.header);
+      }
+      if (this._isVoid) {
+        this._finish();
+        this._continuePack(null);
+      }
+      cb(null);
+    }
+    _write(data, cb) {
+      if (this._isLinkname) {
+        this._linkname = this._linkname ? b4a.concat([this._linkname, data]) : data;
+        return cb(null);
+      }
+      if (this._isVoid) {
+        if (data.byteLength > 0) {
+          return cb(new Error("No body allowed for this entry"));
+        }
+        return cb();
+      }
+      this.written += data.byteLength;
+      if (this._pack.push(data))
+        return cb();
+      this._pack._drain = cb;
+    }
+    _finish() {
+      if (this._finished)
+        return;
+      this._finished = true;
+      if (this._isLinkname) {
+        this.header.linkname = this._linkname ? b4a.toString(this._linkname, "utf-8") : "";
+        this._pack._encode(this.header);
+      }
+      overflow(this._pack, this.header.size);
+      this._pack._done(this);
+    }
+    _final(cb) {
+      if (this.written !== this.header.size) {
+        return cb(new Error("Size mismatch"));
+      }
+      this._finish();
+      cb(null);
+    }
+    _getError() {
+      return getStreamError(this) || new Error("tar entry destroyed");
+    }
+    _predestroy() {
+      this._pack.destroy(this._getError());
+    }
+    _destroy(cb) {
+      this._pack._done(this);
+      this._continuePack(this._finished ? null : this._getError());
+      cb();
+    }
+  }
+
+  class Pack extends Readable {
+    constructor(opts) {
+      super(opts);
+      this._drain = noop;
+      this._finalized = false;
+      this._finalizing = false;
+      this._pending = [];
+      this._stream = null;
+    }
+    entry(header, buffer, callback) {
+      if (this._finalized || this.destroying)
+        throw new Error("already finalized or destroyed");
+      if (typeof buffer === "function") {
+        callback = buffer;
+        buffer = null;
+      }
+      if (!callback)
+        callback = noop;
+      if (!header.size || header.type === "symlink")
+        header.size = 0;
+      if (!header.type)
+        header.type = modeToType(header.mode);
+      if (!header.mode)
+        header.mode = header.type === "directory" ? DMODE : FMODE;
+      if (!header.uid)
+        header.uid = 0;
+      if (!header.gid)
+        header.gid = 0;
+      if (!header.mtime)
+        header.mtime = new Date;
+      if (typeof buffer === "string")
+        buffer = b4a.from(buffer);
+      const sink = new Sink(this, header, callback);
+      if (b4a.isBuffer(buffer)) {
+        header.size = buffer.byteLength;
+        sink.write(buffer);
+        sink.end();
+        return sink;
+      }
+      if (sink._isVoid) {
+        return sink;
+      }
+      return sink;
+    }
+    finalize() {
+      if (this._stream || this._pending.length > 0) {
+        this._finalizing = true;
+        return;
+      }
+      if (this._finalized)
+        return;
+      this._finalized = true;
+      this.push(END_OF_TAR);
+      this.push(null);
+    }
+    _done(stream) {
+      if (stream !== this._stream)
+        return;
+      this._stream = null;
+      if (this._finalizing)
+        this.finalize();
+      if (this._pending.length)
+        this._pending.shift()._continueOpen();
+    }
+    _encode(header) {
+      if (!header.pax) {
+        const buf = headers.encode(header);
+        if (buf) {
+          this.push(buf);
+          return;
+        }
+      }
+      this._encodePax(header);
+    }
+    _encodePax(header) {
+      const paxHeader = headers.encodePax({
+        name: header.name,
+        linkname: header.linkname,
+        pax: header.pax
+      });
+      const newHeader = {
+        name: "PaxHeader",
+        mode: header.mode,
+        uid: header.uid,
+        gid: header.gid,
+        size: paxHeader.byteLength,
+        mtime: header.mtime,
+        type: "pax-header",
+        linkname: header.linkname && "PaxHeader",
+        uname: header.uname,
+        gname: header.gname,
+        devmajor: header.devmajor,
+        devminor: header.devminor
+      };
+      this.push(headers.encode(newHeader));
+      this.push(paxHeader);
+      overflow(this, paxHeader.byteLength);
+      newHeader.size = header.size;
+      newHeader.type = header.type;
+      this.push(headers.encode(newHeader));
+    }
+    _doDrain() {
+      const drain = this._drain;
+      this._drain = noop;
+      drain();
+    }
+    _predestroy() {
+      const err = getStreamError(this);
+      if (this._stream)
+        this._stream.destroy(err);
+      while (this._pending.length) {
+        const stream = this._pending.shift();
+        stream.destroy(err);
+        stream._continueOpen();
+      }
+      this._doDrain();
+    }
+    _read(cb) {
+      this._doDrain();
+      cb();
+    }
+  }
+  module.exports = function pack(opts) {
+    return new Pack(opts);
+  };
+  function modeToType(mode) {
+    switch (mode & constants.S_IFMT) {
+      case constants.S_IFBLK:
+        return "block-device";
+      case constants.S_IFCHR:
+        return "character-device";
+      case constants.S_IFDIR:
+        return "directory";
+      case constants.S_IFIFO:
+        return "fifo";
+      case constants.S_IFLNK:
+        return "symlink";
+    }
+    return "file";
+  }
+  function noop() {}
+  function overflow(self, size) {
+    size &= 511;
+    if (size)
+      self.push(END_OF_TAR.subarray(0, 512 - size));
+  }
+  function mapWritable(buf) {
+    return b4a.isBuffer(buf) ? buf : b4a.from(buf);
+  }
+});
+
 // src/auth.ts
 import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
@@ -575,7 +3024,7 @@ function getConfigFile() {
 function getConfigFileForHome(home) {
   return join(getAidentDir(home), "config.json");
 }
-var DEFAULT_BASE_URL = "https://loadout.aident.ai"?.trim() || "https://loadout.aident.ai";
+var DEFAULT_BASE_URL = "https://staging.loadout.aident.ai"?.trim() || "https://loadout.aident.ai";
 var CONFIG_KEYS = ["baseUrl", "packages"];
 async function readConfig(configFile = getConfigFile()) {
   try {
@@ -4679,7 +7128,7 @@ function serializeLoadoutSkillPackage(skillPackage) {
 }
 
 // src/version.ts
-var VERSION = "0.3.0";
+var VERSION = "0.3.1-staging.ci.34903740288.1";
 var DESKTOP_VERSION = process.env.AIDENT_DESKTOP_VERSION?.trim() || undefined;
 var DESKTOP_CHANNEL = parseDesktopChannel(process.env.AIDENT_DESKTOP_CHANNEL);
 function parseDesktopChannel(value) {
@@ -5883,7 +8332,7 @@ var LoadoutFavoriteSkillsUpdateSchema = objectType({
   syncRequired: booleanType()
 }).strict();
 function getLoadoutFavoriteSkillsStateToken(skills) {
-  const state = skills.map(({ name, artifactVersionId }) => ({ name, artifactVersionId })).sort((left, right) => left.name.localeCompare(right.name));
+  const state = skills.map(({ name, artifactVersionId, deliveryRevision }) => ({ name, artifactVersionId, deliveryRevision })).sort((left, right) => left.name.localeCompare(right.name));
   return createHash2("sha256").update(JSON.stringify(state)).digest("hex");
 }
 
@@ -6619,11 +9068,464 @@ function isExpired(creds) {
 }
 
 // src/loadoutFavoriteSkills.ts
-import { createHash as createHash4 } from "node:crypto";
-import { lstat as lstat4, mkdir as mkdir6, readFile as readFile7, readlink, rename as rename3, rm as rm2, symlink as symlink2, writeFile as writeFile6 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
+import { createHash as createHash5 } from "node:crypto";
+import { cp, lstat as lstat5, mkdir as mkdir8, readFile as readFile8, readlink, rename as rename4, rm as rm3, symlink as symlink3, writeFile as writeFile6 } from "node:fs/promises";
+import { homedir as homedir5 } from "node:os";
 import path from "node:path";
 
+// src/agentSkillBundles.ts
+import { createHash as createHash4, randomUUID as randomUUID3 } from "node:crypto";
+import { existsSync as existsSync2 } from "node:fs";
+import { lstat as lstat4, mkdir as mkdir7, mkdtemp, readFile as readFile7, realpath as realpath3, rename as rename3, rm as rm2, symlink as symlink2 } from "node:fs/promises";
+import { homedir as homedir4 } from "node:os";
+import { dirname as dirname6, join as join8, resolve as resolve3, sep as sep2 } from "node:path";
+
+// ../web/shared/agentSkills/AgentSkillBundleArchive.ts
+import { createWriteStream } from "node:fs";
+import { mkdir as mkdir6 } from "node:fs/promises";
+import { dirname as dirname5, posix as posix2, resolve as resolve2, sep } from "node:path";
+import { Readable, Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { createGunzip } from "node:zlib";
+
+// ../../node_modules/tar-stream/index.js
+var $extract = require_extract();
+var $pack = require_pack();
+
+// ../web/shared/agentSkills/AgentSkillBundleSchemas.ts
+var AGENT_SKILL_BUNDLE_BUCKET = "agent-skill-bundles";
+var AGENT_SKILL_BUNDLE_MAX_ARCHIVE_BYTES = 128 * 1024 * 1024;
+var AGENT_SKILL_BUNDLE_MAX_UNPACKED_BYTES = 256 * 1024 * 1024;
+var AGENT_SKILL_BUNDLE_MAX_FILES = 5000;
+var AgentSkillBundleReleaseStatus;
+((AgentSkillBundleReleaseStatus) => {
+  AgentSkillBundleReleaseStatus["Active"] = "active";
+  AgentSkillBundleReleaseStatus["Retired"] = "retired";
+})(AgentSkillBundleReleaseStatus ||= {});
+var AgentSkillBundleRightsBasis;
+((AgentSkillBundleRightsBasis) => {
+  AgentSkillBundleRightsBasis["AidentOwned"] = "aident-owned";
+  AgentSkillBundleRightsBasis["AuthorizedInternalUse"] = "authorized-internal-use";
+})(AgentSkillBundleRightsBasis ||= {});
+var AgentSkillBundleNameSchema = stringType().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(80);
+var AgentSkillBundleVersionSchema = stringType().regex(/^[0-9]+\.[0-9]+\.[0-9]+(?:[+-][0-9A-Za-z.-]+)?$/).max(80);
+var AgentSkillBundleSha256Schema = stringType().regex(/^[a-f0-9]{64}$/);
+var AgentSkillBundleGitShaSchema = stringType().regex(/^[a-f0-9]{40}$/);
+var AgentSkillBundleRightsBasisSchema = nativeEnumType(AgentSkillBundleRightsBasis);
+var AgentSkillBundlePublishManifestSchema = objectType({
+  name: AgentSkillBundleNameSchema,
+  version: AgentSkillBundleVersionSchema,
+  sourceOwner: stringType().regex(/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/).max(39).refine((value) => !value.includes("--")),
+  sourceRepository: stringType().regex(/^[A-Za-z0-9_.][A-Za-z0-9_.-]{0,99}$/).refine((value) => value !== "." && value !== ".."),
+  sourceCommit: AgentSkillBundleGitShaSchema,
+  sourceTree: AgentSkillBundleGitShaSchema,
+  expectedSha256: AgentSkillBundleSha256Schema,
+  expectedBytes: numberType().int().positive().max(AGENT_SKILL_BUNDLE_MAX_ARCHIVE_BYTES),
+  rightsBasis: AgentSkillBundleRightsBasisSchema,
+  rightsNotice: stringType().min(1).max(2000)
+});
+var AgentSkillBundlePublishInputSchema = objectType({
+  manifest: AgentSkillBundlePublishManifestSchema
+});
+var AgentSkillBundleInstallInputSchema = objectType({
+  name: AgentSkillBundleNameSchema,
+  version: AgentSkillBundleVersionSchema.optional()
+});
+var AgentSkillBundleListInputSchema = objectType({
+  name: AgentSkillBundleNameSchema.optional(),
+  status: nativeEnumType(AgentSkillBundleReleaseStatus).default("active" /* Active */)
+});
+var AgentSkillBundleReleaseSchema = objectType({
+  id: stringType().uuid(),
+  name: AgentSkillBundleNameSchema,
+  version: AgentSkillBundleVersionSchema,
+  status: nativeEnumType(AgentSkillBundleReleaseStatus),
+  artifactSha256: AgentSkillBundleSha256Schema,
+  artifactBytes: numberType().int().positive(),
+  storageBucket: literalType(AGENT_SKILL_BUNDLE_BUCKET),
+  storageObjectPath: stringType().min(1),
+  sourceOwner: stringType(),
+  sourceRepository: stringType(),
+  sourceCommit: AgentSkillBundleGitShaSchema,
+  sourceTree: AgentSkillBundleGitShaSchema,
+  rightsBasis: AgentSkillBundleRightsBasisSchema,
+  rightsNotice: stringType(),
+  publishedAt: stringType().datetime()
+});
+var AgentSkillBundleInstallDescriptorSchema = AgentSkillBundleReleaseSchema.omit({
+  id: true,
+  status: true,
+  storageBucket: true,
+  storageObjectPath: true,
+  rightsNotice: true
+}).extend({
+  artifactUrl: stringType().url(),
+  expiresAt: stringType().datetime()
+});
+
+// ../web/shared/agentSkills/AgentSkillBundleArchive.ts
+var MAX_SKILL_ENTRYPOINT_BYTES = 64 * 1024;
+async function extractAgentSkillBundleArchive(archive, expectedSkillName, destination) {
+  await mkdir6(destination, { recursive: true, mode: 448 });
+  return processArchive(archive, expectedSkillName, destination);
+}
+async function processArchive(archive, expectedSkillName, destination) {
+  AgentSkillBundleNameSchema.parse(expectedSkillName);
+  const seenPaths = new Set;
+  const rootNames = new Set;
+  let fileCount = 0;
+  let unpackedBytes = 0;
+  let rootSkillContent = null;
+  let extractionError = null;
+  const tarExtractor = $extract();
+  tarExtractor.on("error", (error) => {
+    extractionError = error instanceof Error ? error : new Error(String(error));
+  });
+  tarExtractor.on("entry", (header, stream, next) => {
+    stream.on("error", (error) => {
+      extractionError = error instanceof Error ? error : new Error(String(error));
+    });
+    (async () => {
+      try {
+        const relativePath = normalizeArchivePath(header.name);
+        if (!relativePath) {
+          stream.resume();
+          await onceEnded(stream);
+          next();
+          return;
+        }
+        if (seenPaths.has(relativePath))
+          throw new Error(`Duplicate agent Skill archive entry: ${relativePath}`);
+        seenPaths.add(relativePath);
+        rootNames.add(relativePath.split("/")[0]);
+        if (rootNames.size > 1)
+          throw new Error("Agent Skill archive must contain exactly one root directory");
+        if (header.type !== "file" && header.type !== "directory") {
+          throw new Error(`Unsupported agent Skill archive entry type: ${header.type ?? "unknown"}`);
+        }
+        if (header.type === "directory") {
+          if (destination)
+            await mkdir6(resolveDestination(destination, relativePath), { recursive: true, mode: 448 });
+          stream.resume();
+          await onceEnded(stream);
+          next();
+          return;
+        }
+        fileCount++;
+        if (fileCount > AGENT_SKILL_BUNDLE_MAX_FILES)
+          throw new Error("Agent Skill archive contains too many files");
+        const entrySize = header.size ?? 0;
+        unpackedBytes += entrySize;
+        if (unpackedBytes > AGENT_SKILL_BUNDLE_MAX_UNPACKED_BYTES) {
+          throw new Error("Agent Skill archive exceeds the unpacked size limit");
+        }
+        const rootName = relativePath.split("/")[0];
+        const isRootSkillEntrypoint = relativePath === `${rootName}/SKILL.md`;
+        if (isRootSkillEntrypoint && entrySize > MAX_SKILL_ENTRYPOINT_BYTES) {
+          throw new Error("Agent Skill entrypoint exceeds the size limit");
+        }
+        const chunks = [];
+        const capture = new Transform({
+          transform(chunk, _encoding, callback) {
+            if (isRootSkillEntrypoint)
+              chunks.push(Buffer.from(chunk));
+            callback(null, chunk);
+          }
+        });
+        if (destination) {
+          const outputPath = resolveDestination(destination, relativePath);
+          await mkdir6(dirname5(outputPath), { recursive: true, mode: 448 });
+          await pipeline(stream, capture, createWriteStream(outputPath, { flags: "wx", mode: safeFileMode(header) }));
+        } else {
+          await pipeline(stream, capture, new Transform({
+            transform(_chunk, _encoding, callback) {
+              callback();
+            }
+          }));
+        }
+        if (isRootSkillEntrypoint)
+          rootSkillContent = Buffer.concat(chunks).toString("utf8");
+        next();
+      } catch (error) {
+        stream.resume();
+        next(error);
+      }
+    })();
+  });
+  try {
+    await pipeline(Readable.from(archive), createGunzip(), tarExtractor);
+  } catch (error) {
+    throw extractionError ?? error;
+  }
+  const rootDirectory = Array.from(rootNames)[0];
+  if (!rootDirectory)
+    throw new Error("Agent Skill archive is empty");
+  if (!rootSkillContent)
+    throw new Error("Agent Skill archive is missing its root SKILL.md");
+  const skillName = readSkillName(rootSkillContent);
+  if (skillName !== expectedSkillName) {
+    throw new Error(`Agent Skill archive identity mismatch: expected ${expectedSkillName}, received ${skillName}`);
+  }
+  return { fileCount, rootDirectory, skillName, unpackedBytes };
+}
+function normalizeArchivePath(value) {
+  const withoutPrefix = value.replace(/^\.\//, "").replace(/\/$/, "");
+  const normalized = posix2.normalize(withoutPrefix);
+  if (!withoutPrefix)
+    return "";
+  if (withoutPrefix.includes("\\") || withoutPrefix.includes("\x00") || posix2.isAbsolute(withoutPrefix) || normalized === ".." || normalized.startsWith("../") || normalized !== withoutPrefix || withoutPrefix.length > 500) {
+    throw new Error(`Unsafe agent Skill archive path: ${value}`);
+  }
+  return normalized;
+}
+function resolveDestination(destination, relativePath) {
+  const root = resolve2(destination);
+  const output = resolve2(root, ...relativePath.split("/"));
+  if (output !== root && !output.startsWith(`${root}${sep}`)) {
+    throw new Error(`Agent Skill archive path escapes its destination: ${relativePath}`);
+  }
+  return output;
+}
+function safeFileMode(header) {
+  return (header.mode ?? 420) & 493;
+}
+function readSkillName(content) {
+  const frontmatter = content.match(/^---\n([\s\S]*?)\n---(?:\n|$)/)?.[1];
+  const name = frontmatter?.match(/^name:\s*["']?([^\s"']+)["']?\s*$/m)?.[1];
+  if (!name)
+    throw new Error("Agent Skill SKILL.md is missing a frontmatter name");
+  return AgentSkillBundleNameSchema.parse(name);
+}
+function onceEnded(stream) {
+  return new Promise((resolvePromise, reject) => {
+    stream.once("end", resolvePromise);
+    stream.once("error", reject);
+  });
+}
+
+// src/agentSkillBundles.ts
+async function installAgentSkillBundle(descriptorValue, options = {}, injected = {}) {
+  const descriptor = AgentSkillBundleInstallDescriptorSchema.parse(descriptorValue);
+  const home = options.home ?? homedir4();
+  const env = options.env ?? process.env;
+  return withInstallLock(descriptor.name, home, async () => {
+    const { releaseDirectory } = await prepareRelease(descriptor, home, injected.fetch ?? fetch);
+    const targets = await reconcileTargets(descriptor.name, releaseDirectory, dirname6(releaseDirectory), home, env);
+    return {
+      name: descriptor.name,
+      version: descriptor.version,
+      artifactSha256: descriptor.artifactSha256,
+      releaseDirectory,
+      success: targets.every((target) => target.status !== "conflict" /* Conflict */ && target.status !== "failed" /* Failed */),
+      targets
+    };
+  });
+}
+async function prepareAgentSkillBundleRelease(descriptorValue, options = {}, injected = {}) {
+  const descriptor = AgentSkillBundleInstallDescriptorSchema.parse(descriptorValue);
+  const home = options.home ?? homedir4();
+  return withInstallLock(descriptor.name, home, () => prepareRelease(descriptor, home, injected.fetch ?? fetch));
+}
+async function prepareRelease(descriptor, home, fetchImpl) {
+  const stateRoot = join8(home, ".aident", "skills", "internal", descriptor.name);
+  const releasesRoot = join8(stateRoot, "releases");
+  const releaseDirectory = join8(releasesRoot, descriptor.artifactSha256);
+  if (!await pathExists2(releaseDirectory)) {
+    const archive = await downloadArchive(descriptor, fetchImpl);
+    await materializeRelease(archive, descriptor, releasesRoot, releaseDirectory);
+  } else {
+    const existingRelease = await lstat4(releaseDirectory);
+    if (!existingRelease.isDirectory()) {
+      throw new Error(`Existing agent Skill release is not a directory: ${releaseDirectory}`);
+    }
+    await assertInstalledSkillIdentity(releaseDirectory, descriptor.name);
+  }
+  return { descriptor, releaseDirectory };
+}
+async function withInstallLock(name, home, run) {
+  const stateRoot = join8(home, ".aident", "skills", "internal", name);
+  await mkdir7(stateRoot, { recursive: true, mode: 448 });
+  const lock = await tryAcquireDirectoryLock(join8(stateRoot, "install.lock"));
+  if (!lock)
+    throw new Error(`Another ${name} installation is already running`);
+  try {
+    return await run();
+  } finally {
+    await lock.release();
+  }
+}
+async function genInstallAgentSkillBundleCommandResult(resolved, result, install = installAgentSkillBundle) {
+  if (resolved.domain !== "admin:agent-skills" || resolved.command !== "install" || !result.body.success)
+    return result;
+  try {
+    const installed = await install(result.body.data);
+    return {
+      ...result,
+      body: installed.success ? { success: true, data: installed } : {
+        success: false,
+        data: installed,
+        error: {
+          code: "agent-skill-install-incomplete",
+          message: "Some local Skill targets were preserved or failed"
+        }
+      }
+    };
+  } catch (error) {
+    return {
+      ...result,
+      body: {
+        success: false,
+        error: {
+          code: "agent-skill-install-failed",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      }
+    };
+  }
+}
+async function downloadArchive(descriptor, fetchImpl) {
+  const response = await fetchImpl(descriptor.artifactUrl, { signal: AbortSignal.timeout(5 * 60 * 1000) });
+  if (!response.ok)
+    throw new Error(`Failed to download ${descriptor.name}: HTTP ${response.status}`);
+  const contentLength = response.headers.get("content-length");
+  if (contentLength && Number(contentLength) !== descriptor.artifactBytes) {
+    throw new Error(`Agent Skill archive size mismatch: expected ${descriptor.artifactBytes}, received ${contentLength}`);
+  }
+  if (descriptor.artifactBytes > AGENT_SKILL_BUNDLE_MAX_ARCHIVE_BYTES) {
+    throw new Error("Agent Skill archive exceeds the compressed size limit");
+  }
+  const archive = Buffer.from(await response.arrayBuffer());
+  if (archive.length !== descriptor.artifactBytes) {
+    throw new Error(`Agent Skill archive size mismatch: expected ${descriptor.artifactBytes}, received ${archive.length}`);
+  }
+  const digest = createHash4("sha256").update(archive).digest("hex");
+  if (digest !== descriptor.artifactSha256) {
+    throw new Error(`Agent Skill archive digest mismatch: expected ${descriptor.artifactSha256}, received ${digest}`);
+  }
+  return archive;
+}
+async function materializeRelease(archive, descriptor, releasesRoot, releaseDirectory) {
+  await mkdir7(releasesRoot, { recursive: true, mode: 448 });
+  const transactionRoot = await mkdtemp(join8(stateParent(releasesRoot), ".install-"));
+  const extractRoot = join8(transactionRoot, "extract");
+  try {
+    const inspection = await extractAgentSkillBundleArchive(archive, descriptor.name, extractRoot);
+    const sourceDirectory = join8(extractRoot, inspection.rootDirectory);
+    await assertInstalledSkillIdentity(sourceDirectory, descriptor.name);
+    await rename3(sourceDirectory, releaseDirectory);
+  } finally {
+    await rm2(transactionRoot, { recursive: true, force: true });
+  }
+}
+async function reconcileTargets(name, releaseDirectory, releasesRoot, home, env) {
+  const roots = getGlobalLoadoutSkillHostRoots(home, env);
+  const canonical = roots.find((root) => root.canonical);
+  if (!canonical)
+    throw new Error("Canonical Aident Skill host is unavailable");
+  const detectedWorkBuddyRoots = new Set(getDetectedWorkBuddySkillHostRoots(home, env).map((root) => resolve3(root)));
+  const selected = roots.filter((root) => root.canonical || existsSync2(root.root) || root.agent === "workbuddy" /* WorkBuddy */ && detectedWorkBuddyRoots.has(resolve3(root.root)));
+  const results = [];
+  const canonicalPath = join8(canonical.root, "skills", name);
+  results.push(await reconcileTarget(canonical.agent, canonicalPath, releaseDirectory, releasesRoot));
+  if (results[0]?.status !== "current" /* Current */ && results[0]?.status !== "installed" /* Installed */ && results[0]?.status !== "updated" /* Updated */) {
+    return results;
+  }
+  for (const root of selected) {
+    if (root.canonical)
+      continue;
+    results.push(await reconcileTarget(root.agent, join8(root.root, "skills", name), canonicalPath, releasesRoot));
+  }
+  return results;
+}
+async function reconcileTarget(agent, target, desired, releasesRoot) {
+  const desiredRealPath = await realpath3(desired);
+  const currentRealPath = await realpath3(target).catch(() => null);
+  if (currentRealPath === desiredRealPath) {
+    return { agent, path: target, status: "current" /* Current */ };
+  }
+  const existing = await lstat4(target).catch((error) => {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  });
+  if (existing) {
+    const managedRoot = await realpath3(releasesRoot);
+    if (!existing.isSymbolicLink() || !currentRealPath || !isInside(managedRoot, currentRealPath)) {
+      return {
+        agent,
+        path: target,
+        status: "conflict" /* Conflict */,
+        detail: "Existing target is not an Aident-managed internal Skill release"
+      };
+    }
+  }
+  try {
+    await switchManagedLink(target, desired, !!existing);
+    return {
+      agent,
+      path: target,
+      status: existing ? "updated" /* Updated */ : "installed" /* Installed */
+    };
+  } catch (error) {
+    return {
+      agent,
+      path: target,
+      status: "failed" /* Failed */,
+      detail: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+async function switchManagedLink(target, desired, exists) {
+  await mkdir7(dirname6(target), { recursive: true, mode: 448 });
+  const token = randomUUID3();
+  const temporary = `${target}.${token}.tmp`;
+  const backup = `${target}.${token}.backup`;
+  await symlink2(desired, temporary, process.platform === "win32" ? "junction" : "dir");
+  if (!exists) {
+    try {
+      await rename3(temporary, target);
+    } catch (error) {
+      await rm2(temporary, { force: true });
+      throw error;
+    }
+    return;
+  }
+  await rename3(target, backup);
+  try {
+    await rename3(temporary, target);
+    await rm2(backup, { force: true });
+  } catch (error) {
+    await rm2(temporary, { force: true });
+    await rename3(backup, target);
+    throw error;
+  }
+}
+async function assertInstalledSkillIdentity(directory, expectedName) {
+  const content = await readFile7(join8(directory, "SKILL.md"), "utf8");
+  const frontmatter = content.match(/^---\n([\s\S]*?)\n---(?:\n|$)/)?.[1];
+  const name = frontmatter?.match(/^name:\s*["']?([^\s"']+)["']?\s*$/m)?.[1];
+  if (name !== expectedName)
+    throw new Error(`Installed agent Skill identity mismatch: expected ${expectedName}`);
+}
+async function pathExists2(path) {
+  try {
+    await lstat4(path);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return false;
+    throw error;
+  }
+}
+function stateParent(releasesRoot) {
+  return dirname6(releasesRoot);
+}
+function isInside(root, value) {
+  const resolvedRoot = resolve3(root);
+  const resolvedValue = resolve3(value);
+  return resolvedValue === resolvedRoot || resolvedValue.startsWith(`${resolvedRoot}${sep2}`);
+}
+
 // ../web/shared/integrations/LoadoutSkillConstants.ts
 var LOADOUT_SKILL_ENTRYPOINT = "SKILL.md";
 var LOADOUT_SKILL_PLATFORM_SECTION_HEADING = "Aident Loadout Platform";
@@ -6650,7 +9552,7 @@ function isCanonicalUuid(value) {
   return value === value.toLowerCase() && extractUUID(value) === value;
 }
 function getHome() {
-  return process.env.HOME || process.env.USERPROFILE || homedir4();
+  return process.env.HOME || process.env.USERPROFILE || homedir5();
 }
 function getCanonicalRoot(home, env) {
   return path.join(getGlobalLoadoutSkillHostRoots(home, env).find(({ canonical }) => canonical).root, "skills");
@@ -6693,12 +9595,14 @@ function assertPackage(pkg) {
     packageBytes += bytes;
     if (bytes !== file.sizeBytes)
       throw new Error(`Size mismatch: ${pkg.name}/${file.path}`);
-    if (createHash4("sha256").update(file.content).digest("hex") !== file.contentDigest) {
+    if (createHash5("sha256").update(file.content).digest("hex") !== file.contentDigest) {
       throw new Error(`Digest mismatch: ${pkg.name}/${file.path}`);
     }
   }
   if (packageBytes > LOADOUT_SKILL_MAX_PACKAGE_BYTES)
     throw new Error(`Package is too large: ${pkg.name}`);
+  if (pkg.bundle)
+    AgentSkillBundleInstallDescriptorSchema.parse(pkg.bundle);
 }
 function quoteYaml(value) {
   return JSON.stringify(value);
@@ -6724,9 +9628,9 @@ function entrypointContent(pkg, content) {
   ].join(`
 `);
 }
-async function pathExists2(target) {
+async function pathExists3(target) {
   try {
-    await lstat4(target);
+    await lstat5(target);
     return true;
   } catch (error) {
     if (error.code === "ENOENT")
@@ -6736,12 +9640,12 @@ async function pathExists2(target) {
 }
 async function readManifest(home, env) {
   try {
-    const value = JSON.parse(await readFile7(getManifestPath(home), "utf8"));
+    const value = JSON.parse(await readFile8(getManifestPath(home), "utf8"));
     if (value.version !== MANIFEST_VERSION || !Array.isArray(value.skills))
       throw new Error("Unsupported manifest");
     const harnessRoots = new Set(getHarnessHosts(home, env).map(({ root }) => path.join(root, "skills")));
     for (const skill of value.skills) {
-      if (!LOADOUT_SKILL_NAME_PATTERN.test(skill.name) || !isCanonicalUuid(skill.artifactVersionId) || skill.displayName !== undefined && typeof skill.displayName !== "string" || skill.summary !== undefined && typeof skill.summary !== "string" || !/^loadout-[a-z0-9-]+-[0-9a-f]{8}$/.test(skill.commandName) || skill.installPath !== path.join(getCanonicalRoot(home, env), skill.commandName) || skill.linkPaths.some((linkPath) => !harnessRoots.has(path.dirname(linkPath)) || path.basename(linkPath) !== skill.commandName)) {
+      if (!LOADOUT_SKILL_NAME_PATTERN.test(skill.name) || !isCanonicalUuid(skill.artifactVersionId) || skill.displayName !== undefined && typeof skill.displayName !== "string" || skill.summary !== undefined && typeof skill.summary !== "string" || skill.deliveryRevision !== undefined && !/^[a-f0-9]{64}$/.test(skill.deliveryRevision) || !/^loadout-[a-z0-9-]+-[0-9a-f]{8}$/.test(skill.commandName) || skill.installPath !== path.join(getCanonicalRoot(home, env), skill.commandName) || skill.linkPaths.some((linkPath) => !harnessRoots.has(path.dirname(linkPath)) || path.basename(linkPath) !== skill.commandName)) {
         throw new Error("Invalid favorite Skills ownership manifest");
       }
     }
@@ -6759,23 +9663,27 @@ async function getInstalledLoadoutFavoriteSkillsStateToken(home = getHome(), env
 async function writeManifest(home, manifest) {
   const manifestPath = getManifestPath(home);
   const temporaryPath = `${manifestPath}.${process.pid}.tmp`;
-  await mkdir6(path.dirname(manifestPath), { recursive: true, mode: 448 });
+  await mkdir8(path.dirname(manifestPath), { recursive: true, mode: 448 });
   await writeFile6(temporaryPath, `${JSON.stringify(manifest, null, 2)}
 `, { mode: 384 });
-  await rename3(temporaryPath, manifestPath);
+  await rename4(temporaryPath, manifestPath);
 }
 async function removeOwnedSkill(skill) {
   for (const linkPath of skill.linkPaths) {
-    if (!await pathExists2(linkPath))
+    if (!await pathExists3(linkPath))
       continue;
-    const stat = await lstat4(linkPath);
+    const stat = await lstat5(linkPath);
     if (stat.isSymbolicLink())
-      await rm2(linkPath);
+      await rm3(linkPath);
   }
-  if (await pathExists2(skill.installPath))
-    await rm2(skill.installPath, { recursive: true });
+  if (await pathExists3(skill.installPath))
+    await rm3(skill.installPath, { recursive: true });
 }
-async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = process.env) {
+async function writeBundlePackage(directory, pkg, releaseDirectory) {
+  await cp(releaseDirectory, directory, { recursive: true });
+  await writeFile6(path.join(directory, LOADOUT_SKILL_ENTRYPOINT), entrypointContent(pkg, await readFile8(path.join(releaseDirectory, LOADOUT_SKILL_ENTRYPOINT), "utf8")));
+}
+async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = process.env, injected = {}) {
   const manifest = await readManifest(home, env);
   const previousByName = new Map(manifest.skills.map((skill) => [skill.name, skill]));
   const desiredNames = new Set(payload.packages.map((pkg) => pkg.name));
@@ -6790,6 +9698,12 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
   if (payload.unavailable.some((name) => desiredNames.has(name))) {
     throw new Error("A favorite Skill cannot be both available and unavailable");
   }
+  const preparedBundles = new Map;
+  for (const pkg of payload.packages) {
+    if (!pkg.bundle)
+      continue;
+    preparedBundles.set(pkg.name, await (injected.prepareBundleRelease ?? prepareAgentSkillBundleRelease)(pkg.bundle, { home, env }));
+  }
   const nextSkills = [];
   const result = {
     installed: [],
@@ -6811,13 +9725,13 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
     const installPath = path.join(getCanonicalRoot(home, env), nextCommandName);
     const linkPaths = getHarnessRoots(home, env).map((root) => path.join(root, nextCommandName));
     const conflictingPath = (await Promise.all([installPath, ...linkPaths].map(async (candidate) => {
-      if (!await pathExists2(candidate))
+      if (!await pathExists3(candidate))
         return null;
       if (previous && candidate === previous.installPath) {
-        return (await lstat4(candidate)).isDirectory() ? null : candidate;
+        return (await lstat5(candidate)).isDirectory() ? null : candidate;
       }
       if (previous && previous.linkPaths.includes(candidate)) {
-        const stat = await lstat4(candidate);
+        const stat = await lstat5(candidate);
         if (!stat.isSymbolicLink())
           return candidate;
         return path.resolve(path.dirname(candidate), await readlink(candidate)) === previous.installPath ? null : candidate;
@@ -6830,45 +9744,50 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
         nextSkills.push(previous);
       continue;
     }
-    const allLinksExist = (await Promise.all(linkPaths.map(pathExists2))).every(Boolean);
-    if (previous?.artifactVersionId === pkg.artifactVersionId && previous.displayName === pkg.displayName && previous.summary === pkg.summary && previous.installPath === installPath && previous.linkPaths.length === linkPaths.length && previous.linkPaths.every((linkPath) => linkPaths.includes(linkPath)) && await pathExists2(installPath) && allLinksExist) {
+    const allLinksExist = (await Promise.all(linkPaths.map(pathExists3))).every(Boolean);
+    if (previous?.artifactVersionId === pkg.artifactVersionId && previous.displayName === pkg.displayName && previous.summary === pkg.summary && previous.deliveryRevision === pkg.bundle?.artifactSha256 && previous.installPath === installPath && previous.linkPaths.length === linkPaths.length && previous.linkPaths.every((linkPath) => linkPaths.includes(linkPath)) && await pathExists3(installPath) && allLinksExist) {
       result.unchanged.push(pkg.name);
       nextSkills.push(previous);
       continue;
     }
+    const preparedBundle = preparedBundles.get(pkg.name);
     const temporaryPath = `${installPath}.${process.pid}.tmp`;
     const backupPath = `${installPath}.${process.pid}.backup`;
-    await mkdir6(getCanonicalRoot(home, env), { recursive: true });
-    await rm2(temporaryPath, { recursive: true, force: true });
-    await rm2(backupPath, { recursive: true, force: true });
-    await mkdir6(temporaryPath, { recursive: true });
-    for (const file of pkg.files) {
-      const destination = path.join(temporaryPath, ...file.path.split("/"));
-      await mkdir6(path.dirname(destination), { recursive: true });
-      await writeFile6(destination, file.path === LOADOUT_SKILL_ENTRYPOINT ? entrypointContent(pkg, file.content) : file.content);
+    await mkdir8(getCanonicalRoot(home, env), { recursive: true });
+    await rm3(temporaryPath, { recursive: true, force: true });
+    await rm3(backupPath, { recursive: true, force: true });
+    if (preparedBundle) {
+      await writeBundlePackage(temporaryPath, pkg, preparedBundle.releaseDirectory);
+    } else {
+      await mkdir8(temporaryPath, { recursive: true });
+      for (const file of pkg.files) {
+        const destination = path.join(temporaryPath, ...file.path.split("/"));
+        await mkdir8(path.dirname(destination), { recursive: true });
+        await writeFile6(destination, file.path === LOADOUT_SKILL_ENTRYPOINT ? entrypointContent(pkg, file.content) : file.content);
+      }
     }
     const createdLinkPaths = [];
     let backedUp = false;
     try {
-      if (await pathExists2(installPath)) {
-        await rename3(installPath, backupPath);
+      if (await pathExists3(installPath)) {
+        await rename4(installPath, backupPath);
         backedUp = true;
       }
-      await rename3(temporaryPath, installPath);
+      await rename4(temporaryPath, installPath);
       for (const linkPath of linkPaths) {
-        await mkdir6(path.dirname(linkPath), { recursive: true });
-        if (!await pathExists2(linkPath)) {
-          await symlink2(installPath, linkPath, "dir");
+        await mkdir8(path.dirname(linkPath), { recursive: true });
+        if (!await pathExists3(linkPath)) {
+          await symlink3(installPath, linkPath, "dir");
           createdLinkPaths.push(linkPath);
         }
       }
-      await rm2(backupPath, { recursive: true, force: true });
+      await rm3(backupPath, { recursive: true, force: true });
     } catch (error) {
-      await Promise.all(createdLinkPaths.map((linkPath) => rm2(linkPath, { force: true })));
-      await rm2(installPath, { recursive: true, force: true });
+      await Promise.all(createdLinkPaths.map((linkPath) => rm3(linkPath, { force: true })));
+      await rm3(installPath, { recursive: true, force: true });
       if (backedUp)
-        await rename3(backupPath, installPath);
-      await rm2(temporaryPath, { recursive: true, force: true });
+        await rename4(backupPath, installPath);
+      await rm3(temporaryPath, { recursive: true, force: true });
       throw error;
     }
     if (previous && previous.installPath !== installPath)
@@ -6880,7 +9799,8 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
       summary: pkg.summary,
       commandName: nextCommandName,
       installPath,
-      linkPaths
+      linkPaths,
+      ...pkg.bundle ? { deliveryRevision: pkg.bundle.artifactSha256 } : {}
     });
     (previous ? result.updated : result.installed).push(pkg.name);
   }