agent-web-os 0.3.5 → 0.4.0-beta.1

package/dist/chunk-L7KW6Y27.js

@@ -0,0 +1,2750 @@
+import {
+  __export
+} from "./chunk-PR4QN5HX.js";
+
+// node_modules/almostnode/src/utils/binary-encoding.ts
+var CHUNK = 8192;
+function uint8ToBase64(bytes) {
+  const parts = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+  }
+  return btoa(parts.join(""));
+}
+function base64ToUint8(base64) {
+  const binary = atob(base64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ToHex(bytes) {
+  const hex = new Array(bytes.length);
+  for (let i = 0; i < bytes.length; i++) {
+    hex[i] = bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex.join("");
+}
+function uint8ToBinaryString(bytes) {
+  const parts = [];
+  for (let i = 0; i < bytes.length; i += CHUNK) {
+    parts.push(String.fromCharCode.apply(null, Array.from(bytes.subarray(i, i + CHUNK))));
+  }
+  return parts.join("");
+}
+
+// node_modules/almostnode/src/shims/events.ts
+var kEvents = /* @__PURE__ */ Symbol("events");
+var kMaxListeners = /* @__PURE__ */ Symbol("maxListeners");
+var EventEmitter = class {
+  [kEvents];
+  [kMaxListeners];
+  // Helper to get events map, creating it if needed
+  _getEvents() {
+    const self = this;
+    if (!self[kEvents]) {
+      self[kEvents] = /* @__PURE__ */ new Map();
+    }
+    return self[kEvents];
+  }
+  on(event, listener) {
+    return this.addListener(event, listener);
+  }
+  addListener(event, listener) {
+    const events2 = this._getEvents();
+    if (!events2.has(event)) {
+      events2.set(event, []);
+    }
+    events2.get(event).push(listener);
+    return this;
+  }
+  once(event, listener) {
+    const onceWrapper = (...args) => {
+      this.removeListener(event, onceWrapper);
+      listener.apply(this, args);
+    };
+    return this.addListener(event, onceWrapper);
+  }
+  off(event, listener) {
+    return this.removeListener(event, listener);
+  }
+  removeListener(event, listener) {
+    const events2 = this._getEvents();
+    const listeners = events2.get(event);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+    return this;
+  }
+  removeAllListeners(event) {
+    const events2 = this._getEvents();
+    if (event) {
+      events2.delete(event);
+    } else {
+      events2.clear();
+    }
+    return this;
+  }
+  emit(event, ...args) {
+    const events2 = this._getEvents();
+    const listeners = events2.get(event);
+    if (!listeners || listeners.length === 0) {
+      if (event === "error") {
+        const err = args[0];
+        if (err instanceof Error) {
+          throw err;
+        }
+        throw new Error("Unhandled error event");
+      }
+      return false;
+    }
+    for (const listener of [...listeners]) {
+      try {
+        listener.apply(this, args);
+      } catch (err) {
+        console.error("Error in event listener:", err);
+      }
+    }
+    return true;
+  }
+  listeners(event) {
+    const events2 = this._getEvents();
+    return [...events2.get(event) || []];
+  }
+  rawListeners(event) {
+    return this.listeners(event);
+  }
+  listenerCount(event) {
+    const events2 = this._getEvents();
+    return events2.get(event)?.length || 0;
+  }
+  eventNames() {
+    const events2 = this._getEvents();
+    return [...events2.keys()];
+  }
+  setMaxListeners(n) {
+    this[kMaxListeners] = n;
+    return this;
+  }
+  getMaxListeners() {
+    return this[kMaxListeners] || 10;
+  }
+  prependListener(event, listener) {
+    const events2 = this._getEvents();
+    if (!events2.has(event)) {
+      events2.set(event, []);
+    }
+    events2.get(event).unshift(listener);
+    return this;
+  }
+  prependOnceListener(event, listener) {
+    const onceWrapper = (...args) => {
+      this.removeListener(event, onceWrapper);
+      listener.apply(this, args);
+    };
+    return this.prependListener(event, onceWrapper);
+  }
+  // Static methods for compatibility
+  static listenerCount(emitter, event) {
+    return emitter.listenerCount(event);
+  }
+};
+var events = EventEmitter;
+events.EventEmitter = EventEmitter;
+events.once = async (emitter, event) => {
+  return new Promise((resolve, reject) => {
+    const onEvent = (...args) => {
+      emitter.removeListener("error", onError);
+      resolve(args);
+    };
+    const onError = (...args) => {
+      emitter.removeListener(event, onEvent);
+      reject(args[0]);
+    };
+    emitter.once(event, onEvent);
+    emitter.once("error", onError);
+  });
+};
+events.on = (emitter, event) => {
+  const iterator = {
+    async next() {
+      return new Promise((resolve) => {
+        emitter.once(event, (...args) => resolve({ value: args, done: false }));
+      });
+    },
+    [Symbol.asyncIterator]() {
+      return this;
+    }
+  };
+  return iterator;
+};
+events.getEventListeners = (emitter, event) => emitter.listeners(event);
+events.listenerCount = (emitter, event) => emitter.listenerCount(event);
+var events_default = events;
+
+// node_modules/almostnode/src/shims/stream.ts
+var _encoder = new TextEncoder();
+var _decoder = new TextDecoder("utf-8");
+var Readable = class _Readable extends EventEmitter {
+  _buffer = [];
+  _ended = false;
+  _flowing = false;
+  _endEmitted = false;
+  readable = true;
+  readableEnded = false;
+  readableFlowing = null;
+  constructor() {
+    super();
+  }
+  // Internal method to add listener without triggering auto-flow
+  _addListenerInternal(event, listener) {
+    EventEmitter.prototype.addListener.call(this, event, listener);
+    return this;
+  }
+  // Override on() to auto-flow when 'data' listener is added
+  on(event, listener) {
+    this._addListenerInternal(event, listener);
+    if (event === "data" && !this._flowing) {
+      queueMicrotask(() => {
+        if (this.listenerCount("data") > 0 && !this._flowing) {
+          this.resume();
+        }
+      });
+    }
+    return this;
+  }
+  // Also handle addListener (alias for on)
+  addListener(event, listener) {
+    return this.on(event, listener);
+  }
+  push(chunk) {
+    if (chunk === null) {
+      this._ended = true;
+      this.readableEnded = true;
+      this.readable = false;
+      if (this._flowing && this._buffer.length === 0 && !this._endEmitted) {
+        this._endEmitted = true;
+        queueMicrotask(() => this.emit("end"));
+      }
+      return false;
+    }
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    this._buffer.push(buffer);
+    if (this._flowing) {
+      queueMicrotask(() => {
+        this._flushBuffer();
+      });
+    }
+    return true;
+  }
+  _flushBuffer() {
+    while (this._buffer.length > 0 && this._flowing) {
+      const data = this._buffer.shift();
+      this.emit("data", data);
+    }
+    if (this._ended && this._buffer.length === 0 && !this._endEmitted) {
+      this._endEmitted = true;
+      this.emit("end");
+    }
+  }
+  read(size) {
+    if (this._buffer.length === 0) {
+      return null;
+    }
+    if (size === void 0) {
+      const result = Buffer.concat(this._buffer);
+      this._buffer = [];
+      return result;
+    }
+    const chunks = [];
+    let remaining = size;
+    while (remaining > 0 && this._buffer.length > 0) {
+      const chunk = this._buffer[0];
+      if (chunk.length <= remaining) {
+        chunks.push(this._buffer.shift());
+        remaining -= chunk.length;
+      } else {
+        chunks.push(chunk.slice(0, remaining));
+        this._buffer[0] = chunk.slice(remaining);
+        remaining = 0;
+      }
+    }
+    return chunks.length > 0 ? Buffer.concat(chunks) : null;
+  }
+  resume() {
+    this._flowing = true;
+    this.readableFlowing = true;
+    this._flushBuffer();
+    return this;
+  }
+  pause() {
+    this._flowing = false;
+    this.readableFlowing = false;
+    return this;
+  }
+  pipe(destination) {
+    this.on("data", (chunk) => {
+      destination.write(chunk);
+    });
+    this.on("end", () => {
+      destination.end();
+    });
+    this.resume();
+    return destination;
+  }
+  unpipe(destination) {
+    this.removeAllListeners("data");
+    this.removeAllListeners("end");
+    return this;
+  }
+  setEncoding(encoding) {
+    return this;
+  }
+  destroy(error) {
+    this._buffer = [];
+    this._ended = true;
+    this.readable = false;
+    if (error) {
+      this.emit("error", error);
+    }
+    this.emit("close");
+    return this;
+  }
+  /**
+   * Creates a Readable stream from an iterable or async iterable
+   * @param iterable - An iterable or async iterable to create the stream from
+   * @param options - Optional stream options
+   */
+  static from(iterable, options) {
+    const readable = new _Readable();
+    (async () => {
+      try {
+        for await (const chunk of iterable) {
+          if (chunk !== null && chunk !== void 0) {
+            const data = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+            readable.push(data);
+          }
+        }
+        readable.push(null);
+      } catch (err) {
+        readable.destroy(err);
+      }
+    })();
+    return readable;
+  }
+};
+var Writable = class extends EventEmitter {
+  _chunks = [];
+  _ended = false;
+  writable = true;
+  writableEnded = false;
+  writableFinished = false;
+  constructor() {
+    super();
+  }
+  write(chunk, encodingOrCallback, callback) {
+    if (this._ended) {
+      const error = new Error("write after end");
+      if (typeof encodingOrCallback === "function") {
+        encodingOrCallback(error);
+      } else if (callback) {
+        callback(error);
+      }
+      return false;
+    }
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    this._chunks.push(buffer);
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb) {
+      queueMicrotask(() => cb(null));
+    }
+    return true;
+  }
+  end(chunkOrCallback, encodingOrCallback, callback) {
+    if (typeof chunkOrCallback === "function") {
+      callback = chunkOrCallback;
+    } else if (chunkOrCallback !== void 0) {
+      this.write(chunkOrCallback);
+    }
+    if (typeof encodingOrCallback === "function") {
+      callback = encodingOrCallback;
+    }
+    this._ended = true;
+    this.writable = false;
+    this.writableEnded = true;
+    queueMicrotask(() => {
+      this.writableFinished = true;
+      this.emit("finish");
+      if (callback) {
+        callback();
+      }
+    });
+    return this;
+  }
+  getBuffer() {
+    return Buffer.concat(this._chunks);
+  }
+  getBufferAsString(encoding = "utf8") {
+    return this.getBuffer().toString(encoding);
+  }
+  destroy(error) {
+    this._chunks = [];
+    this._ended = true;
+    this.writable = false;
+    if (error) {
+      this.emit("error", error);
+    }
+    this.emit("close");
+    return this;
+  }
+  cork() {
+  }
+  uncork() {
+  }
+  setDefaultEncoding(encoding) {
+    return this;
+  }
+};
+var Duplex = class extends Readable {
+  _writeChunks = [];
+  _writeEnded = false;
+  writable = true;
+  writableEnded = false;
+  writableFinished = false;
+  write(chunk, encodingOrCallback, callback) {
+    if (this._writeEnded) {
+      return false;
+    }
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    this._writeChunks.push(buffer);
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb) {
+      queueMicrotask(() => cb(null));
+    }
+    return true;
+  }
+  end(chunkOrCallback, encodingOrCallback, callback) {
+    if (typeof chunkOrCallback === "function") {
+      callback = chunkOrCallback;
+    } else if (chunkOrCallback !== void 0) {
+      this.write(chunkOrCallback);
+    }
+    this._writeEnded = true;
+    this.writable = false;
+    this.writableEnded = true;
+    queueMicrotask(() => {
+      this.writableFinished = true;
+      this.emit("finish");
+      if (callback) {
+        callback();
+      }
+    });
+    return this;
+  }
+};
+var PassThrough = class extends Duplex {
+  constructor() {
+    super();
+  }
+  write(chunk, encodingOrCallback, callback) {
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    this.push(buffer);
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb) {
+      queueMicrotask(() => cb(null));
+    }
+    return true;
+  }
+};
+var Transform = class extends Duplex {
+  constructor() {
+    super();
+  }
+  _transform(chunk, encoding, callback) {
+    callback(null, chunk);
+  }
+  _flush(callback) {
+    callback(null);
+  }
+  write(chunk, encodingOrCallback, callback) {
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    const encoding = typeof encodingOrCallback === "string" ? encodingOrCallback : "utf8";
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    this._transform(buffer, encoding, (error, data) => {
+      if (error) {
+        if (cb) cb(error);
+        return;
+      }
+      if (data) {
+        this.push(data);
+      }
+      if (cb) cb(null);
+    });
+    return true;
+  }
+  end(chunkOrCallback, encodingOrCallback, callback) {
+    this._flush((error, data) => {
+      if (data) {
+        this.push(data);
+      }
+    });
+    return super.end(chunkOrCallback, encodingOrCallback, callback);
+  }
+};
+var Stream = class extends EventEmitter {
+  pipe(destination) {
+    return destination;
+  }
+};
+Stream.Readable = Readable;
+Stream.Writable = Writable;
+Stream.Duplex = Duplex;
+Stream.Transform = Transform;
+Stream.PassThrough = PassThrough;
+Stream.Stream = Stream;
+Stream.from = Readable.from;
+var promises = {
+  pipeline: async (...streams) => {
+    return Promise.resolve();
+  },
+  finished: async (stream) => {
+    return Promise.resolve();
+  }
+};
+function pipeline(...args) {
+  const callback = args[args.length - 1];
+  if (typeof callback === "function") {
+    setTimeout(() => callback(), 0);
+  }
+  return args[args.length - 2] || args[0];
+}
+function finished(stream, callback) {
+  setTimeout(() => callback(), 0);
+  return () => {
+  };
+}
+var BufferPolyfill = class _BufferPolyfill extends Uint8Array {
+  // BYTES_PER_ELEMENT for TypedArray compatibility
+  static BYTES_PER_ELEMENT = 1;
+  static from(value, encodingOrMapfn, thisArg) {
+    if (typeof encodingOrMapfn === "function") {
+      const arrayLike = value;
+      const mapped = Array.from(arrayLike, encodingOrMapfn, thisArg);
+      return new _BufferPolyfill(mapped);
+    }
+    const data = value;
+    const encoding = encodingOrMapfn;
+    if (Array.isArray(data)) {
+      return new _BufferPolyfill(data);
+    }
+    if (typeof data === "string") {
+      const enc = (encoding || "utf8").toLowerCase();
+      if (enc === "base64" || enc === "base64url") {
+        let base64 = data;
+        if (enc === "base64url") {
+          base64 = data.replace(/-/g, "+").replace(/_/g, "/");
+          while (base64.length % 4 !== 0) {
+            base64 += "=";
+          }
+        }
+        const binary = atob(base64);
+        const bytes2 = new Uint8Array(binary.length);
+        for (let i = 0; i < binary.length; i++) {
+          bytes2[i] = binary.charCodeAt(i);
+        }
+        return new _BufferPolyfill(bytes2);
+      }
+      if (enc === "hex") {
+        const bytes2 = new Uint8Array(data.length / 2);
+        for (let i = 0; i < data.length; i += 2) {
+          bytes2[i / 2] = parseInt(data.slice(i, i + 2), 16);
+        }
+        return new _BufferPolyfill(bytes2);
+      }
+      if (enc === "latin1" || enc === "binary") {
+        const bytes2 = new Uint8Array(data.length);
+        for (let i = 0; i < data.length; i++) {
+          bytes2[i] = data.charCodeAt(i) & 255;
+        }
+        return new _BufferPolyfill(bytes2);
+      }
+      const bytes = _encoder.encode(data);
+      return new _BufferPolyfill(bytes);
+    }
+    if (data instanceof ArrayBuffer) {
+      return new _BufferPolyfill(data);
+    }
+    return new _BufferPolyfill(data);
+  }
+  static alloc(size, fill) {
+    const buffer = new _BufferPolyfill(size);
+    if (fill !== void 0) {
+      buffer.fill(fill);
+    }
+    return buffer;
+  }
+  static allocUnsafe(size) {
+    return new _BufferPolyfill(size);
+  }
+  static allocUnsafeSlow(size) {
+    return new _BufferPolyfill(size);
+  }
+  static concat(buffers) {
+    const totalLength = buffers.reduce((sum, buf) => sum + buf.length, 0);
+    const result = new _BufferPolyfill(totalLength);
+    let offset = 0;
+    for (const buf of buffers) {
+      result.set(buf, offset);
+      offset += buf.length;
+    }
+    return result;
+  }
+  static isBuffer(obj) {
+    return obj instanceof _BufferPolyfill || obj instanceof Uint8Array;
+  }
+  static isEncoding(encoding) {
+    return ["utf8", "utf-8", "ascii", "latin1", "binary", "base64", "base64url", "hex"].includes(encoding.toLowerCase());
+  }
+  static byteLength(string, encoding) {
+    const enc = (encoding || "utf8").toLowerCase();
+    if (enc === "base64" || enc === "base64url") {
+      const base64 = string.replace(/[=]/g, "");
+      return Math.floor(base64.length * 3 / 4);
+    }
+    if (enc === "hex") {
+      return string.length / 2;
+    }
+    return _encoder.encode(string).length;
+  }
+  toString(encoding = "utf8") {
+    const enc = (encoding || "utf8").toLowerCase();
+    if (enc === "base64") {
+      return uint8ToBase64(this);
+    }
+    if (enc === "base64url") {
+      return uint8ToBase64(this).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+    }
+    if (enc === "hex") {
+      return uint8ToHex(this);
+    }
+    if (enc === "latin1" || enc === "binary") {
+      return uint8ToBinaryString(this);
+    }
+    return _decoder.decode(this);
+  }
+  slice(start, end) {
+    return new _BufferPolyfill(super.slice(start, end));
+  }
+  subarray(start, end) {
+    return new _BufferPolyfill(super.subarray(start, end));
+  }
+  write(string, offset) {
+    const bytes = _encoder.encode(string);
+    this.set(bytes, offset || 0);
+    return bytes.length;
+  }
+  copy(target, targetStart, sourceStart, sourceEnd) {
+    const src = this.subarray(sourceStart || 0, sourceEnd);
+    target.set(src, targetStart || 0);
+    return src.length;
+  }
+  compare(otherBuffer) {
+    const len = Math.min(this.length, otherBuffer.length);
+    for (let i = 0; i < len; i++) {
+      if (this[i] < otherBuffer[i]) return -1;
+      if (this[i] > otherBuffer[i]) return 1;
+    }
+    if (this.length < otherBuffer.length) return -1;
+    if (this.length > otherBuffer.length) return 1;
+    return 0;
+  }
+  equals(otherBuffer) {
+    return this.compare(otherBuffer) === 0;
+  }
+  toJSON() {
+    return {
+      type: "Buffer",
+      data: Array.from(this)
+    };
+  }
+  // Add Object prototype methods that TypedArrays don't have directly
+  hasOwnProperty(prop) {
+    return Object.prototype.hasOwnProperty.call(this, prop);
+  }
+  readUInt8(offset) {
+    return this[offset];
+  }
+  readUInt16BE(offset) {
+    return this[offset] << 8 | this[offset + 1];
+  }
+  readUInt16LE(offset) {
+    return this[offset] | this[offset + 1] << 8;
+  }
+  readUInt32BE(offset) {
+    return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+  }
+  readUInt32LE(offset) {
+    return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+  }
+  writeUInt8(value, offset) {
+    this[offset] = value & 255;
+    return offset + 1;
+  }
+  writeUInt16BE(value, offset) {
+    this[offset] = value >> 8 & 255;
+    this[offset + 1] = value & 255;
+    return offset + 2;
+  }
+  writeUInt16LE(value, offset) {
+    this[offset] = value & 255;
+    this[offset + 1] = value >> 8 & 255;
+    return offset + 2;
+  }
+  writeUInt32BE(value, offset) {
+    this[offset] = value >> 24 & 255;
+    this[offset + 1] = value >> 16 & 255;
+    this[offset + 2] = value >> 8 & 255;
+    this[offset + 3] = value & 255;
+    return offset + 4;
+  }
+  writeUInt32LE(value, offset) {
+    this[offset] = value & 255;
+    this[offset + 1] = value >> 8 & 255;
+    this[offset + 2] = value >> 16 & 255;
+    this[offset + 3] = value >> 24 & 255;
+    return offset + 4;
+  }
+  // Lowercase aliases for UInt methods (Node.js Buffer API compatibility)
+  readUint8(offset) {
+    return this.readUInt8(offset);
+  }
+  readUint16BE(offset) {
+    return this.readUInt16BE(offset);
+  }
+  readUint16LE(offset) {
+    return this.readUInt16LE(offset);
+  }
+  readUint32BE(offset) {
+    return this.readUInt32BE(offset);
+  }
+  readUint32LE(offset) {
+    return this.readUInt32LE(offset);
+  }
+  writeUint8(value, offset) {
+    return this.writeUInt8(value, offset);
+  }
+  writeUint16BE(value, offset) {
+    return this.writeUInt16BE(value, offset);
+  }
+  writeUint16LE(value, offset) {
+    return this.writeUInt16LE(value, offset);
+  }
+  writeUint32BE(value, offset) {
+    return this.writeUInt32BE(value, offset);
+  }
+  writeUint32LE(value, offset) {
+    return this.writeUInt32LE(value, offset);
+  }
+  // Signed integer methods
+  readInt8(offset) {
+    const val = this[offset];
+    return val & 128 ? val - 256 : val;
+  }
+  readInt16BE(offset) {
+    const val = this.readUInt16BE(offset);
+    return val & 32768 ? val - 65536 : val;
+  }
+  readInt16LE(offset) {
+    const val = this.readUInt16LE(offset);
+    return val & 32768 ? val - 65536 : val;
+  }
+  readInt32BE(offset) {
+    const val = this.readUInt32BE(offset);
+    return val | 0;
+  }
+  readInt32LE(offset) {
+    const val = this.readUInt32LE(offset);
+    return val | 0;
+  }
+  writeInt8(value, offset) {
+    this[offset] = value & 255;
+    return offset + 1;
+  }
+  writeInt16BE(value, offset) {
+    return this.writeUInt16BE(value & 65535, offset);
+  }
+  writeInt16LE(value, offset) {
+    return this.writeUInt16LE(value & 65535, offset);
+  }
+  writeInt32BE(value, offset) {
+    return this.writeUInt32BE(value >>> 0, offset);
+  }
+  writeInt32LE(value, offset) {
+    return this.writeUInt32LE(value >>> 0, offset);
+  }
+  // BigInt methods (64-bit)
+  readBigUInt64LE(offset) {
+    const lo = BigInt(this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24) & 0xffffffffn;
+    const hi = BigInt(this[offset + 4] | this[offset + 5] << 8 | this[offset + 6] << 16 | this[offset + 7] << 24) & 0xffffffffn;
+    return lo | hi << 32n;
+  }
+  readBigUInt64BE(offset) {
+    const hi = BigInt(this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]) & 0xffffffffn;
+    const lo = BigInt(this[offset + 4] << 24 | this[offset + 5] << 16 | this[offset + 6] << 8 | this[offset + 7]) & 0xffffffffn;
+    return lo | hi << 32n;
+  }
+  readBigInt64LE(offset) {
+    const val = this.readBigUInt64LE(offset);
+    if (val >= 0x8000000000000000n) {
+      return val - 0x10000000000000000n;
+    }
+    return val;
+  }
+  readBigInt64BE(offset) {
+    const val = this.readBigUInt64BE(offset);
+    if (val >= 0x8000000000000000n) {
+      return val - 0x10000000000000000n;
+    }
+    return val;
+  }
+  writeBigUInt64LE(value, offset) {
+    const lo = value & 0xffffffffn;
+    const hi = value >> 32n & 0xffffffffn;
+    this[offset] = Number(lo & 0xffn);
+    this[offset + 1] = Number(lo >> 8n & 0xffn);
+    this[offset + 2] = Number(lo >> 16n & 0xffn);
+    this[offset + 3] = Number(lo >> 24n & 0xffn);
+    this[offset + 4] = Number(hi & 0xffn);
+    this[offset + 5] = Number(hi >> 8n & 0xffn);
+    this[offset + 6] = Number(hi >> 16n & 0xffn);
+    this[offset + 7] = Number(hi >> 24n & 0xffn);
+    return offset + 8;
+  }
+  writeBigUInt64BE(value, offset) {
+    const lo = value & 0xffffffffn;
+    const hi = value >> 32n & 0xffffffffn;
+    this[offset] = Number(hi >> 24n & 0xffn);
+    this[offset + 1] = Number(hi >> 16n & 0xffn);
+    this[offset + 2] = Number(hi >> 8n & 0xffn);
+    this[offset + 3] = Number(hi & 0xffn);
+    this[offset + 4] = Number(lo >> 24n & 0xffn);
+    this[offset + 5] = Number(lo >> 16n & 0xffn);
+    this[offset + 6] = Number(lo >> 8n & 0xffn);
+    this[offset + 7] = Number(lo & 0xffn);
+    return offset + 8;
+  }
+  writeBigInt64LE(value, offset) {
+    const unsigned = value < 0n ? value + 0x10000000000000000n : value;
+    return this.writeBigUInt64LE(unsigned, offset);
+  }
+  writeBigInt64BE(value, offset) {
+    const unsigned = value < 0n ? value + 0x10000000000000000n : value;
+    return this.writeBigUInt64BE(unsigned, offset);
+  }
+  // Lowercase aliases for BigInt methods (Node.js Buffer API compatibility)
+  readBigUint64LE(offset) {
+    return this.readBigUInt64LE(offset);
+  }
+  readBigUint64BE(offset) {
+    return this.readBigUInt64BE(offset);
+  }
+  writeBigUint64LE(value, offset) {
+    return this.writeBigUInt64LE(value, offset);
+  }
+  writeBigUint64BE(value, offset) {
+    return this.writeBigUInt64BE(value, offset);
+  }
+  // Float methods
+  readFloatLE(offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    return view.getFloat32(0, true);
+  }
+  readFloatBE(offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    return view.getFloat32(0, false);
+  }
+  readDoubleLE(offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getFloat64(0, true);
+  }
+  readDoubleBE(offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    return view.getFloat64(0, false);
+  }
+  writeFloatLE(value, offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    view.setFloat32(0, value, true);
+    return offset + 4;
+  }
+  writeFloatBE(value, offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 4);
+    view.setFloat32(0, value, false);
+    return offset + 4;
+  }
+  writeDoubleLE(value, offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setFloat64(0, value, true);
+    return offset + 8;
+  }
+  writeDoubleBE(value, offset) {
+    const view = new DataView(this.buffer, this.byteOffset + offset, 8);
+    view.setFloat64(0, value, false);
+    return offset + 8;
+  }
+  // Variable-length unsigned integer methods
+  readUIntLE(offset, byteLength) {
+    let val = 0;
+    let mul = 1;
+    for (let i = 0; i < byteLength; i++) {
+      val += this[offset + i] * mul;
+      mul *= 256;
+    }
+    return val;
+  }
+  readUintLE(offset, byteLength) {
+    return this.readUIntLE(offset, byteLength);
+  }
+  readUIntBE(offset, byteLength) {
+    let val = 0;
+    let mul = 1;
+    for (let i = byteLength - 1; i >= 0; i--) {
+      val += this[offset + i] * mul;
+      mul *= 256;
+    }
+    return val;
+  }
+  readUintBE(offset, byteLength) {
+    return this.readUIntBE(offset, byteLength);
+  }
+  readIntLE(offset, byteLength) {
+    let val = this.readUIntLE(offset, byteLength);
+    const limit = Math.pow(2, byteLength * 8 - 1);
+    if (val >= limit) {
+      val -= Math.pow(2, byteLength * 8);
+    }
+    return val;
+  }
+  readIntBE(offset, byteLength) {
+    let val = this.readUIntBE(offset, byteLength);
+    const limit = Math.pow(2, byteLength * 8 - 1);
+    if (val >= limit) {
+      val -= Math.pow(2, byteLength * 8);
+    }
+    return val;
+  }
+  writeUIntLE(value, offset, byteLength) {
+    let val = value;
+    for (let i = 0; i < byteLength; i++) {
+      this[offset + i] = val & 255;
+      val = Math.floor(val / 256);
+    }
+    return offset + byteLength;
+  }
+  writeUintLE(value, offset, byteLength) {
+    return this.writeUIntLE(value, offset, byteLength);
+  }
+  writeUIntBE(value, offset, byteLength) {
+    let val = value;
+    for (let i = byteLength - 1; i >= 0; i--) {
+      this[offset + i] = val & 255;
+      val = Math.floor(val / 256);
+    }
+    return offset + byteLength;
+  }
+  writeUintBE(value, offset, byteLength) {
+    return this.writeUIntBE(value, offset, byteLength);
+  }
+  writeIntLE(value, offset, byteLength) {
+    let val = value;
+    if (val < 0) {
+      val += Math.pow(2, byteLength * 8);
+    }
+    return this.writeUIntLE(val, offset, byteLength);
+  }
+  writeIntBE(value, offset, byteLength) {
+    let val = value;
+    if (val < 0) {
+      val += Math.pow(2, byteLength * 8);
+    }
+    return this.writeUIntBE(val, offset, byteLength);
+  }
+  // Swap methods
+  swap16() {
+    const len = this.length;
+    if (len % 2 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 16-bits");
+    }
+    for (let i = 0; i < len; i += 2) {
+      const a = this[i];
+      this[i] = this[i + 1];
+      this[i + 1] = a;
+    }
+    return this;
+  }
+  swap32() {
+    const len = this.length;
+    if (len % 4 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 32-bits");
+    }
+    for (let i = 0; i < len; i += 4) {
+      const a = this[i];
+      const b = this[i + 1];
+      this[i] = this[i + 3];
+      this[i + 1] = this[i + 2];
+      this[i + 2] = b;
+      this[i + 3] = a;
+    }
+    return this;
+  }
+  swap64() {
+    const len = this.length;
+    if (len % 8 !== 0) {
+      throw new RangeError("Buffer size must be a multiple of 64-bits");
+    }
+    for (let i = 0; i < len; i += 8) {
+      const a = this[i];
+      const b = this[i + 1];
+      const c = this[i + 2];
+      const d = this[i + 3];
+      this[i] = this[i + 7];
+      this[i + 1] = this[i + 6];
+      this[i + 2] = this[i + 5];
+      this[i + 3] = this[i + 4];
+      this[i + 4] = d;
+      this[i + 5] = c;
+      this[i + 6] = b;
+      this[i + 7] = a;
+    }
+    return this;
+  }
+};
+if (typeof globalThis.Buffer === "undefined") {
+  globalThis.Buffer = BufferPolyfill;
+}
+Stream.pipeline = pipeline;
+Stream.finished = finished;
+Stream.promises = promises;
+var stream_default = Stream;
+
+// node_modules/almostnode/src/shims/http.ts
+var http_exports = {};
+__export(http_exports, {
+  Agent: () => Agent,
+  ClientRequest: () => ClientRequest,
+  IncomingMessage: () => IncomingMessage,
+  METHODS: () => METHODS,
+  STATUS_CODES: () => STATUS_CODES,
+  Server: () => Server2,
+  ServerResponse: () => ServerResponse,
+  _createClientRequest: () => _createClientRequest,
+  _createWsFrame: () => _createWsFrame,
+  _parseWsFrame: () => _parseWsFrame,
+  _registerServer: () => _registerServer,
+  _unregisterServer: () => _unregisterServer,
+  createServer: () => createServer2,
+  default: () => http_default,
+  get: () => get,
+  getAllServers: () => getAllServers,
+  getServer: () => getServer,
+  globalAgent: () => globalAgent,
+  request: () => request,
+  setServerCloseCallback: () => setServerCloseCallback,
+  setServerListenCallback: () => setServerListenCallback
+});
+
+// node_modules/almostnode/src/shims/net.ts
+var net_exports = {};
+__export(net_exports, {
+  Server: () => Server,
+  Socket: () => Socket,
+  connect: () => connect,
+  createConnection: () => createConnection,
+  createServer: () => createServer,
+  default: () => net_default,
+  isIP: () => isIP,
+  isIPv4: () => isIPv4,
+  isIPv6: () => isIPv6
+});
+var Socket = class extends Duplex {
+  _connecting = false;
+  _connected = false;
+  _destroyed = false;
+  _remoteAddress = "";
+  _remotePort = 0;
+  _localAddress = "127.0.0.1";
+  _localPort = 0;
+  localAddress = "127.0.0.1";
+  localPort = 0;
+  remoteAddress;
+  remotePort;
+  remoteFamily;
+  connecting = false;
+  destroyed = false;
+  readyState = "closed";
+  constructor(options) {
+    super();
+  }
+  connect(portOrOptions, hostOrCallback, callback) {
+    let port;
+    let host = "127.0.0.1";
+    let cb;
+    if (typeof portOrOptions === "number") {
+      port = portOrOptions;
+      if (typeof hostOrCallback === "string") {
+        host = hostOrCallback;
+        cb = callback;
+      } else {
+        cb = hostOrCallback;
+      }
+    } else {
+      port = portOrOptions.port;
+      host = portOrOptions.host || "127.0.0.1";
+      cb = typeof hostOrCallback === "function" ? hostOrCallback : callback;
+    }
+    this._connecting = true;
+    this.connecting = true;
+    this._remoteAddress = host;
+    this._remotePort = port;
+    this.remoteAddress = host;
+    this.remotePort = port;
+    this.remoteFamily = "IPv4";
+    this.readyState = "opening";
+    queueMicrotask(() => {
+      this._connecting = false;
+      this._connected = true;
+      this.connecting = false;
+      this.readyState = "open";
+      this.emit("connect");
+      if (cb) cb();
+    });
+    return this;
+  }
+  address() {
+    if (!this._connected) return null;
+    return {
+      address: this._localAddress,
+      family: "IPv4",
+      port: this._localPort
+    };
+  }
+  setEncoding(encoding) {
+    return this;
+  }
+  setTimeout(timeout, callback) {
+    if (callback) {
+      this.once("timeout", callback);
+    }
+    return this;
+  }
+  setNoDelay(noDelay) {
+    return this;
+  }
+  setKeepAlive(enable, initialDelay) {
+    return this;
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  destroy(error) {
+    if (this._destroyed) return this;
+    this._destroyed = true;
+    this._connected = false;
+    this.destroyed = true;
+    this.readyState = "closed";
+    if (error) {
+      this.emit("error", error);
+    }
+    queueMicrotask(() => {
+      this.emit("close", !!error);
+    });
+    return this;
+  }
+  // Internal: simulate receiving data from remote
+  _receiveData(data) {
+    const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
+    this.push(buffer);
+  }
+  // Internal: signal end of remote data
+  _receiveEnd() {
+    this.push(null);
+  }
+};
+var Server = class extends EventEmitter {
+  _listening = false;
+  _address = null;
+  _connections = /* @__PURE__ */ new Set();
+  _maxConnections = Infinity;
+  listening = false;
+  maxConnections;
+  constructor(optionsOrConnectionListener, connectionListener) {
+    super();
+    let listener;
+    if (typeof optionsOrConnectionListener === "function") {
+      listener = optionsOrConnectionListener;
+    } else {
+      listener = connectionListener;
+    }
+    if (listener) {
+      this.on("connection", listener);
+    }
+  }
+  listen(portOrOptions, hostOrCallback, backlogOrCallback, callback) {
+    let port = 0;
+    let host = "0.0.0.0";
+    let cb;
+    if (typeof portOrOptions === "number") {
+      port = portOrOptions;
+      if (typeof hostOrCallback === "string") {
+        host = hostOrCallback;
+        if (typeof backlogOrCallback === "function") {
+          cb = backlogOrCallback;
+        } else {
+          cb = callback;
+        }
+      } else if (typeof hostOrCallback === "function") {
+        cb = hostOrCallback;
+      } else if (typeof hostOrCallback === "number") {
+        cb = typeof backlogOrCallback === "function" ? backlogOrCallback : callback;
+      } else {
+        if (typeof backlogOrCallback === "function") {
+          cb = backlogOrCallback;
+        } else if (typeof callback === "function") {
+          cb = callback;
+        }
+      }
+    } else if (portOrOptions) {
+      port = portOrOptions.port || 0;
+      host = portOrOptions.host || "0.0.0.0";
+      cb = typeof hostOrCallback === "function" ? hostOrCallback : callback;
+    }
+    if (port === 0) {
+      port = 3e3 + Math.floor(Math.random() * 1e3);
+    }
+    this._address = {
+      address: host,
+      family: "IPv4",
+      port
+    };
+    this._listening = true;
+    this.listening = true;
+    queueMicrotask(() => {
+      this.emit("listening");
+      if (cb) cb();
+    });
+    return this;
+  }
+  address() {
+    return this._address;
+  }
+  close(callback) {
+    this._listening = false;
+    this.listening = false;
+    for (const socket of this._connections) {
+      socket.destroy();
+    }
+    this._connections.clear();
+    queueMicrotask(() => {
+      this.emit("close");
+      if (callback) callback();
+    });
+    return this;
+  }
+  getConnections(callback) {
+    callback(null, this._connections.size);
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  // Internal: handle incoming connection
+  _handleConnection(socket) {
+    if (!this._listening) {
+      socket.destroy();
+      return;
+    }
+    this._connections.add(socket);
+    socket.on("close", () => {
+      this._connections.delete(socket);
+    });
+    this.emit("connection", socket);
+  }
+};
+function createServer(optionsOrConnectionListener, connectionListener) {
+  return new Server(optionsOrConnectionListener, connectionListener);
+}
+function createConnection(portOrOptions, hostOrCallback, callback) {
+  const socket = new Socket();
+  return socket.connect(portOrOptions, hostOrCallback, callback);
+}
+var connect = createConnection;
+function isIP(input) {
+  if (/^(\d{1,3}\.){3}\d{1,3}$/.test(input)) {
+    return 4;
+  }
+  if (/^([0-9a-fA-F]{0,4}:){2,7}[0-9a-fA-F]{0,4}$/.test(input)) {
+    return 6;
+  }
+  return 0;
+}
+function isIPv4(input) {
+  return isIP(input) === 4;
+}
+function isIPv6(input) {
+  return isIP(input) === 6;
+}
+var net_default = {
+  Socket,
+  Server,
+  createServer,
+  createConnection,
+  connect,
+  isIP,
+  isIPv4,
+  isIPv6
+};
+
+// node_modules/almostnode/src/shims/crypto.ts
+var crypto_exports = {};
+__export(crypto_exports, {
+  KeyObject: () => KeyObject,
+  constants: () => constants,
+  createHash: () => createHash,
+  createHmac: () => createHmac,
+  createPrivateKey: () => createPrivateKey,
+  createPublicKey: () => createPublicKey,
+  createSecretKey: () => createSecretKey,
+  createSign: () => createSign,
+  createVerify: () => createVerify,
+  default: () => crypto_default,
+  getCiphers: () => getCiphers,
+  getHashes: () => getHashes,
+  getRandomValues: () => getRandomValues,
+  pbkdf2: () => pbkdf2,
+  pbkdf2Sync: () => pbkdf2Sync,
+  randomBytes: () => randomBytes,
+  randomFillSync: () => randomFillSync,
+  randomInt: () => randomInt,
+  randomUUID: () => randomUUID,
+  sign: () => sign,
+  timingSafeEqual: () => timingSafeEqual,
+  verify: () => verify
+});
+function randomBytes(size) {
+  const array = new Uint8Array(size);
+  crypto.getRandomValues(array);
+  return BufferPolyfill.from(array);
+}
+function randomFillSync(buffer, offset, size) {
+  const start = offset || 0;
+  const len = size !== void 0 ? size : buffer.length - start;
+  const view = new Uint8Array(buffer.buffer, buffer.byteOffset + start, len);
+  crypto.getRandomValues(view);
+  return buffer;
+}
+function randomUUID() {
+  return crypto.randomUUID();
+}
+function randomInt(min, max) {
+  if (max === void 0) {
+    max = min;
+    min = 0;
+  }
+  const range = max - min;
+  const array = new Uint32Array(1);
+  crypto.getRandomValues(array);
+  return min + array[0] % range;
+}
+function getRandomValues(array) {
+  return crypto.getRandomValues(array);
+}
+function createHash(algorithm) {
+  return new Hash(algorithm);
+}
+var Hash = class {
+  algorithm;
+  data = [];
+  constructor(algorithm) {
+    this.algorithm = normalizeHashAlgorithm(algorithm);
+  }
+  update(data, encoding) {
+    let buffer;
+    if (typeof data === "string") {
+      if (encoding === "base64") {
+        buffer = BufferPolyfill.from(atob(data));
+      } else {
+        buffer = BufferPolyfill.from(data);
+      }
+    } else {
+      buffer = BufferPolyfill.from(data);
+    }
+    this.data.push(buffer);
+    return this;
+  }
+  async digestAsync(encoding) {
+    const combined = concatBuffers(this.data);
+    const dataBuffer = new Uint8Array(combined).buffer;
+    const hashBuffer = await crypto.subtle.digest(this.algorithm, dataBuffer);
+    return encodeResult(new Uint8Array(hashBuffer), encoding);
+  }
+  digest(encoding) {
+    const combined = concatBuffers(this.data);
+    const hash = syncHash(combined, this.algorithm);
+    return encodeResult(hash, encoding);
+  }
+};
+function createHmac(algorithm, key) {
+  return new Hmac(algorithm, key);
+}
+var Hmac = class {
+  algorithm;
+  key;
+  data = [];
+  constructor(algorithm, key) {
+    this.algorithm = normalizeHashAlgorithm(algorithm);
+    this.key = typeof key === "string" ? BufferPolyfill.from(key) : key;
+  }
+  update(data, encoding) {
+    const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
+    this.data.push(buffer);
+    return this;
+  }
+  async digestAsync(encoding) {
+    const combined = concatBuffers(this.data);
+    const keyBuffer = new Uint8Array(this.key).buffer;
+    const dataBuffer = new Uint8Array(combined).buffer;
+    const cryptoKey = await crypto.subtle.importKey(
+      "raw",
+      keyBuffer,
+      { name: "HMAC", hash: this.algorithm },
+      false,
+      ["sign"]
+    );
+    const signature = await crypto.subtle.sign("HMAC", cryptoKey, dataBuffer);
+    return encodeResult(new Uint8Array(signature), encoding);
+  }
+  digest(encoding) {
+    const combined = concatBuffers(this.data);
+    const hash = syncHmac(combined, this.key, this.algorithm);
+    return encodeResult(hash, encoding);
+  }
+};
+async function pbkdf2Async(password, salt, iterations, keylen, digest) {
+  const passwordBuffer = typeof password === "string" ? BufferPolyfill.from(password) : password instanceof Uint8Array ? password : BufferPolyfill.from(password);
+  const saltBuffer = typeof salt === "string" ? BufferPolyfill.from(salt) : salt instanceof Uint8Array ? salt : BufferPolyfill.from(salt);
+  const passwordArrayBuffer = new Uint8Array(passwordBuffer).buffer;
+  const saltArrayBuffer = new Uint8Array(saltBuffer).buffer;
+  const key = await crypto.subtle.importKey(
+    "raw",
+    passwordArrayBuffer,
+    "PBKDF2",
+    false,
+    ["deriveBits"]
+  );
+  const derivedBits = await crypto.subtle.deriveBits(
+    {
+      name: "PBKDF2",
+      salt: saltArrayBuffer,
+      iterations,
+      hash: normalizeHashAlgorithm(digest)
+    },
+    key,
+    keylen * 8
+    // Convert bytes to bits
+  );
+  return BufferPolyfill.from(derivedBits);
+}
+function pbkdf2(password, salt, iterations, keylen, digest, callback) {
+  pbkdf2Async(password, salt, iterations, keylen, digest).then((key) => callback(null, key)).catch((err) => callback(err, BufferPolyfill.alloc(0)));
+}
+function pbkdf2Sync(password, salt, iterations, keylen, digest) {
+  const passwordBuffer = typeof password === "string" ? BufferPolyfill.from(password) : password;
+  const saltBuffer = typeof salt === "string" ? BufferPolyfill.from(salt) : salt;
+  const hashAlg = normalizeHashAlgorithm(digest);
+  let hashLen;
+  if (hashAlg.includes("512")) {
+    hashLen = 64;
+  } else if (hashAlg.includes("384")) {
+    hashLen = 48;
+  } else if (hashAlg.includes("1") || hashAlg === "SHA-1") {
+    hashLen = 20;
+  } else {
+    hashLen = 32;
+  }
+  const numBlocks = Math.ceil(keylen / hashLen);
+  const derivedKey = new Uint8Array(numBlocks * hashLen);
+  for (let blockNum = 1; blockNum <= numBlocks; blockNum++) {
+    const blockNumBuf = new Uint8Array(4);
+    blockNumBuf[0] = blockNum >>> 24 & 255;
+    blockNumBuf[1] = blockNum >>> 16 & 255;
+    blockNumBuf[2] = blockNum >>> 8 & 255;
+    blockNumBuf[3] = blockNum & 255;
+    const saltWithBlock = new Uint8Array(saltBuffer.length + 4);
+    saltWithBlock.set(saltBuffer);
+    saltWithBlock.set(blockNumBuf, saltBuffer.length);
+    let u = syncHmac(saltWithBlock, passwordBuffer, hashAlg);
+    const block = new Uint8Array(u);
+    for (let i = 1; i < iterations; i++) {
+      u = syncHmac(u, passwordBuffer, hashAlg);
+      for (let j = 0; j < block.length; j++) {
+        block[j] ^= u[j];
+      }
+    }
+    derivedKey.set(block, (blockNum - 1) * hashLen);
+  }
+  return BufferPolyfill.from(derivedKey.slice(0, keylen));
+}
+function sign(algorithm, data, key, callback) {
+  const keyInfo = extractKeyInfo(key);
+  const alg = algorithm || keyInfo.algorithm;
+  if (!alg) {
+    const error = new Error("Algorithm must be specified");
+    if (callback) {
+      callback(error, null);
+      return;
+    }
+    throw error;
+  }
+  if (callback) {
+    signAsync(alg, data, keyInfo).then((sig) => callback(null, sig)).catch((err) => callback(err, null));
+    return;
+  }
+  const result = signSync(alg, data, keyInfo);
+  return result;
+}
+function verify(algorithm, data, key, signature, callback) {
+  const keyInfo = extractKeyInfo(key);
+  const alg = algorithm || keyInfo.algorithm;
+  if (!alg) {
+    const error = new Error("Algorithm must be specified");
+    if (callback) {
+      callback(error, false);
+      return;
+    }
+    throw error;
+  }
+  if (callback) {
+    verifyAsync(alg, data, keyInfo, signature).then((result) => callback(null, result)).catch((err) => callback(err, false));
+    return;
+  }
+  return verifySync(alg, data, keyInfo, signature);
+}
+function createSign(algorithm) {
+  return new Sign(algorithm);
+}
+function createVerify(algorithm) {
+  return new Verify(algorithm);
+}
+var Sign = class extends EventEmitter {
+  algorithm;
+  data = [];
+  constructor(algorithm) {
+    super();
+    this.algorithm = algorithm;
+  }
+  update(data, encoding) {
+    const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
+    this.data.push(buffer);
+    return this;
+  }
+  sign(privateKey, outputEncoding) {
+    const combined = concatBuffers(this.data);
+    const keyInfo = extractKeyInfo(privateKey);
+    const signature = signSync(this.algorithm, combined, keyInfo);
+    if (outputEncoding === "base64") {
+      return btoa(String.fromCharCode(...signature));
+    }
+    if (outputEncoding === "hex") {
+      return Array.from(signature).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    return signature;
+  }
+};
+var Verify = class extends EventEmitter {
+  algorithm;
+  data = [];
+  constructor(algorithm) {
+    super();
+    this.algorithm = algorithm;
+  }
+  update(data, encoding) {
+    const buffer = typeof data === "string" ? BufferPolyfill.from(data) : data;
+    this.data.push(buffer);
+    return this;
+  }
+  verify(publicKey, signature, signatureEncoding) {
+    const combined = concatBuffers(this.data);
+    const keyInfo = extractKeyInfo(publicKey);
+    let sig;
+    if (typeof signature === "string") {
+      if (signatureEncoding === "base64") {
+        sig = BufferPolyfill.from(atob(signature));
+      } else if (signatureEncoding === "hex") {
+        sig = BufferPolyfill.from(signature.match(/.{2}/g).map((byte) => parseInt(byte, 16)));
+      } else {
+        sig = BufferPolyfill.from(signature);
+      }
+    } else {
+      sig = signature;
+    }
+    return verifySync(this.algorithm, combined, keyInfo, sig);
+  }
+};
+var KeyObject = class {
+  _keyData;
+  _type;
+  _algorithm;
+  constructor(type, keyData, algorithm) {
+    this._type = type;
+    this._keyData = keyData;
+    this._algorithm = algorithm;
+  }
+  get type() {
+    return this._type;
+  }
+  get asymmetricKeyType() {
+    if (this._type === "secret") return void 0;
+    if (this._algorithm?.includes("RSA")) return "rsa";
+    if (this._algorithm?.includes("EC") || this._algorithm?.includes("ES")) return "ec";
+    if (this._algorithm?.includes("Ed")) return "ed25519";
+    return void 0;
+  }
+  get symmetricKeySize() {
+    if (this._type !== "secret") return void 0;
+    if (this._keyData instanceof Uint8Array) {
+      return this._keyData.length * 8;
+    }
+    return void 0;
+  }
+  export(options) {
+    if (this._keyData instanceof Uint8Array) {
+      return BufferPolyfill.from(this._keyData);
+    }
+    throw new Error("Cannot export CryptoKey synchronously");
+  }
+};
+function createSecretKey(key, encoding) {
+  const keyBuffer = typeof key === "string" ? BufferPolyfill.from(key, encoding) : key;
+  return new KeyObject("secret", keyBuffer);
+}
+function createPublicKey(key) {
+  const keyInfo = extractKeyInfo(key);
+  return new KeyObject("public", keyInfo.keyData, keyInfo.algorithm);
+}
+function createPrivateKey(key) {
+  const keyInfo = extractKeyInfo(key);
+  return new KeyObject("private", keyInfo.keyData, keyInfo.algorithm);
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) {
+    return false;
+  }
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+}
+function getCiphers() {
+  return ["aes-128-cbc", "aes-256-cbc", "aes-128-gcm", "aes-256-gcm"];
+}
+function getHashes() {
+  return ["sha1", "sha256", "sha384", "sha512"];
+}
+var constants = {
+  SSL_OP_ALL: 0,
+  RSA_PKCS1_PADDING: 1,
+  RSA_PKCS1_OAEP_PADDING: 4,
+  RSA_PKCS1_PSS_PADDING: 6
+};
+function normalizeHashAlgorithm(alg) {
+  const normalized = alg.toUpperCase().replace(/[^A-Z0-9]/g, "");
+  switch (normalized) {
+    case "SHA1":
+      return "SHA-1";
+    case "SHA256":
+      return "SHA-256";
+    case "SHA384":
+      return "SHA-384";
+    case "SHA512":
+      return "SHA-512";
+    case "MD5":
+      return "MD5";
+    // Not supported by WebCrypto
+    default:
+      return alg;
+  }
+}
+function getWebCryptoAlgorithm(nodeAlgorithm) {
+  const alg = nodeAlgorithm.toUpperCase().replace(/[^A-Z0-9]/g, "");
+  if (alg.includes("RSA")) {
+    if (alg.includes("PSS")) {
+      const hash2 = alg.match(/SHA(\d+)/)?.[0] || "SHA-256";
+      return { name: "RSA-PSS", hash: `SHA-${hash2.replace("SHA", "")}` };
+    }
+    const hash = alg.match(/SHA(\d+)/)?.[0] || "SHA-256";
+    return { name: "RSASSA-PKCS1-v1_5", hash: `SHA-${hash.replace("SHA", "")}` };
+  }
+  if (alg.startsWith("ES") || alg.includes("ECDSA")) {
+    const bits = alg.match(/\d+/)?.[0] || "256";
+    const hash = bits === "512" ? "SHA-512" : bits === "384" ? "SHA-384" : "SHA-256";
+    return { name: "ECDSA", hash };
+  }
+  if (alg.includes("ED25519") || alg === "EDDSA") {
+    return { name: "Ed25519" };
+  }
+  if (alg.includes("HS") || alg.includes("HMAC")) {
+    const bits = alg.match(/\d+/)?.[0] || "256";
+    return { name: "HMAC", hash: `SHA-${bits}` };
+  }
+  return { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
+}
+function extractKeyInfo(key) {
+  if (key instanceof KeyObject) {
+    return {
+      keyData: key._keyData,
+      algorithm: key._algorithm,
+      type: key._type,
+      format: "raw"
+    };
+  }
+  if (typeof key === "object" && "key" in key) {
+    return extractKeyInfo(key.key);
+  }
+  const keyStr = typeof key === "string" ? key : key.toString();
+  if (keyStr.includes("-----BEGIN")) {
+    const isPrivate = keyStr.includes("PRIVATE");
+    const isPublic = keyStr.includes("PUBLIC");
+    const base64 = keyStr.replace(/-----BEGIN [^-]+-----/, "").replace(/-----END [^-]+-----/, "").replace(/\s/g, "");
+    const keyData2 = BufferPolyfill.from(atob(base64));
+    let algorithm;
+    if (keyStr.includes("RSA")) algorithm = "RSA-SHA256";
+    else if (keyStr.includes("EC")) algorithm = "ES256";
+    else if (keyStr.includes("ED25519")) algorithm = "Ed25519";
+    return {
+      keyData: keyData2,
+      algorithm,
+      type: isPrivate ? "private" : isPublic ? "public" : "secret",
+      format: "pem"
+    };
+  }
+  const keyData = typeof key === "string" ? BufferPolyfill.from(key) : key;
+  return {
+    keyData,
+    type: "secret",
+    format: "raw"
+  };
+}
+function concatBuffers(buffers) {
+  const totalLength = buffers.reduce((acc, arr) => acc + arr.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const buf of buffers) {
+    result.set(buf, offset);
+    offset += buf.length;
+  }
+  return result;
+}
+function encodeResult(data, encoding) {
+  if (encoding === "hex") {
+    return Array.from(data).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  if (encoding === "base64") {
+    return btoa(String.fromCharCode(...data));
+  }
+  return BufferPolyfill.from(data);
+}
+function syncHash(data, algorithm) {
+  let size;
+  if (algorithm.includes("512")) {
+    size = 64;
+  } else if (algorithm.includes("384")) {
+    size = 48;
+  } else if (algorithm.includes("1") || algorithm === "SHA-1") {
+    size = 20;
+  } else {
+    size = 32;
+  }
+  const result = new Uint8Array(size);
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < data.length; i++) {
+    h1 = Math.imul(h1 ^ data[i], 2654435761);
+    h2 = Math.imul(h2 ^ data[i], 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  for (let i = 0; i < size; i++) {
+    const mix = i < size / 2 ? h1 : h2;
+    result[i] = mix >>> i % 4 * 8 & 255;
+    h1 = Math.imul(h1, 1103515245) + 12345;
+    h2 = Math.imul(h2, 1103515245) + 12345;
+  }
+  return result;
+}
+function syncHmac(data, key, algorithm) {
+  const combined = new Uint8Array(key.length + data.length);
+  combined.set(key, 0);
+  combined.set(data, key.length);
+  return syncHash(combined, algorithm);
+}
+async function signAsync(algorithm, data, keyInfo) {
+  const webCryptoAlg = getWebCryptoAlgorithm(algorithm);
+  try {
+    const cryptoKey = await importKey(keyInfo, webCryptoAlg, ["sign"]);
+    const signatureAlg = webCryptoAlg.hash ? { name: webCryptoAlg.name, hash: webCryptoAlg.hash } : { name: webCryptoAlg.name };
+    const dataBuffer = new Uint8Array(data).buffer;
+    const signature = await crypto.subtle.sign(signatureAlg, cryptoKey, dataBuffer);
+    return BufferPolyfill.from(signature);
+  } catch (error) {
+    console.warn("WebCrypto sign failed, using fallback:", error);
+    return signSync(algorithm, data, keyInfo);
+  }
+}
+async function verifyAsync(algorithm, data, keyInfo, signature) {
+  const webCryptoAlg = getWebCryptoAlgorithm(algorithm);
+  try {
+    const cryptoKey = await importKey(keyInfo, webCryptoAlg, ["verify"]);
+    const verifyAlg = webCryptoAlg.hash ? { name: webCryptoAlg.name, hash: webCryptoAlg.hash } : { name: webCryptoAlg.name };
+    const sigBuffer = new Uint8Array(signature).buffer;
+    const dataBuffer = new Uint8Array(data).buffer;
+    return await crypto.subtle.verify(verifyAlg, cryptoKey, sigBuffer, dataBuffer);
+  } catch (error) {
+    console.warn("WebCrypto verify failed, using fallback:", error);
+    return verifySync(algorithm, data, keyInfo, signature);
+  }
+}
+function signSync(algorithm, data, keyInfo) {
+  const keyData = keyInfo.keyData instanceof Uint8Array ? keyInfo.keyData : new Uint8Array(0);
+  const combined = new Uint8Array(keyData.length + data.length);
+  combined.set(keyData, 0);
+  combined.set(data, keyData.length);
+  const hash = syncHash(combined, algorithm);
+  return BufferPolyfill.from(hash);
+}
+function verifySync(algorithm, data, keyInfo, signature) {
+  const expectedSig = signSync(algorithm, data, keyInfo);
+  return timingSafeEqual(BufferPolyfill.from(signature), expectedSig);
+}
+async function importKey(keyInfo, algorithm, usages) {
+  if (keyInfo.keyData instanceof CryptoKey) {
+    return keyInfo.keyData;
+  }
+  const keyData = keyInfo.keyData;
+  const keyBuffer = new Uint8Array(keyData).buffer;
+  if (keyInfo.format === "pem") {
+    const format = keyInfo.type === "private" ? "pkcs8" : "spki";
+    const importAlg = algorithm.name === "ECDSA" ? { name: "ECDSA", namedCurve: "P-256" } : algorithm.name === "Ed25519" ? { name: "Ed25519" } : { name: algorithm.name, hash: algorithm.hash || "SHA-256" };
+    return await crypto.subtle.importKey(
+      format,
+      keyBuffer,
+      importAlg,
+      true,
+      usages
+    );
+  }
+  if (keyInfo.type === "secret") {
+    return await crypto.subtle.importKey(
+      "raw",
+      keyBuffer,
+      { name: algorithm.name, hash: algorithm.hash },
+      true,
+      usages
+    );
+  }
+  throw new Error(`Unsupported key format: ${keyInfo.format}`);
+}
+var crypto_default = {
+  randomBytes,
+  randomFillSync,
+  randomUUID,
+  randomInt,
+  getRandomValues,
+  createHash,
+  createHmac,
+  createSign,
+  createVerify,
+  sign,
+  verify,
+  pbkdf2,
+  pbkdf2Sync,
+  timingSafeEqual,
+  getCiphers,
+  getHashes,
+  constants,
+  KeyObject,
+  createSecretKey,
+  createPublicKey,
+  createPrivateKey
+};
+
+// node_modules/almostnode/src/shims/http.ts
+var _isBrowser = typeof window !== "undefined" && typeof window.document !== "undefined";
+var _BrowserWebSocket = _isBrowser && typeof globalThis.WebSocket === "function" ? globalThis.WebSocket : null;
+var IncomingMessage = class _IncomingMessage extends Readable {
+  httpVersion = "1.1";
+  httpVersionMajor = 1;
+  httpVersionMinor = 1;
+  complete = false;
+  headers = {};
+  rawHeaders = [];
+  trailers = {};
+  rawTrailers = [];
+  method;
+  url;
+  statusCode;
+  statusMessage;
+  socket;
+  _body = null;
+  constructor(socket) {
+    super();
+    this.socket = socket || new Socket();
+  }
+  setTimeout(msecs, callback) {
+    if (callback) {
+      this.once("timeout", callback);
+    }
+    return this;
+  }
+  destroy(error) {
+    super.destroy(error);
+    return this;
+  }
+  // Internal: set body data
+  _setBody(body) {
+    if (body === null) {
+      this._body = null;
+    } else {
+      this._body = typeof body === "string" ? BufferPolyfill.from(body) : body;
+    }
+    if (this._body) {
+      this.push(this._body);
+    }
+    this.push(null);
+    this.complete = true;
+  }
+  // Internal: initialize from raw request
+  static fromRequest(method, url, headers, body) {
+    const msg = new _IncomingMessage();
+    msg.method = method;
+    msg.url = url;
+    msg.headers = { ...headers };
+    for (const [key, value] of Object.entries(headers)) {
+      msg.rawHeaders.push(key, value);
+    }
+    if (body) {
+      msg._setBody(body);
+    } else {
+      msg.push(null);
+      msg.complete = true;
+    }
+    return msg;
+  }
+};
+var ServerResponse = class extends Writable {
+  statusCode = 200;
+  statusMessage = "OK";
+  headersSent = false;
+  finished = false;
+  sendDate = true;
+  socket;
+  _headers = /* @__PURE__ */ new Map();
+  _body = [];
+  _resolve;
+  constructor(req) {
+    super();
+    this.socket = req.socket;
+  }
+  // Internal: set resolver for async response handling
+  _setResolver(resolve) {
+    this._resolve = resolve;
+  }
+  setHeader(name, value) {
+    if (this.headersSent) {
+      throw new Error("Cannot set headers after they are sent");
+    }
+    this._headers.set(name.toLowerCase(), String(value));
+    return this;
+  }
+  getHeader(name) {
+    return this._headers.get(name.toLowerCase());
+  }
+  getHeaders() {
+    const headers = {};
+    for (const [key, value] of this._headers) {
+      headers[key] = value;
+    }
+    return headers;
+  }
+  getHeaderNames() {
+    return [...this._headers.keys()];
+  }
+  hasHeader(name) {
+    return this._headers.has(name.toLowerCase());
+  }
+  removeHeader(name) {
+    if (this.headersSent) {
+      throw new Error("Cannot remove headers after they are sent");
+    }
+    this._headers.delete(name.toLowerCase());
+  }
+  writeHead(statusCode, statusMessageOrHeaders, headers) {
+    this.statusCode = statusCode;
+    if (typeof statusMessageOrHeaders === "string") {
+      this.statusMessage = statusMessageOrHeaders;
+      if (headers) {
+        for (const [key, value] of Object.entries(headers)) {
+          this.setHeader(key, value);
+        }
+      }
+    } else if (statusMessageOrHeaders) {
+      for (const [key, value] of Object.entries(statusMessageOrHeaders)) {
+        this.setHeader(key, value);
+      }
+    }
+    return this;
+  }
+  write(chunk, encodingOrCallback, callback) {
+    this.headersSent = true;
+    const buffer = typeof chunk === "string" ? BufferPolyfill.from(chunk) : chunk;
+    this._body.push(buffer);
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb) {
+      queueMicrotask(() => cb(null));
+    }
+    return true;
+  }
+  end(chunkOrCallback, encodingOrCallback, callback) {
+    if (typeof chunkOrCallback === "function") {
+      callback = chunkOrCallback;
+    } else if (chunkOrCallback !== void 0) {
+      this.write(chunkOrCallback);
+    }
+    if (typeof encodingOrCallback === "function") {
+      callback = encodingOrCallback;
+    }
+    this.headersSent = true;
+    this.finished = true;
+    if (this._resolve) {
+      const headers = {};
+      for (const [key, value] of this._headers) {
+        headers[key] = Array.isArray(value) ? value.join(", ") : value;
+      }
+      this._resolve({
+        statusCode: this.statusCode,
+        statusMessage: this.statusMessage,
+        headers,
+        body: BufferPolyfill.concat(this._body)
+      });
+    }
+    queueMicrotask(() => {
+      this.emit("finish");
+      if (callback) callback();
+    });
+    return this;
+  }
+  // Convenience method for simple responses
+  send(data) {
+    if (typeof data === "object" && !BufferPolyfill.isBuffer(data)) {
+      this.setHeader("Content-Type", "application/json");
+      data = JSON.stringify(data);
+    }
+    if (!this.hasHeader("Content-Type")) {
+      this.setHeader("Content-Type", "text/html");
+    }
+    this.write(typeof data === "string" ? data : data);
+    return this.end();
+  }
+  // Express compatibility
+  json(data) {
+    this.setHeader("Content-Type", "application/json");
+    return this.end(JSON.stringify(data));
+  }
+  status(code) {
+    this.statusCode = code;
+    return this;
+  }
+  redirect(urlOrStatus, url) {
+    if (typeof urlOrStatus === "number") {
+      this.statusCode = urlOrStatus;
+      this.setHeader("Location", url);
+    } else {
+      this.statusCode = 302;
+      this.setHeader("Location", urlOrStatus);
+    }
+    this.end();
+  }
+  // Get body for testing/debugging
+  _getBody() {
+    return BufferPolyfill.concat(this._body);
+  }
+  _getBodyAsString() {
+    return this._getBody().toString("utf8");
+  }
+};
+var Server2 = class extends EventEmitter {
+  _netServer;
+  _requestListener;
+  _pendingRequests = /* @__PURE__ */ new Map();
+  listening = false;
+  maxHeadersCount = null;
+  timeout = 0;
+  keepAliveTimeout = 5e3;
+  headersTimeout = 6e4;
+  requestTimeout = 0;
+  constructor(requestListener) {
+    super();
+    this._requestListener = requestListener;
+    this._netServer = new Server();
+    this._netServer.on("listening", () => {
+      this.listening = true;
+      this.emit("listening");
+    });
+    this._netServer.on("close", () => {
+      this.listening = false;
+      this.emit("close");
+    });
+    this._netServer.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  listen(portOrOptions, hostOrCallback, callback) {
+    let port;
+    let host;
+    let cb;
+    if (typeof portOrOptions === "number") {
+      port = portOrOptions;
+      if (typeof hostOrCallback === "string") {
+        host = hostOrCallback;
+        cb = callback;
+      } else {
+        cb = hostOrCallback;
+      }
+    } else if (portOrOptions) {
+      port = portOrOptions.port;
+      host = portOrOptions.host;
+      cb = typeof hostOrCallback === "function" ? hostOrCallback : callback;
+    }
+    const originalCb = cb;
+    const self = this;
+    cb = function() {
+      const addr = self._netServer.address();
+      if (addr) {
+        _registerServer(addr.port, self);
+      }
+      if (originalCb) originalCb();
+    };
+    this._netServer.listen(port, host, cb);
+    return this;
+  }
+  close(callback) {
+    const addr = this._netServer.address();
+    if (addr) {
+      _unregisterServer(addr.port);
+    }
+    this._netServer.close(callback);
+    return this;
+  }
+  address() {
+    return this._netServer.address();
+  }
+  setTimeout(msecs, callback) {
+    this.timeout = msecs || 0;
+    if (callback) {
+      this.on("timeout", callback);
+    }
+    return this;
+  }
+  ref() {
+    this._netServer.ref();
+    return this;
+  }
+  unref() {
+    this._netServer.unref();
+    return this;
+  }
+  /**
+   * Handle an incoming request (used by server bridge)
+   */
+  async handleRequest(method, url, headers, body) {
+    return new Promise((resolve, reject) => {
+      const req = IncomingMessage.fromRequest(method, url, headers, body);
+      const res = new ServerResponse(req);
+      res._setResolver(resolve);
+      const timeoutId = this.timeout ? setTimeout(() => {
+        reject(new Error("Request timeout"));
+      }, this.timeout) : null;
+      res.on("finish", () => {
+        if (timeoutId) clearTimeout(timeoutId);
+      });
+      try {
+        this.emit("request", req, res);
+        if (this._requestListener) {
+          this._requestListener(req, res);
+        }
+      } catch (error) {
+        if (timeoutId) clearTimeout(timeoutId);
+        reject(error);
+      }
+    });
+  }
+};
+function createServer2(requestListener) {
+  return new Server2(requestListener);
+}
+var STATUS_CODES = {
+  100: "Continue",
+  101: "Switching Protocols",
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  301: "Moved Permanently",
+  302: "Found",
+  304: "Not Modified",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  408: "Request Timeout",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable"
+};
+var METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE"
+];
+function getCorsProxy() {
+  if (typeof localStorage !== "undefined") {
+    return localStorage.getItem("__corsProxyUrl") || null;
+  }
+  return null;
+}
+var ClientRequest = class extends Writable {
+  method;
+  path;
+  headers;
+  _options;
+  _protocol;
+  _bodyChunks = [];
+  _aborted = false;
+  _timeout = null;
+  _timeoutId = null;
+  _requestEnded = false;
+  constructor(options, protocol = "http") {
+    super();
+    this._options = options;
+    this._protocol = protocol;
+    this.method = options.method || "GET";
+    this.path = options.path || "/";
+    this.headers = {};
+    if (options.headers) {
+      for (const [key, value] of Object.entries(options.headers)) {
+        this.headers[key.toLowerCase()] = Array.isArray(value) ? value.join(", ") : value;
+      }
+    }
+  }
+  setHeader(name, value) {
+    this.headers[name.toLowerCase()] = value;
+  }
+  getHeader(name) {
+    return this.headers[name.toLowerCase()];
+  }
+  removeHeader(name) {
+    delete this.headers[name.toLowerCase()];
+  }
+  write(chunk, encodingOrCallback, callback) {
+    const buffer = typeof chunk === "string" ? BufferPolyfill.from(chunk) : chunk;
+    this._bodyChunks.push(buffer);
+    const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+    if (cb) {
+      queueMicrotask(() => cb(null));
+    }
+    return true;
+  }
+  end(dataOrCallback, encodingOrCallback, callback) {
+    if (this._requestEnded) return this;
+    this._requestEnded = true;
+    let finalCallback = callback;
+    if (typeof dataOrCallback === "function") {
+      finalCallback = dataOrCallback;
+    } else if (dataOrCallback !== void 0) {
+      this.write(dataOrCallback);
+    }
+    if (typeof encodingOrCallback === "function") {
+      finalCallback = encodingOrCallback;
+    }
+    this._performRequest().then(() => {
+      if (finalCallback) finalCallback();
+    }).catch((error) => {
+      this.emit("error", error);
+    });
+    return this;
+  }
+  abort() {
+    this._aborted = true;
+    if (this._timeoutId) {
+      clearTimeout(this._timeoutId);
+    }
+    this.emit("abort");
+  }
+  setTimeout(ms, callback) {
+    this._timeout = ms;
+    if (callback) {
+      this.once("timeout", callback);
+    }
+    return this;
+  }
+  async _performRequest() {
+    if (this._aborted) return;
+    try {
+      const protocol = this._protocol === "https" ? "https:" : "http:";
+      let hostname = this._options.hostname || "";
+      let port = this._options.port ? `:${this._options.port}` : "";
+      if (!hostname && this._options.host) {
+        const hostParts = this._options.host.split(":");
+        hostname = hostParts[0];
+        if (!port && hostParts[1]) {
+          port = `:${hostParts[1]}`;
+        }
+      }
+      if (!hostname) hostname = "localhost";
+      const path = this._options.path || "/";
+      const url = `${protocol}//${hostname}${port}${path}`;
+      if (this.headers["upgrade"]?.toLowerCase() === "websocket") {
+        this._handleWebSocketUpgrade(url);
+        return;
+      }
+      const corsProxy = getCorsProxy();
+      const fetchUrl = corsProxy ? corsProxy + encodeURIComponent(url) : url;
+      const fetchOptions = {
+        method: this.method,
+        headers: this.headers
+      };
+      if (this._bodyChunks.length > 0 && this.method !== "GET" && this.method !== "HEAD") {
+        fetchOptions.body = BufferPolyfill.concat(this._bodyChunks);
+      }
+      const controller = new AbortController();
+      fetchOptions.signal = controller.signal;
+      if (this._timeout) {
+        this._timeoutId = setTimeout(() => {
+          controller.abort();
+          this.emit("timeout");
+        }, this._timeout);
+      }
+      const response = await fetch(fetchUrl, fetchOptions);
+      if (this._timeoutId) {
+        clearTimeout(this._timeoutId);
+        this._timeoutId = null;
+      }
+      if (this._aborted) return;
+      const incomingMessage = await this._responseToIncomingMessage(response);
+      this.emit("response", incomingMessage);
+    } catch (error) {
+      if (this._timeoutId) {
+        clearTimeout(this._timeoutId);
+      }
+      if (this._aborted) return;
+      if (error instanceof Error && error.name === "AbortError") {
+        return;
+      }
+      this.emit("error", error);
+    }
+  }
+  async _responseToIncomingMessage(response) {
+    const msg = new IncomingMessage();
+    msg.statusCode = response.status;
+    msg.statusMessage = response.statusText || STATUS_CODES[response.status] || "";
+    response.headers.forEach((value, key) => {
+      msg.headers[key.toLowerCase()] = value;
+      msg.rawHeaders.push(key, value);
+    });
+    const body = await response.arrayBuffer();
+    msg._setBody(BufferPolyfill.from(body));
+    return msg;
+  }
+  /**
+   * Bridge a WebSocket upgrade request to the browser's native WebSocket.
+   *
+   * The bundled ws library (inside the Convex CLI) creates WebSocket connections
+   * via http.request() with Upgrade headers. It expects frame-level I/O on the
+   * socket from the 'upgrade' event. This method bridges between:
+   *   - ws library ↔ frame-level I/O on a mock Socket
+   *   - browser native WebSocket ↔ message-level I/O
+   */
+  _handleWebSocketUpgrade(url) {
+    const wsUrl = url.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+    const wsKey = this.headers["sec-websocket-key"] || "";
+    const NativeWS = _BrowserWebSocket;
+    if (!NativeWS) {
+      setTimeout(() => {
+        this.emit("error", new TypeError("Failed to fetch"));
+      }, 0);
+      return;
+    }
+    const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+    const acceptValue = createHash("sha1").update(wsKey + GUID).digest("base64");
+    let nativeWs;
+    try {
+      nativeWs = new NativeWS(wsUrl);
+      nativeWs.binaryType = "arraybuffer";
+    } catch (e) {
+      setTimeout(() => {
+        this.emit("error", e instanceof Error ? e : new Error(String(e)));
+      }, 0);
+      return;
+    }
+    const socket = new Socket();
+    if (typeof socket.cork !== "function") socket.cork = () => {
+    };
+    if (typeof socket.uncork !== "function") socket.uncork = () => {
+    };
+    socket._readableState = { endEmitted: false };
+    socket._writableState = { finished: false, errorEmitted: false };
+    let writeBuffer = new Uint8Array(0);
+    socket.write = ((chunk, encodingOrCallback, callback) => {
+      const data = typeof chunk === "string" ? BufferPolyfill.from(chunk) : new Uint8Array(chunk);
+      const cb = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;
+      const newBuf = new Uint8Array(writeBuffer.length + data.length);
+      newBuf.set(writeBuffer, 0);
+      newBuf.set(data, writeBuffer.length);
+      writeBuffer = newBuf;
+      while (writeBuffer.length >= 2) {
+        const parsed = _parseWsFrame(writeBuffer);
+        if (!parsed) break;
+        const { opcode, payload, totalLength } = parsed;
+        writeBuffer = writeBuffer.slice(totalLength);
+        if (nativeWs.readyState !== NativeWS.OPEN) continue;
+        if (opcode === 8) {
+          nativeWs.close();
+        } else if (opcode === 9) {
+          nativeWs.send(payload);
+        } else if (opcode === 10) {
+        } else if (opcode === 1) {
+          const text = new TextDecoder().decode(payload);
+          nativeWs.send(text);
+        } else if (opcode === 2) {
+          nativeWs.send(payload);
+        }
+      }
+      if (cb) queueMicrotask(() => cb(null));
+      return true;
+    });
+    nativeWs.onopen = () => {
+      const response = new IncomingMessage(socket);
+      response.statusCode = 101;
+      response.statusMessage = "Switching Protocols";
+      response.headers = {
+        "upgrade": "websocket",
+        "connection": "Upgrade",
+        "sec-websocket-accept": acceptValue
+      };
+      response.complete = true;
+      response.push(null);
+      this.emit("upgrade", response, socket, BufferPolyfill.alloc(0));
+    };
+    nativeWs.onmessage = (event) => {
+      let payload;
+      let opcode;
+      if (typeof event.data === "string") {
+        payload = new TextEncoder().encode(event.data);
+        opcode = 1;
+      } else if (event.data instanceof ArrayBuffer) {
+        payload = new Uint8Array(event.data);
+        opcode = 2;
+      } else {
+        return;
+      }
+      const frame = _createWsFrame(opcode, payload, false);
+      socket._receiveData(BufferPolyfill.from(frame));
+    };
+    nativeWs.onclose = (event) => {
+      const code = event.code || 1e3;
+      const closePayload = new Uint8Array(2);
+      closePayload[0] = code >> 8 & 255;
+      closePayload[1] = code & 255;
+      const frame = _createWsFrame(8, closePayload, false);
+      socket._receiveData(BufferPolyfill.from(frame));
+      setTimeout(() => {
+        socket._readableState.endEmitted = true;
+        socket._receiveEnd();
+        socket.emit("close", false);
+      }, 10);
+    };
+    nativeWs.onerror = () => {
+      socket.emit("error", new Error("WebSocket connection error"));
+      socket.destroy();
+    };
+    const origDestroy = socket.destroy.bind(socket);
+    socket.destroy = ((error) => {
+      if (nativeWs.readyState === NativeWS.OPEN || nativeWs.readyState === NativeWS.CONNECTING) {
+        nativeWs.close();
+      }
+      return origDestroy(error);
+    });
+  }
+};
+function parseRequestArgs(urlOrOptions, optionsOrCallback, callback) {
+  let options;
+  let cb = callback;
+  if (typeof urlOrOptions === "string" || urlOrOptions instanceof URL) {
+    const parsed = new URL(urlOrOptions.toString());
+    options = {
+      hostname: parsed.hostname,
+      port: parsed.port ? parseInt(parsed.port) : void 0,
+      path: parsed.pathname + parsed.search,
+      method: "GET"
+    };
+    if (typeof optionsOrCallback === "function") {
+      cb = optionsOrCallback;
+    } else if (optionsOrCallback) {
+      options = { ...options, ...optionsOrCallback };
+    }
+  } else {
+    options = urlOrOptions;
+    if (typeof optionsOrCallback === "function") {
+      cb = optionsOrCallback;
+    }
+  }
+  return { options, callback: cb };
+}
+function request(urlOrOptions, optionsOrCallback, callback) {
+  const { options, callback: cb } = parseRequestArgs(urlOrOptions, optionsOrCallback, callback);
+  const req = new ClientRequest(options, "http");
+  if (cb) {
+    req.once("response", cb);
+  }
+  return req;
+}
+function get(urlOrOptions, optionsOrCallback, callback) {
+  const { options, callback: cb } = parseRequestArgs(urlOrOptions, optionsOrCallback, callback);
+  const req = new ClientRequest({ ...options, method: "GET" }, "http");
+  if (cb) {
+    req.once("response", cb);
+  }
+  req.end();
+  return req;
+}
+function _createClientRequest(urlOrOptions, optionsOrCallback, callback, protocol) {
+  const { options, callback: cb } = parseRequestArgs(urlOrOptions, optionsOrCallback, callback);
+  const req = new ClientRequest(options, protocol);
+  if (cb) {
+    req.once("response", cb);
+  }
+  return req;
+}
+var serverRegistry = /* @__PURE__ */ new Map();
+var onServerListenCallback = null;
+var onServerCloseCallback = null;
+function _registerServer(port, server) {
+  serverRegistry.set(port, server);
+  if (onServerListenCallback) {
+    onServerListenCallback(port, server);
+  }
+}
+function _unregisterServer(port) {
+  serverRegistry.delete(port);
+  if (onServerCloseCallback) {
+    onServerCloseCallback(port);
+  }
+}
+function getServer(port) {
+  return serverRegistry.get(port);
+}
+function getAllServers() {
+  return new Map(serverRegistry);
+}
+function setServerListenCallback(callback) {
+  onServerListenCallback = callback;
+}
+function setServerCloseCallback(callback) {
+  onServerCloseCallback = callback;
+}
+var Agent = class extends EventEmitter {
+  maxSockets;
+  maxFreeSockets;
+  maxTotalSockets;
+  sockets;
+  freeSockets;
+  requests;
+  options;
+  constructor(opts) {
+    super();
+    this.options = opts || {};
+    this.maxSockets = opts?.maxSockets ?? Infinity;
+    this.maxFreeSockets = opts?.maxFreeSockets ?? 256;
+    this.maxTotalSockets = opts?.maxTotalSockets ?? Infinity;
+    this.sockets = {};
+    this.freeSockets = {};
+    this.requests = {};
+  }
+  createConnection(_options, callback) {
+    const socket = new Socket();
+    if (callback) {
+      callback(null, socket);
+    }
+    return socket;
+  }
+  getName(options) {
+    const host = options.host || "localhost";
+    const port = options.port || 80;
+    return `${host}:${port}:${options.localAddress || ""}`;
+  }
+  addRequest(_req, _options) {
+  }
+  destroy() {
+    this.sockets = {};
+    this.freeSockets = {};
+    this.requests = {};
+  }
+};
+var globalAgent = new Agent();
+function _parseWsFrame(data) {
+  if (data.length < 2) return null;
+  const opcode = data[0] & 15;
+  const masked = (data[1] & 128) !== 0;
+  let payloadLength = data[1] & 127;
+  let offset = 2;
+  if (payloadLength === 126) {
+    if (data.length < 4) return null;
+    payloadLength = data[2] << 8 | data[3];
+    offset = 4;
+  } else if (payloadLength === 127) {
+    if (data.length < 10) return null;
+    payloadLength = data[6] << 24 | data[7] << 16 | data[8] << 8 | data[9];
+    offset = 10;
+  }
+  if (masked) {
+    if (data.length < offset + 4 + payloadLength) return null;
+    const maskKey = data.slice(offset, offset + 4);
+    offset += 4;
+    const payload = new Uint8Array(payloadLength);
+    for (let i = 0; i < payloadLength; i++) {
+      payload[i] = data[offset + i] ^ maskKey[i % 4];
+    }
+    return { opcode, payload, totalLength: offset + payloadLength };
+  } else {
+    if (data.length < offset + payloadLength) return null;
+    const payload = data.slice(offset, offset + payloadLength);
+    return { opcode, payload, totalLength: offset + payloadLength };
+  }
+}
+function _createWsFrame(opcode, payload, masked) {
+  const length = payload.length;
+  let headerSize = 2;
+  if (length > 125 && length <= 65535) {
+    headerSize += 2;
+  } else if (length > 65535) {
+    headerSize += 8;
+  }
+  if (masked) {
+    headerSize += 4;
+  }
+  const frame = new Uint8Array(headerSize + length);
+  frame[0] = 128 | opcode;
+  let offset = 2;
+  if (length <= 125) {
+    frame[1] = (masked ? 128 : 0) | length;
+  } else if (length <= 65535) {
+    frame[1] = (masked ? 128 : 0) | 126;
+    frame[2] = length >> 8 & 255;
+    frame[3] = length & 255;
+    offset = 4;
+  } else {
+    frame[1] = (masked ? 128 : 0) | 127;
+    frame[2] = 0;
+    frame[3] = 0;
+    frame[4] = 0;
+    frame[5] = 0;
+    frame[6] = length >> 24 & 255;
+    frame[7] = length >> 16 & 255;
+    frame[8] = length >> 8 & 255;
+    frame[9] = length & 255;
+    offset = 10;
+  }
+  if (masked) {
+    const maskKey = new Uint8Array(4);
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      crypto.getRandomValues(maskKey);
+    } else {
+      for (let i = 0; i < 4; i++) maskKey[i] = Math.floor(Math.random() * 256);
+    }
+    frame.set(maskKey, offset);
+    offset += 4;
+    for (let i = 0; i < length; i++) {
+      frame[offset + i] = payload[i] ^ maskKey[i % 4];
+    }
+  } else {
+    frame.set(payload, offset);
+  }
+  return frame;
+}
+var http_default = {
+  Server: Server2,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer: createServer2,
+  request,
+  get,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  _createClientRequest,
+  Agent,
+  globalAgent,
+  _parseWsFrame,
+  _createWsFrame
+};
+
+export {
+  uint8ToBase64,
+  base64ToUint8,
+  uint8ToHex,
+  uint8ToBinaryString,
+  EventEmitter,
+  events_default,
+  Readable,
+  Writable,
+  BufferPolyfill,
+  stream_default,
+  net_exports,
+  crypto_exports,
+  IncomingMessage,
+  ServerResponse,
+  Server2 as Server,
+  createServer2 as createServer,
+  STATUS_CODES,
+  METHODS,
+  ClientRequest,
+  _createClientRequest,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  Agent,
+  globalAgent,
+  http_exports
+};
+//# sourceMappingURL=chunk-L7KW6Y27.js.map