@scelar/nodepod 1.0.0

package/src/polyfills/http.ts

@@ -0,0 +1,1449 @@
+// HTTP polyfill -- IncomingMessage, ServerResponse, Server, ClientRequest (fetch-backed),
+// createServer, request, get, Agent, STATUS_CODES, WebSocket upgrade bridging.
+// Uses function constructors (not classes) for pre-ES6 inheritance compat.
+
+import { EventEmitter, type EventHandler } from "./events";
+import { Readable, Writable } from "./stream";
+import { Buffer } from "./buffer";
+import { TcpSocket, TcpServer, type NetAddress } from "./net";
+import { createHash } from "./crypto";
+import { ref as _elRef, unref as _elUnref } from "../helpers/event-loop";
+import { TIMEOUTS } from "../constants/config";
+
+// capture real browser WebSocket before any bundled lib can overwrite it
+const _runningInBrowser =
+  typeof window !== "undefined" && typeof window.document !== "undefined";
+const _NativeWebSocket: typeof globalThis.WebSocket | null =
+  _runningInBrowser && typeof globalThis.WebSocket === "function"
+    ? globalThis.WebSocket
+    : null;
+
+// Types
+
+export type HttpHandler = (
+  incoming: IncomingMessage,
+  outgoing: ServerResponse,
+) => void | Promise<void>;
+
+export interface ConnectionOptions {
+  method?: string;
+  path?: string;
+  headers?: Record<string, string | string[]>;
+  hostname?: string;
+  host?: string;
+  port?: number;
+}
+
+export interface CompletedResponse {
+  statusCode: number;
+  statusMessage: string;
+  headers: Record<string, string>;
+  body: Buffer;
+}
+
+// IncomingMessage
+
+export interface IncomingMessage extends Readable {
+  httpVersion: string;
+  httpVersionMajor: number;
+  httpVersionMinor: number;
+  complete: boolean;
+  headers: Record<string, string | string[] | undefined>;
+  rawHeaders: string[];
+  trailers: Record<string, string | undefined>;
+  rawTrailers: string[];
+  method?: string;
+  url?: string;
+  statusCode?: number;
+  statusMessage?: string;
+  aborted: boolean;
+  socket: TcpSocket;
+  connection: TcpSocket;
+  setTimeout(ms: number, handler?: () => void): this;
+  destroy(err?: Error): this;
+  _injectBody(raw: Buffer | string | null): void;
+}
+
+export interface IncomingMessageConstructor {
+  new (sock?: TcpSocket): IncomingMessage;
+  (this: any, sock?: TcpSocket): void;
+  prototype: any;
+  build(
+    verb: string,
+    target: string,
+    hdrs: Record<string, string>,
+    payload?: Buffer | string,
+  ): IncomingMessage;
+}
+
+export const IncomingMessage = function IncomingMessage(this: any, sock?: TcpSocket) {
+  if (!this) return;
+  Readable.call(this);
+
+  this.httpVersion = "1.1";
+  this.httpVersionMajor = 1;
+  this.httpVersionMinor = 1;
+  this.complete = false;
+  this.headers = {};
+  this.rawHeaders = [];
+  this.trailers = {};
+  this.rawTrailers = [];
+  this.method = undefined;
+  this.url = undefined;
+  this.statusCode = undefined;
+  this.statusMessage = undefined;
+  this.aborted = false;
+  this._payload = null;
+  this.socket = sock ?? new TcpSocket();
+  this.connection = this.socket;
+} as unknown as IncomingMessageConstructor;
+
+Object.setPrototypeOf(IncomingMessage.prototype, Readable.prototype);
+
+IncomingMessage.prototype.setTimeout = function setTimeout(ms: number, handler?: () => void): any {
+  if (handler) this.once("timeout", handler);
+  return this;
+};
+
+IncomingMessage.prototype.destroy = function destroy(err?: Error): any {
+  Readable.prototype.destroy.call(this, err);
+  return this;
+};
+
+IncomingMessage.prototype._injectBody = function _injectBody(raw: Buffer | string | null): void {
+  if (raw === null) {
+    this._payload = null;
+  } else {
+    this._payload = typeof raw === "string" ? Buffer.from(raw) : raw;
+  }
+  // Defer push to next microtask so that stream consumers (body-parser, raw-body)
+  // can attach 'data'/'end' listeners before the stream is marked as ended.
+  // Without this, push(null) sets readable=false immediately and raw-body
+  // bails out with "stream is not readable".
+  const self = this;
+  queueMicrotask(() => {
+    if (self._payload) self.push(self._payload);
+    self.push(null);
+    self.complete = true;
+  });
+};
+
+IncomingMessage.build = function build(
+  verb: string,
+  target: string,
+  hdrs: Record<string, string>,
+  payload?: Buffer | string,
+): IncomingMessage {
+  const sock = new TcpSocket();
+  sock.remoteAddress = "127.0.0.1";
+  sock.remotePort = 0;
+  sock.remoteFamily = "IPv4";
+  const msg = new IncomingMessage(sock);
+  msg.method = verb;
+  msg.url = target;
+  // Node.js always lowercases header keys in req.headers
+  const lowerHdrs: Record<string, string> = {};
+  for (const [k, v] of Object.entries(hdrs)) {
+    lowerHdrs[k.toLowerCase()] = v;
+    msg.rawHeaders.push(k, v);
+  }
+  msg.headers = lowerHdrs;
+  if (payload) {
+    msg._injectBody(payload);
+  } else {
+    // Defer end signal for bodyless requests too, for consistent behavior
+    queueMicrotask(() => {
+      msg.push(null);
+      msg.complete = true;
+    });
+  }
+  return msg;
+};
+
+// ServerResponse
+
+export interface ServerResponse extends Writable {
+  statusCode: number;
+  statusMessage: string;
+  headersSent: boolean;
+  finished: boolean;
+  sendDate: boolean;
+  socket: TcpSocket | null;
+  req: IncomingMessage;
+  connection: TcpSocket | null;
+  _onComplete(fn: (r: CompletedResponse) => void): void;
+  assignSocket(socket: TcpSocket): void;
+  detachSocket(socket: TcpSocket): void;
+  setHeader(key: string, val: string | string[] | number): this;
+  getHeader(key: string): string | string[] | undefined;
+  getHeaders(): Record<string, string | string[]>;
+  getHeaderNames(): string[];
+  hasHeader(key: string): boolean;
+  appendHeader(key: string, val: string | string[]): this;
+  removeHeader(key: string): void;
+  flushHeaders(): void;
+  writeContinue(): void;
+  writeProcessing(): void;
+  writeEarlyHints(hints: Record<string, string | string[]>, cb?: () => void): void;
+  writeHead(code: number, msgOrHdrs?: any, extraHdrs?: any): this;
+  write(data: any, encOrCb?: any, cb?: any): boolean;
+  end(dataOrCb?: any, encOrCb?: any, cb?: any): this;
+  send(payload: string | Buffer | object): this;
+  setTimeout(ms: number, handler?: () => void): this;
+  json(obj: unknown): this;
+  status(c: number): this;
+  redirect(target: string | number, loc?: string): void;
+  addTrailers(headers: Record<string, string>): void;
+  _collectedBody(): Buffer;
+  _collectedBodyText(): string;
+}
+
+export interface ServerResponseConstructor {
+  new (incoming: IncomingMessage): ServerResponse;
+  (this: any, incoming: IncomingMessage): void;
+  prototype: any;
+}
+
+export const ServerResponse = function ServerResponse(this: any, incoming: any) {
+  if (!this) return;
+  Writable.call(this);
+
+  this.statusCode = 200;
+  this.statusMessage = "OK";
+  this.headersSent = false;
+  this.finished = false;
+  this.sendDate = true;
+  this.socket = incoming.socket;
+  this.connection = incoming.socket;
+  this.req = incoming;
+  this._hdrs = new Map();
+  this._chunks = [];
+  this._completionCallback = undefined;
+} as unknown as ServerResponseConstructor;
+
+Object.setPrototypeOf(ServerResponse.prototype, Writable.prototype);
+
+ServerResponse.prototype._onComplete = function _onComplete(fn: (r: CompletedResponse) => void): void {
+  this._completionCallback = fn;
+};
+
+ServerResponse.prototype.assignSocket = function assignSocket(socket: TcpSocket): void {
+  this.socket = socket;
+  this.connection = socket;
+};
+
+ServerResponse.prototype.detachSocket = function detachSocket(_socket: TcpSocket): void {
+  this.socket = null;
+  this.connection = null;
+};
+
+ServerResponse.prototype.setHeader = function setHeader(key: string, val: string | string[] | number): any {
+  if (this.headersSent) throw new Error("Headers already dispatched");
+  this._hdrs.set(key.toLowerCase(), String(val));
+  return this;
+};
+
+ServerResponse.prototype.getHeader = function getHeader(key: string): string | string[] | undefined {
+  return this._hdrs.get(key.toLowerCase());
+};
+
+ServerResponse.prototype.getHeaders = function getHeaders(): Record<string, string | string[]> {
+  const out: Record<string, string | string[]> = {};
+  this._hdrs.forEach((v: string | string[], k: string) => {
+    out[k] = v;
+  });
+  return out;
+};
+
+ServerResponse.prototype.getHeaderNames = function getHeaderNames(): string[] {
+  return [...this._hdrs.keys()];
+};
+
+ServerResponse.prototype.hasHeader = function hasHeader(key: string): boolean {
+  return this._hdrs.has(key.toLowerCase());
+};
+
+ServerResponse.prototype.appendHeader = function appendHeader(key: string, val: string | string[]): any {
+  const lk = key.toLowerCase();
+  const existing = this._hdrs.get(lk);
+  if (existing === undefined) {
+    this._hdrs.set(lk, Array.isArray(val) ? val.join(", ") : val);
+  } else {
+    const append = Array.isArray(val) ? val.join(", ") : val;
+    const cur = Array.isArray(existing) ? existing.join(", ") : existing;
+    this._hdrs.set(lk, cur + ", " + append);
+  }
+  return this;
+};
+
+ServerResponse.prototype.removeHeader = function removeHeader(key: string): void {
+  if (this.headersSent) throw new Error("Headers already dispatched");
+  this._hdrs.delete(key.toLowerCase());
+};
+
+ServerResponse.prototype.flushHeaders = function flushHeaders(): void {
+  this.headersSent = true;
+};
+
+ServerResponse.prototype.writeContinue = function writeContinue(): void {
+  // No-op in polyfill
+};
+
+ServerResponse.prototype.writeProcessing = function writeProcessing(): void {
+  // No-op in polyfill
+};
+
+ServerResponse.prototype.writeEarlyHints = function writeEarlyHints(
+  _hints: Record<string, string | string[]>,
+  _cb?: () => void,
+): void {
+  if (_cb) queueMicrotask(_cb);
+};
+
+ServerResponse.prototype.writeHead = function writeHead(
+  code: number,
+  msgOrHdrs?: string | Record<string, string | string[] | number> | string[],
+  extraHdrs?: Record<string, string | string[] | number> | string[],
+): any {
+  this.statusCode = code;
+  if (typeof msgOrHdrs === "string") {
+    this.statusMessage = msgOrHdrs;
+    if (extraHdrs) {
+      if (Array.isArray(extraHdrs)) {
+        for (let i = 0; i < extraHdrs.length; i += 2) {
+          this.setHeader(extraHdrs[i] as string, extraHdrs[i + 1] as string);
+        }
+      } else {
+        for (const [k, v] of Object.entries(extraHdrs)) this.setHeader(k, v);
+      }
+    }
+  } else if (Array.isArray(msgOrHdrs)) {
+    for (let i = 0; i < msgOrHdrs.length; i += 2) {
+      this.setHeader(msgOrHdrs[i] as string, msgOrHdrs[i + 1] as string);
+    }
+  } else if (msgOrHdrs) {
+    for (const [k, v] of Object.entries(msgOrHdrs)) this.setHeader(k, v);
+  }
+  return this;
+};
+
+ServerResponse.prototype.write = function write(
+  data: Uint8Array | string,
+  encOrCb?: BufferEncoding | ((err?: Error | null) => void),
+  cb?: (err?: Error | null) => void,
+): boolean {
+  this.headersSent = true;
+  const buf = typeof data === "string" ? Buffer.from(data) : data;
+  this._chunks.push(buf);
+  const fn = typeof encOrCb === "function" ? encOrCb : cb;
+  if (fn) queueMicrotask(() => fn(null));
+  return true;
+};
+
+ServerResponse.prototype.end = function end(
+  dataOrCb?: Uint8Array | string | (() => void),
+  encOrCb?: BufferEncoding | (() => void),
+  cb?: () => void,
+): any {
+  if (typeof dataOrCb === "function") {
+    cb = dataOrCb;
+  } else if (dataOrCb !== undefined) {
+    this.write(dataOrCb as Uint8Array | string);
+  }
+  if (typeof encOrCb === "function") cb = encOrCb;
+
+  this.headersSent = true;
+  this.finished = true;
+  this.writableEnded = true;
+  this.writableFinished = true;
+
+  if (this._completionCallback) {
+    const flatHdrs: Record<string, string> = {};
+    this._hdrs.forEach((v: string | string[], k: string) => {
+      flatHdrs[k] = Array.isArray(v) ? v.join(", ") : v;
+    });
+    this._completionCallback({
+      statusCode: this.statusCode,
+      statusMessage: this.statusMessage,
+      headers: flatHdrs,
+      body: Buffer.concat(this._chunks),
+    });
+  }
+
+  const self = this;
+  queueMicrotask(() => {
+    self.emit("finish");
+    if (cb) cb();
+  });
+  return this;
+};
+
+ServerResponse.prototype.send = function send(payload: string | Buffer | object): any {
+  if (typeof payload === "object" && !Buffer.isBuffer(payload)) {
+    this.setHeader("Content-Type", "application/json");
+    payload = JSON.stringify(payload);
+  }
+  if (!this.hasHeader("Content-Type")) {
+    this.setHeader("Content-Type", "text/html");
+  }
+  this.write(typeof payload === "string" ? payload : payload);
+  return this.end();
+};
+
+ServerResponse.prototype.setTimeout = function setTimeout(ms: number, handler?: () => void): any {
+  if (handler) this.once("timeout", handler);
+  return this;
+};
+
+ServerResponse.prototype.json = function json(obj: unknown): any {
+  this.setHeader("Content-Type", "application/json");
+  return this.end(JSON.stringify(obj));
+};
+
+ServerResponse.prototype.status = function status(c: number): any {
+  this.statusCode = c;
+  return this;
+};
+
+ServerResponse.prototype.redirect = function redirect(target: string | number, loc?: string): void {
+  if (typeof target === "number") {
+    this.statusCode = target;
+    this.setHeader("Location", loc!);
+  } else {
+    this.statusCode = 302;
+    this.setHeader("Location", target);
+  }
+  this.end();
+};
+
+ServerResponse.prototype.addTrailers = function addTrailers(_headers: Record<string, string>): void {
+  // No-op
+};
+
+ServerResponse.prototype._collectedBody = function _collectedBody(): Buffer {
+  return Buffer.concat(this._chunks);
+};
+
+ServerResponse.prototype._collectedBodyText = function _collectedBodyText(): string {
+  return this._collectedBody().toString("utf8");
+};
+
+// Server
+
+export interface Server extends EventEmitter {
+  listening: boolean;
+  maxHeadersCount: number | null;
+  timeout: number;
+  keepAliveTimeout: number;
+  headersTimeout: number;
+  requestTimeout: number;
+  maxRequestsPerSocket: number | null;
+  listen(portOrOpts?: any, hostOrCb?: any, cb?: any): this;
+  close(cb?: (err?: Error) => void): this;
+  address(): NetAddress | null;
+  setTimeout(ms?: number, handler?: () => void): this;
+  ref(): this;
+  unref(): this;
+  closeAllConnections(): void;
+  closeIdleConnections(): void;
+  dispatchUpgrade(target: string, hdrs: Record<string, string>): { req: IncomingMessage; socket: TcpSocket };
+  dispatchRequest(verb: string, target: string, hdrs: Record<string, string>, payload?: Buffer | string): Promise<CompletedResponse>;
+}
+
+export interface ServerConstructor {
+  new (optsOrHandler?: Record<string, unknown> | HttpHandler, handler?: HttpHandler): Server;
+  (this: any, optsOrHandler?: Record<string, unknown> | HttpHandler, handler?: HttpHandler): void;
+  prototype: any;
+}
+
+export const Server = function Server(
+  this: any,
+  optsOrHandler?: Record<string, unknown> | HttpHandler,
+  handler?: HttpHandler,
+) {
+  if (!this) return;
+  EventEmitter.call(this);
+
+  if (typeof optsOrHandler === "function") {
+    this._handler = optsOrHandler;
+  } else {
+    this._handler = handler;
+  }
+  this._tcp = new TcpServer();
+
+  this.listening = false;
+  this.maxHeadersCount = null;
+  this.timeout = 0;
+  this.keepAliveTimeout = TIMEOUTS.HTTP_KEEP_ALIVE;
+  this.headersTimeout = TIMEOUTS.HTTP_HEADERS;
+  this.requestTimeout = 0;
+  this.maxRequestsPerSocket = null;
+
+  const self = this;
+  this._tcp.on("listening", function onListening() {
+    self.listening = true;
+    self.emit("listening");
+  });
+  this._tcp.on("close", function onClose() {
+    self.listening = false;
+    self.emit("close");
+  });
+  this._tcp.on("error", function onError(e: unknown) { self.emit("error", e); });
+} as unknown as ServerConstructor;
+
+Object.setPrototypeOf(Server.prototype, EventEmitter.prototype);
+
+Server.prototype.listen = function listen(
+  portOrOpts?: number | { port?: number; host?: string },
+  hostOrCb?: string | (() => void),
+  cb?: () => void,
+): any {
+  let port: number | undefined;
+  let host: string | undefined;
+  let done: (() => void) | undefined;
+
+  if (typeof portOrOpts === "number") {
+    port = portOrOpts;
+    if (typeof hostOrCb === "string") {
+      host = hostOrCb;
+      done = cb;
+    } else done = hostOrCb;
+  } else if (portOrOpts) {
+    port = portOrOpts.port;
+    host = portOrOpts.host;
+    done = typeof hostOrCb === "function" ? hostOrCb : cb;
+  }
+
+  const self = this;
+  const origDone = done;
+  done = function onBound() {
+    const addr = self._tcp.address();
+    if (addr) _addServer(addr.port, self);
+    if (origDone) origDone();
+  };
+
+  this._tcp.listen(port, host, done);
+  return this;
+};
+
+Server.prototype.close = function close(cb?: (err?: Error) => void): any {
+  const addr = this._tcp.address();
+  if (addr) _removeServer(addr.port);
+  this._tcp.close(cb);
+  return this;
+};
+
+Server.prototype.address = function address(): NetAddress | null {
+  return this._tcp.address();
+};
+
+Server.prototype.setTimeout = function setTimeout(ms?: number, handler?: () => void): any {
+  this.timeout = ms || 0;
+  if (handler) this.on("timeout", handler);
+  return this;
+};
+
+Server.prototype.ref = function ref(): any {
+  this._tcp.ref();
+  return this;
+};
+
+Server.prototype.unref = function unref(): any {
+  this._tcp.unref();
+  return this;
+};
+
+Server.prototype.closeAllConnections = function closeAllConnections(): void {
+  // No-op
+};
+
+Server.prototype.closeIdleConnections = function closeIdleConnections(): void {
+  // No-op
+};
+
+Server.prototype.dispatchUpgrade = function dispatchUpgrade(
+  target: string,
+  hdrs: Record<string, string>,
+): { req: IncomingMessage; socket: TcpSocket } {
+  const socket = new TcpSocket();
+  (socket as any).cork = () => {};
+  (socket as any).uncork = () => {};
+  (socket as any)._readableState = { endEmitted: false };
+  (socket as any)._writableState = { finished: false, errorEmitted: false };
+
+  const req = new IncomingMessage(socket);
+  req.method = "GET";
+  req.url = target;
+  req.headers = {
+    ...hdrs,
+    upgrade: "websocket",
+    connection: "Upgrade",
+  };
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (typeof v === "string") req.rawHeaders.push(k, v);
+  }
+  req.push(null);
+  req.complete = true;
+
+  const self = this;
+  queueMicrotask(() => {
+    self.emit("upgrade", req, socket, Buffer.alloc(0));
+  });
+
+  return { req, socket };
+};
+
+Server.prototype.dispatchRequest = async function dispatchRequest(
+  verb: string,
+  target: string,
+  hdrs: Record<string, string>,
+  payload?: Buffer | string,
+): Promise<CompletedResponse> {
+  const self = this;
+  return new Promise((resolve, reject) => {
+    const req = IncomingMessage.build(verb, target, hdrs, payload);
+    const res = new ServerResponse(req);
+    res._onComplete(resolve);
+
+    const timeoutMs = self.timeout || TIMEOUTS.HTTP_DISPATCH_SAFETY;
+    const timer = setTimeout(() => {
+      reject(
+        new Error(
+          `dispatchRequest timed out after ${timeoutMs}ms for ${verb} ${target}`,
+        ),
+      );
+    }, timeoutMs);
+
+    res.on("finish", () => {
+      clearTimeout(timer);
+    });
+
+    try {
+      self.emit("request", req, res);
+      if (typeof self._handler === "function") {
+        const result = self._handler(req, res);
+        if (result && typeof (result as any).then === "function") {
+          (result as Promise<unknown>).catch((err) => {
+            clearTimeout(timer);
+            console.error("[DEBUG] dispatchRequest async error:", (err as Error)?.message || err, (err as Error)?.stack?.split("\n").slice(0, 5).join("\n"));
+            if (!res.headersSent) {
+              try {
+                res.statusCode = 500;
+                res.end("Internal Server Error");
+              } catch { /* ignore */ }
+            } else {
+              try { res.end(); } catch { /* ignore */ }
+            }
+          });
+        }
+      }
+    } catch (err) {
+      clearTimeout(timer);
+      console.error("[DEBUG] dispatchRequest sync error:", (err as Error)?.message || err, (err as Error)?.stack?.split("\n").slice(0, 5).join("\n"));
+      if (!res.headersSent) {
+        try {
+          res.statusCode = 500;
+          res.end("Internal Server Error");
+        } catch { /* ignore */ }
+      }
+      reject(err);
+    }
+  });
+};
+
+// createServer
+
+export function createServer(
+  optsOrHandler?: Record<string, unknown> | HttpHandler,
+  handler?: HttpHandler,
+): Server {
+  return new Server(optsOrHandler, handler);
+}
+
+// STATUS_CODES & METHODS
+
+export const STATUS_CODES: Record<number, string> = {
+  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",
+  409: "Conflict",
+  410: "Gone",
+  413: "Payload Too Large",
+  415: "Unsupported Media Type",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+};
+
+export const METHODS = [
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE",
+  "PATCH",
+  "HEAD",
+  "OPTIONS",
+  "CONNECT",
+  "TRACE",
+];
+
+// CORS proxy helper
+
+function fetchProxy(): string | null {
+  try {
+    return typeof localStorage !== "undefined"
+      ? (localStorage.getItem("__corsProxyUrl") ?? null)
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+// ClientRequest  (fetch-backed)
+
+export interface ClientRequest extends Writable {
+  method: string;
+  path: string;
+  headers: Record<string, string>;
+  finished: boolean;
+  aborted: boolean;
+  reusedSocket: boolean;
+  maxHeadersCount: number | null;
+  readonly socket: TcpSocket;
+  readonly connection: TcpSocket;
+  setHeader(k: string, v: string): void;
+  getHeader(k: string): string | undefined;
+  removeHeader(k: string): void;
+  write(chunk: any, encOrCb?: any, cb?: any): boolean;
+  end(dataOrCb?: any, encOrCb?: any, cb?: any): this;
+  abort(): void;
+  setTimeout(ms: number, handler?: () => void): this;
+  flushHeaders(): void;
+  setNoDelay(noDelay?: boolean): void;
+  setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+}
+
+export interface ClientRequestConstructor {
+  new (opts: ConnectionOptions, proto?: "http" | "https"): ClientRequest;
+  (this: any, opts: ConnectionOptions, proto?: "http" | "https"): void;
+  prototype: any;
+}
+
+export const ClientRequest = function ClientRequest(
+  this: any,
+  opts: ConnectionOptions,
+  proto?: "http" | "https",
+) {
+  if (!this) return;
+  Writable.call(this);
+
+  this._opts = opts;
+  this._proto = proto || "http";
+  this.method = opts.method ?? "GET";
+  this.path = opts.path ?? "/";
+  this.headers = {};
+  this._pending = [];
+  this._cancelled = false;
+  this._waitMs = null;
+  this._waitTimer = null;
+  this._sealed = false;
+  this._socket = new TcpSocket();
+  this.finished = false;
+  this.aborted = false;
+  this.reusedSocket = false;
+  this.maxHeadersCount = null;
+
+  if (opts.headers) {
+    for (const [k, v] of Object.entries(opts.headers)) {
+      this.headers[k.toLowerCase()] = Array.isArray(v) ? v.join(", ") : v;
+    }
+  }
+  // Emit socket event async
+  const self = this;
+  queueMicrotask(() => self.emit("socket", self._socket));
+} as unknown as ClientRequestConstructor;
+
+Object.setPrototypeOf(ClientRequest.prototype, Writable.prototype);
+
+// Getters for socket/connection
+Object.defineProperty(ClientRequest.prototype, "socket", {
+  get: function (this: any) { return this._socket; },
+  configurable: true,
+});
+
+Object.defineProperty(ClientRequest.prototype, "connection", {
+  get: function (this: any) { return this._socket; },
+  configurable: true,
+});
+
+ClientRequest.prototype.setHeader = function setHeader(k: string, v: string): void {
+  this.headers[k.toLowerCase()] = v;
+};
+
+ClientRequest.prototype.getHeader = function getHeader(k: string): string | undefined {
+  return this.headers[k.toLowerCase()];
+};
+
+ClientRequest.prototype.removeHeader = function removeHeader(k: string): void {
+  delete this.headers[k.toLowerCase()];
+};
+
+ClientRequest.prototype.write = function write(
+  chunk: Uint8Array | string,
+  encOrCb?: BufferEncoding | ((err?: Error | null) => void),
+  cb?: (err?: Error | null) => void,
+): boolean {
+  const buf = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+  this._pending.push(buf);
+  const fn = typeof encOrCb === "function" ? encOrCb : cb;
+  if (fn) queueMicrotask(() => fn(null));
+  return true;
+};
+
+ClientRequest.prototype.end = function end(
+  dataOrCb?: Uint8Array | string | (() => void),
+  encOrCb?: BufferEncoding | (() => void),
+  cb?: () => void,
+): any {
+  if (this._sealed) return this;
+  this._sealed = true;
+  this.finished = true;
+
+  let finalCb = cb;
+  if (typeof dataOrCb === "function") {
+    finalCb = dataOrCb;
+  } else if (dataOrCb !== undefined) {
+    this.write(dataOrCb as Uint8Array | string);
+  }
+  if (typeof encOrCb === "function") finalCb = encOrCb;
+
+  const self = this;
+  self._dispatch()
+    .then(() => {
+      if (finalCb) finalCb();
+    })
+    .catch((err: Error) => self.emit("error", err));
+
+  return this;
+};
+
+ClientRequest.prototype.abort = function abort(): void {
+  this._cancelled = true;
+  this.aborted = true;
+  if (this._waitTimer) clearTimeout(this._waitTimer);
+  this.emit("abort");
+};
+
+ClientRequest.prototype.setTimeout = function setTimeout(ms: number, handler?: () => void): any {
+  this._waitMs = ms;
+  if (handler) this.once("timeout", handler);
+  return this;
+};
+
+ClientRequest.prototype.flushHeaders = function flushHeaders(): void {
+  // No-op
+};
+
+ClientRequest.prototype.setNoDelay = function setNoDelay(_noDelay?: boolean): void {
+  // No-op
+};
+
+ClientRequest.prototype.setSocketKeepAlive = function setSocketKeepAlive(
+  _enable?: boolean,
+  _initialDelay?: number,
+): void {
+  // No-op
+};
+
+/* ---------- ClientRequest internal dispatch ---------- */
+
+ClientRequest.prototype._dispatch = async function _dispatch(): Promise<void> {
+  if (this._cancelled) return;
+
+  try {
+    const scheme = this._proto === "https" ? "https:" : "http:";
+    let hostname = this._opts.hostname ?? "";
+    let portSuffix = this._opts.port ? `:${this._opts.port}` : "";
+    if (!hostname && this._opts.host) {
+      const parts = this._opts.host.split(":");
+      hostname = parts[0];
+      if (!portSuffix && parts[1]) portSuffix = `:${parts[1]}`;
+    }
+    if (!hostname) hostname = "localhost";
+    const endpoint = `${scheme}//${hostname}${portSuffix}${this._opts.path ?? "/"}`;
+
+    // WebSocket upgrade -- delegate to native browser WS
+    if (this.headers["upgrade"]?.toLowerCase() === "websocket") {
+      this._bridgeWebSocket(endpoint);
+      return;
+    }
+
+    // Route requests to virtual servers through the registry instead of fetch
+    const isLocal = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "0.0.0.0";
+    const port = Number(this._opts.port) || (this._proto === "https" ? 443 : 80);
+    if (isLocal) {
+      const vServer = _registry.get(port);
+      if (vServer) {
+        const body = this._pending.length > 0 ? Buffer.concat(this._pending) : undefined;
+        try {
+          const result = await vServer.dispatchRequest(
+            this.method,
+            this._opts.path ?? "/",
+            this.headers,
+            body,
+          );
+          if (this._cancelled) return;
+          const incoming = new IncomingMessage();
+          incoming.statusCode = result.statusCode;
+          incoming.statusMessage = result.statusMessage;
+          for (const [k, v] of Object.entries(result.headers)) {
+            incoming.headers[k.toLowerCase()] = v;
+            incoming.rawHeaders.push(k, v);
+          }
+          incoming._injectBody(result.body);
+          this.emit("response", incoming);
+        } catch (err) {
+          this.emit("error", err);
+        }
+        return;
+      }
+      // No virtual server on this port — emit ECONNREFUSED
+      const err = new Error(`connect ECONNREFUSED ${hostname}:${port}`) as NodeJS.ErrnoException;
+      err.code = "ECONNREFUSED";
+      err.errno = -111;
+      (err as any).syscall = "connect";
+      (err as any).address = hostname;
+      (err as any).port = port;
+      this.emit("error", err);
+      return;
+    }
+
+    const proxy = fetchProxy();
+    const targetUrl = proxy ? proxy + encodeURIComponent(endpoint) : endpoint;
+
+    const init: RequestInit = { method: this.method, headers: this.headers };
+    if (
+      this._pending.length > 0 &&
+      this.method !== "GET" &&
+      this.method !== "HEAD"
+    ) {
+      init.body = Buffer.concat(this._pending);
+    }
+
+    const ac = new AbortController();
+    init.signal = ac.signal;
+
+    if (this._waitMs) {
+      this._waitTimer = setTimeout(() => {
+        ac.abort();
+        this.emit("timeout");
+      }, this._waitMs);
+    }
+
+    const resp = await fetch(targetUrl, init);
+    if (this._waitTimer) {
+      clearTimeout(this._waitTimer);
+      this._waitTimer = null;
+    }
+    if (this._cancelled) return;
+
+    const incoming = await this._mapResponse(resp);
+    this.emit("response", incoming);
+  } catch (err) {
+    if (this._waitTimer) clearTimeout(this._waitTimer);
+    if (this._cancelled) return;
+    if (err instanceof Error && err.name === "AbortError") return;
+    this.emit("error", err);
+  }
+};
+
+ClientRequest.prototype._mapResponse = async function _mapResponse(resp: Response): Promise<IncomingMessage> {
+  const msg = new IncomingMessage();
+  msg.statusCode = resp.status;
+  msg.statusMessage = resp.statusText || STATUS_CODES[resp.status] || "";
+  resp.headers.forEach((v: string, k: string) => {
+    msg.headers[k.toLowerCase()] = v;
+    msg.rawHeaders.push(k, v);
+  });
+  const raw = await resp.arrayBuffer();
+  msg._injectBody(Buffer.from(raw));
+  return msg;
+};
+
+/* ---------- WebSocket upgrade bridge ---------- */
+
+ClientRequest.prototype._bridgeWebSocket = function _bridgeWebSocket(url: string): void {
+  const wsUrl = url.replace(/^https:/, "wss:").replace(/^http:/, "ws:");
+  const wsKey = this.headers["sec-websocket-key"] ?? "";
+  const WS = _NativeWebSocket;
+
+  if (!WS) {
+    const self = this;
+    setTimeout(
+      () => self.emit("error", new TypeError("No WebSocket available")),
+      0,
+    );
+    return;
+  }
+
+  const WS_GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+  const acceptDigest = createHash("sha1")
+    .update(wsKey + WS_GUID)
+    .digest("base64") as string;
+
+  let ws: globalThis.WebSocket;
+  try {
+    ws = new WS(wsUrl);
+    ws.binaryType = "arraybuffer";
+  } catch (e) {
+    const self = this;
+    setTimeout(
+      () => self.emit("error", e instanceof Error ? e : new Error(String(e))),
+      0,
+    );
+    return;
+  }
+
+  const pipe = new TcpSocket();
+  (pipe as any).cork = () => {};
+  (pipe as any).uncork = () => {};
+  (pipe as any)._readableState = { endEmitted: false };
+  (pipe as any)._writableState = { finished: false, errorEmitted: false };
+
+  let outboundBuf = new Uint8Array(0);
+
+  pipe.write = ((
+    chunk: Uint8Array | string,
+    encOrCb?: BufferEncoding | ((err?: Error | null) => void),
+    cb?: (err?: Error | null) => void,
+  ): boolean => {
+    const raw =
+      typeof chunk === "string" ? Buffer.from(chunk) : new Uint8Array(chunk);
+    const fn = typeof encOrCb === "function" ? encOrCb : cb;
+
+    const merged = new Uint8Array(outboundBuf.length + raw.length);
+    merged.set(outboundBuf, 0);
+    merged.set(raw, outboundBuf.length);
+    outboundBuf = merged;
+
+    while (outboundBuf.length >= 2) {
+      const frame = decodeFrame(outboundBuf);
+      if (!frame) break;
+      outboundBuf = outboundBuf.slice(frame.consumed);
+
+      if (ws.readyState !== WS.OPEN) continue;
+
+      switch (frame.op) {
+        case 0x08:
+          ws.close();
+          break;
+        case 0x09:
+          ws.send(frame.data);
+          break;
+        case 0x0a:
+          break; // pong -- ignore
+        case 0x01:
+          ws.send(new TextDecoder().decode(frame.data));
+          break;
+        case 0x02:
+          ws.send(frame.data);
+          break;
+      }
+    }
+
+    if (fn) queueMicrotask(() => fn(null));
+    return true;
+  }) as any;
+
+  const self = this;
+
+  ws.onopen = () => {
+    const fakeResp = new IncomingMessage(pipe);
+    fakeResp.statusCode = 101;
+    fakeResp.statusMessage = "Switching Protocols";
+    fakeResp.headers = {
+      upgrade: "websocket",
+      connection: "Upgrade",
+      "sec-websocket-accept": acceptDigest,
+    };
+    fakeResp.complete = true;
+    fakeResp.push(null);
+    self.emit("upgrade", fakeResp, pipe, Buffer.alloc(0));
+  };
+
+  ws.onmessage = (ev: MessageEvent) => {
+    let payload: Uint8Array;
+    let op: number;
+    if (typeof ev.data === "string") {
+      payload = new TextEncoder().encode(ev.data);
+      op = 0x01;
+    } else if (ev.data instanceof ArrayBuffer) {
+      payload = new Uint8Array(ev.data);
+      op = 0x02;
+    } else {
+      return;
+    }
+    const frame = encodeFrame(op, payload, false);
+    pipe._feedData(Buffer.from(frame));
+  };
+
+  ws.onclose = (ev: CloseEvent) => {
+    const code = ev.code || 1000;
+    const closeBuf = new Uint8Array(2);
+    closeBuf[0] = (code >> 8) & 0xff;
+    closeBuf[1] = code & 0xff;
+    const frame = encodeFrame(0x08, closeBuf, false);
+    pipe._feedData(Buffer.from(frame));
+    setTimeout(() => {
+      (pipe as any)._readableState.endEmitted = true;
+      pipe._feedEnd();
+      pipe.emit("close", false);
+    }, 10);
+  };
+
+  ws.onerror = () => {
+    pipe.emit("error", new Error("WebSocket transport error"));
+    pipe.destroy();
+  };
+
+  const origDestroy = pipe.destroy.bind(pipe);
+  pipe.destroy = ((e?: Error): TcpSocket => {
+    if (ws.readyState === WS.OPEN || ws.readyState === WS.CONNECTING)
+      ws.close();
+    return origDestroy(e);
+  }) as any;
+};
+
+// Argument parsing helper
+
+function dissectArgs(
+  first: string | URL | ConnectionOptions,
+  second?: ConnectionOptions | ((r: IncomingMessage) => void),
+  third?: (r: IncomingMessage) => void,
+): { opts: ConnectionOptions; cb?: (r: IncomingMessage) => void } {
+  let opts: ConnectionOptions;
+  let cb = third;
+
+  if (typeof first === "string" || first instanceof URL) {
+    const parsed = new URL(first.toString());
+    opts = {
+      hostname: parsed.hostname,
+      port: parsed.port ? parseInt(parsed.port, 10) : undefined,
+      path: parsed.pathname + parsed.search,
+      method: "GET",
+    };
+    if (typeof second === "function") cb = second;
+    else if (second) opts = { ...opts, ...second };
+  } else {
+    opts = first;
+    if (typeof second === "function") cb = second;
+  }
+
+  return { opts, cb };
+}
+
+// request / get
+
+export function request(
+  first: string | URL | ConnectionOptions,
+  second?: ConnectionOptions | ((r: IncomingMessage) => void),
+  third?: (r: IncomingMessage) => void,
+): ClientRequest {
+  const { opts, cb } = dissectArgs(first, second, third);
+  const cr = new ClientRequest(opts, "http");
+  if (cb) cr.once("response", cb as unknown as EventHandler);
+  return cr;
+}
+
+export function get(
+  first: string | URL | ConnectionOptions,
+  second?: ConnectionOptions | ((r: IncomingMessage) => void),
+  third?: (r: IncomingMessage) => void,
+): ClientRequest {
+  const { opts, cb } = dissectArgs(first, second, third);
+  const cr = new ClientRequest({ ...opts, method: "GET" }, "http");
+  if (cb) cr.once("response", cb as unknown as EventHandler);
+  cr.end();
+  return cr;
+}
+
+export function _buildClientRequest(
+  first: string | URL | ConnectionOptions,
+  second: ConnectionOptions | ((r: IncomingMessage) => void) | undefined,
+  third: ((r: IncomingMessage) => void) | undefined,
+  proto: "http" | "https",
+): ClientRequest {
+  const { opts, cb } = dissectArgs(first, second, third);
+  const cr = new ClientRequest(opts, proto);
+  if (cb) cr.once("response", cb as unknown as EventHandler);
+  return cr;
+}
+
+// Server registry (global, for server bridge routing)
+
+export type RegistryHook = (port: number, srv: Server) => void;
+
+const _registry = new Map<number, Server>();
+const _serverOwnership = new Map<number, number>(); // port → pid
+let _onBind: RegistryHook | null = null;
+let _onUnbind: ((port: number) => void) | null = null;
+
+function _addServer(port: number, srv: Server, ownerPid?: number): void {
+  _registry.set(port, srv);
+  if (ownerPid !== undefined) _serverOwnership.set(port, ownerPid);
+  _elRef(); // server keeps the process alive
+  if (_onBind) _onBind(port, srv);
+}
+
+function _removeServer(port: number): void {
+  if (_registry.has(port)) _elUnref(); // server no longer keeps process alive
+  _registry.delete(port);
+  _serverOwnership.delete(port);
+  if (_onUnbind) _onUnbind(port);
+}
+
+export function getServer(port: number): Server | undefined {
+  return _registry.get(port);
+}
+
+export function getAllServers(): Map<number, Server> {
+  return new Map(_registry);
+}
+
+export function closeAllServers(): void {
+  for (const [, srv] of _registry) {
+    try { srv.close(); } catch { /* best effort */ }
+  }
+  _registry.clear();
+  _serverOwnership.clear();
+}
+
+export function closeServersByPid(pid: number): void {
+  for (const [port, ownerPid] of _serverOwnership) {
+    if (ownerPid === pid) {
+      const srv = _registry.get(port);
+      if (srv) {
+        try { srv.close(); } catch { /* best effort */ }
+      }
+      _registry.delete(port);
+      _serverOwnership.delete(port);
+    }
+  }
+}
+
+export function getServerOwner(port: number): number | undefined {
+  return _serverOwnership.get(port);
+}
+
+export function setServerListenCallback(fn: RegistryHook | null): void {
+  _onBind = fn;
+}
+
+export function setServerCloseCallback(
+  fn: ((port: number) => void) | null,
+): void {
+  _onUnbind = fn;
+}
+
+// Agent
+
+export interface AgentConfig {
+  keepAlive?: boolean;
+  keepAliveMsecs?: number;
+  maxSockets?: number;
+  maxTotalSockets?: number;
+  maxFreeSockets?: number;
+  scheduling?: "fifo" | "lifo";
+  timeout?: number;
+}
+
+export interface Agent extends EventEmitter {
+  maxSockets: number;
+  maxFreeSockets: number;
+  maxTotalSockets: number;
+  sockets: Record<string, TcpSocket[]>;
+  freeSockets: Record<string, TcpSocket[]>;
+  requests: Record<string, IncomingMessage[]>;
+  options: AgentConfig;
+  createConnection(cfg: Record<string, unknown>, done?: (err: Error | null, sock: TcpSocket) => void): TcpSocket;
+  getName(o: { host?: string; port?: number; localAddress?: string }): string;
+  addRequest(r: ClientRequest, o: Record<string, unknown>): void;
+  destroy(): void;
+}
+
+export interface AgentConstructor {
+  new (cfg?: AgentConfig): Agent;
+  (this: any, cfg?: AgentConfig): void;
+  prototype: any;
+}
+
+export const Agent = function Agent(this: any, cfg?: AgentConfig) {
+  if (!this) return;
+  EventEmitter.call(this);
+
+  this.options = cfg ?? {};
+  this.maxSockets = cfg?.maxSockets ?? Infinity;
+  this.maxFreeSockets = cfg?.maxFreeSockets ?? 256;
+  this.maxTotalSockets = cfg?.maxTotalSockets ?? Infinity;
+  this.sockets = {};
+  this.freeSockets = {};
+  this.requests = {};
+} as unknown as AgentConstructor;
+
+Object.setPrototypeOf(Agent.prototype, EventEmitter.prototype);
+
+Agent.prototype.createConnection = function createConnection(
+  _cfg: Record<string, unknown>,
+  done?: (err: Error | null, sock: TcpSocket) => void,
+): TcpSocket {
+  const sock = new TcpSocket();
+  if (done) done(null, sock);
+  return sock;
+};
+
+Agent.prototype.getName = function getName(
+  o: { host?: string; port?: number; localAddress?: string },
+): string {
+  return `${o.host ?? "localhost"}:${o.port ?? 80}:${o.localAddress ?? ""}`;
+};
+
+Agent.prototype.addRequest = function addRequest(
+  _r: ClientRequest,
+  _o: Record<string, unknown>,
+): void {};
+
+Agent.prototype.destroy = function destroy(): void {
+  this.sockets = {};
+  this.freeSockets = {};
+  this.requests = {};
+};
+
+export const globalAgent = new Agent();
+
+// WebSocket frame codec
+
+export function decodeFrame(raw: Uint8Array): {
+  op: number;
+  data: Uint8Array;
+  consumed: number;
+} | null {
+  if (raw.length < 2) return null;
+
+  const op = raw[0] & 0x0f;
+  const isMasked = (raw[1] & 0x80) !== 0;
+  let len = raw[1] & 0x7f;
+  let cursor = 2;
+
+  if (len === 126) {
+    if (raw.length < 4) return null;
+    len = (raw[2] << 8) | raw[3];
+    cursor = 4;
+  } else if (len === 127) {
+    if (raw.length < 10) return null;
+    len = (raw[6] << 24) | (raw[7] << 16) | (raw[8] << 8) | raw[9];
+    cursor = 10;
+  }
+
+  if (isMasked) {
+    if (raw.length < cursor + 4 + len) return null;
+    const mask = raw.slice(cursor, cursor + 4);
+    cursor += 4;
+    const payload = new Uint8Array(len);
+    for (let i = 0; i < len; i++) payload[i] = raw[cursor + i] ^ mask[i & 3];
+    return { op, data: payload, consumed: cursor + len };
+  }
+
+  if (raw.length < cursor + len) return null;
+  return { op, data: raw.slice(cursor, cursor + len), consumed: cursor + len };
+}
+
+export function encodeFrame(
+  op: number,
+  payload: Uint8Array,
+  masked: boolean,
+): Uint8Array {
+  const pLen = payload.length;
+  let headerLen = 2;
+  if (pLen > 125 && pLen <= 0xffff) headerLen += 2;
+  else if (pLen > 0xffff) headerLen += 8;
+  if (masked) headerLen += 4;
+
+  const frame = new Uint8Array(headerLen + pLen);
+  frame[0] = 0x80 | op;
+
+  let pos = 2;
+  if (pLen <= 125) {
+    frame[1] = (masked ? 0x80 : 0) | pLen;
+  } else if (pLen <= 0xffff) {
+    frame[1] = (masked ? 0x80 : 0) | 126;
+    frame[2] = (pLen >> 8) & 0xff;
+    frame[3] = pLen & 0xff;
+    pos = 4;
+  } else {
+    frame[1] = (masked ? 0x80 : 0) | 127;
+    frame[2] = 0;
+    frame[3] = 0;
+    frame[4] = 0;
+    frame[5] = 0;
+    frame[6] = (pLen >> 24) & 0xff;
+    frame[7] = (pLen >> 16) & 0xff;
+    frame[8] = (pLen >> 8) & 0xff;
+    frame[9] = pLen & 0xff;
+    pos = 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, pos);
+    pos += 4;
+    for (let i = 0; i < pLen; i++) frame[pos + i] = payload[i] ^ maskKey[i & 3];
+  } else {
+    frame.set(payload, pos);
+  }
+
+  return frame;
+}
+
+// Default export
+
+export default {
+  Server,
+  IncomingMessage,
+  ServerResponse,
+  ClientRequest,
+  createServer,
+  request,
+  get,
+  STATUS_CODES,
+  METHODS,
+  getServer,
+  getAllServers,
+  setServerListenCallback,
+  setServerCloseCallback,
+  _buildClientRequest,
+  Agent,
+  globalAgent,
+  decodeFrame,
+  encodeFrame,
+};