@aident-ai/cli 0.2.4-staging.ci.34807529340.1 → 0.3.0

package/dist/dsh.mjs

@@ -1,2452 +1,3 @@
-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";
@@ -3024,7 +575,7 @@ function getConfigFile() {
 function getConfigFileForHome(home) {
   return join(getAidentDir(home), "config.json");
 }
-var DEFAULT_BASE_URL = "https://staging.loadout.aident.ai"?.trim() || "https://loadout.aident.ai";
+var DEFAULT_BASE_URL = "https://loadout.aident.ai"?.trim() || "https://loadout.aident.ai";
 var CONFIG_KEYS = ["baseUrl", "packages"];
 async function readConfig(configFile = getConfigFile()) {
   try {
@@ -7128,7 +4679,7 @@ function serializeLoadoutSkillPackage(skillPackage) {
 }
 
 // src/version.ts
-var VERSION = "0.2.4-staging.ci.34807529340.1";
+var VERSION = "0.3.0";
 var DESKTOP_VERSION = process.env.AIDENT_DESKTOP_VERSION?.trim() || undefined;
 var DESKTOP_CHANNEL = parseDesktopChannel(process.env.AIDENT_DESKTOP_CHANNEL);
 function parseDesktopChannel(value) {
@@ -8332,7 +5883,7 @@ var LoadoutFavoriteSkillsUpdateSchema = objectType({
   syncRequired: booleanType()
 }).strict();
 function getLoadoutFavoriteSkillsStateToken(skills) {
-  const state = skills.map(({ name, artifactVersionId, deliveryRevision }) => ({ name, artifactVersionId, deliveryRevision })).sort((left, right) => left.name.localeCompare(right.name));
+  const state = skills.map(({ name, artifactVersionId }) => ({ name, artifactVersionId })).sort((left, right) => left.name.localeCompare(right.name));
   return createHash2("sha256").update(JSON.stringify(state)).digest("hex");
 }
 
@@ -9068,463 +6619,10 @@ function isExpired(creds) {
 }
 
 // src/loadoutFavoriteSkills.ts
-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 { 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 { 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}`);
-}
+import path from "node:path";
 
 // ../web/shared/integrations/LoadoutSkillConstants.ts
 var LOADOUT_SKILL_ENTRYPOINT = "SKILL.md";
@@ -9552,7 +6650,7 @@ function isCanonicalUuid(value) {
   return value === value.toLowerCase() && extractUUID(value) === value;
 }
 function getHome() {
-  return process.env.HOME || process.env.USERPROFILE || homedir5();
+  return process.env.HOME || process.env.USERPROFILE || homedir4();
 }
 function getCanonicalRoot(home, env) {
   return path.join(getGlobalLoadoutSkillHostRoots(home, env).find(({ canonical }) => canonical).root, "skills");
@@ -9595,14 +6693,12 @@ function assertPackage(pkg) {
     packageBytes += bytes;
     if (bytes !== file.sizeBytes)
       throw new Error(`Size mismatch: ${pkg.name}/${file.path}`);
-    if (createHash5("sha256").update(file.content).digest("hex") !== file.contentDigest) {
+    if (createHash4("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);
@@ -9628,9 +6724,9 @@ function entrypointContent(pkg, content) {
   ].join(`
 `);
 }
-async function pathExists3(target) {
+async function pathExists2(target) {
   try {
-    await lstat5(target);
+    await lstat4(target);
     return true;
   } catch (error) {
     if (error.code === "ENOENT")
@@ -9640,12 +6736,12 @@ async function pathExists3(target) {
 }
 async function readManifest(home, env) {
   try {
-    const value = JSON.parse(await readFile8(getManifestPath(home), "utf8"));
+    const value = JSON.parse(await readFile7(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" || 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)) {
+      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)) {
         throw new Error("Invalid favorite Skills ownership manifest");
       }
     }
@@ -9663,27 +6759,23 @@ async function getInstalledLoadoutFavoriteSkillsStateToken(home = getHome(), env
 async function writeManifest(home, manifest) {
   const manifestPath = getManifestPath(home);
   const temporaryPath = `${manifestPath}.${process.pid}.tmp`;
-  await mkdir8(path.dirname(manifestPath), { recursive: true, mode: 448 });
+  await mkdir6(path.dirname(manifestPath), { recursive: true, mode: 448 });
   await writeFile6(temporaryPath, `${JSON.stringify(manifest, null, 2)}
 `, { mode: 384 });
-  await rename4(temporaryPath, manifestPath);
+  await rename3(temporaryPath, manifestPath);
 }
 async function removeOwnedSkill(skill) {
   for (const linkPath of skill.linkPaths) {
-    if (!await pathExists3(linkPath))
+    if (!await pathExists2(linkPath))
       continue;
-    const stat = await lstat5(linkPath);
+    const stat = await lstat4(linkPath);
     if (stat.isSymbolicLink())
-      await rm3(linkPath);
+      await rm2(linkPath);
   }
-  if (await pathExists3(skill.installPath))
-    await rm3(skill.installPath, { recursive: true });
+  if (await pathExists2(skill.installPath))
+    await rm2(skill.installPath, { recursive: true });
 }
-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 = {}) {
+async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = process.env) {
   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));
@@ -9698,12 +6790,6 @@ 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: [],
@@ -9725,13 +6811,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 pathExists3(candidate))
+      if (!await pathExists2(candidate))
         return null;
       if (previous && candidate === previous.installPath) {
-        return (await lstat5(candidate)).isDirectory() ? null : candidate;
+        return (await lstat4(candidate)).isDirectory() ? null : candidate;
       }
       if (previous && previous.linkPaths.includes(candidate)) {
-        const stat = await lstat5(candidate);
+        const stat = await lstat4(candidate);
         if (!stat.isSymbolicLink())
           return candidate;
         return path.resolve(path.dirname(candidate), await readlink(candidate)) === previous.installPath ? null : candidate;
@@ -9744,50 +6830,45 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
         nextSkills.push(previous);
       continue;
     }
-    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) {
+    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) {
       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 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);
-      }
+    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);
     }
     const createdLinkPaths = [];
     let backedUp = false;
     try {
-      if (await pathExists3(installPath)) {
-        await rename4(installPath, backupPath);
+      if (await pathExists2(installPath)) {
+        await rename3(installPath, backupPath);
         backedUp = true;
       }
-      await rename4(temporaryPath, installPath);
+      await rename3(temporaryPath, installPath);
       for (const linkPath of linkPaths) {
-        await mkdir8(path.dirname(linkPath), { recursive: true });
-        if (!await pathExists3(linkPath)) {
-          await symlink3(installPath, linkPath, "dir");
+        await mkdir6(path.dirname(linkPath), { recursive: true });
+        if (!await pathExists2(linkPath)) {
+          await symlink2(installPath, linkPath, "dir");
           createdLinkPaths.push(linkPath);
         }
       }
-      await rm3(backupPath, { recursive: true, force: true });
+      await rm2(backupPath, { recursive: true, force: true });
     } catch (error) {
-      await Promise.all(createdLinkPaths.map((linkPath) => rm3(linkPath, { force: true })));
-      await rm3(installPath, { recursive: true, force: true });
+      await Promise.all(createdLinkPaths.map((linkPath) => rm2(linkPath, { force: true })));
+      await rm2(installPath, { recursive: true, force: true });
       if (backedUp)
-        await rename4(backupPath, installPath);
-      await rm3(temporaryPath, { recursive: true, force: true });
+        await rename3(backupPath, installPath);
+      await rm2(temporaryPath, { recursive: true, force: true });
       throw error;
     }
     if (previous && previous.installPath !== installPath)
@@ -9799,8 +6880,7 @@ async function reconcileLoadoutFavoriteSkills(payload, home = getHome(), env = p
       summary: pkg.summary,
       commandName: nextCommandName,
       installPath,
-      linkPaths,
-      ...pkg.bundle ? { deliveryRevision: pkg.bundle.artifactSha256 } : {}
+      linkPaths
     });
     (previous ? result.updated : result.installed).push(pkg.name);
   }