@gjsify/http 0.1.13 → 0.2.0

package/lib/esm/incoming-message.js

@@ -13,12 +13,19 @@ class IncomingMessage extends Readable {
   complete = false;
   socket = null;
   aborted = false;
+  /** Node.js legacy alias for socket — needed by engine.io and other HTTP consumers. */
+  get connection() {
+    return this.socket;
+  }
   _timeoutTimer = null;
   constructor() {
     super();
   }
   _read(_size) {
   }
+  // 'close' means connection lost, not body-stream end — don't auto-emit after 'end'.
+  _autoClose() {
+  }
   /** Finish the readable stream with the body data (used by server-side handler). */
   _pushBody(body) {
     if (body && body.length > 0) {

package/lib/esm/server-request-socket.js

@@ -0,0 +1,71 @@
+import { Duplex } from "node:stream";
+class ServerRequestSocket extends Duplex {
+  remoteAddress;
+  remotePort;
+  localAddress;
+  localPort;
+  remoteFamily = "IPv4";
+  encrypted;
+  connecting = false;
+  pending = false;
+  bytesRead = 0;
+  bytesWritten = 0;
+  // Bridge response we forward pause/resume to (via super.pause/resume
+  // for now; the bridge will grow explicit pause/unpause hooks later).
+  _bridgeRes;
+  _bridgePaused = false;
+  constructor(remoteAddress, remotePort, localAddress, localPort, bridgeRes, encrypted = false) {
+    super({ allowHalfOpen: true });
+    this.remoteAddress = remoteAddress;
+    this.remotePort = remotePort;
+    this.localAddress = localAddress;
+    this.localPort = localPort;
+    this.encrypted = encrypted;
+    this._bridgeRes = bridgeRes;
+  }
+  pause() {
+    if (this._bridgePaused) return this;
+    this._bridgePaused = true;
+    return super.pause();
+  }
+  resume() {
+    if (!this._bridgePaused) return super.resume();
+    this._bridgePaused = false;
+    return super.resume();
+  }
+  // The bridge owns the TCP connection — no data flows through this Duplex.
+  _read(_size) {
+  }
+  _write(_chunk, _encoding, cb) {
+    cb();
+  }
+  destroySoon() {
+    if (!this.writableEnded) this.end();
+    if (this.writableFinished)
+      this.destroy();
+    else
+      this.once("finish", () => this.destroy());
+  }
+  setTimeout(_timeout, cb) {
+    if (cb) this.once("timeout", cb);
+    return this;
+  }
+  setNoDelay(_noDelay) {
+    return this;
+  }
+  setKeepAlive(_enable, _delay) {
+    return this;
+  }
+  ref() {
+    return this;
+  }
+  unref() {
+    return this;
+  }
+  address() {
+    return { address: this.localAddress, family: "IPv4", port: this.localPort };
+  }
+}
+export {
+  ServerRequestSocket
+};

package/lib/esm/server.js

@@ -1,9 +1,12 @@
-import Soup from "@girs/soup-3.0";
 import { EventEmitter } from "node:events";
 import { Writable } from "node:stream";
 import { Buffer } from "node:buffer";
 import { Socket as NetSocket } from "@gjsify/net/socket";
-import { deferEmit, ensureMainLoop } from "@gjsify/utils";
+import {
+  Server as BridgeServer
+} from "@gjsify/http-soup-bridge";
+import { ServerRequestSocket } from "./server-request-socket.js";
+import { createNodeError, deferEmit, ensureMainLoop } from "@gjsify/utils";
 import { STATUS_CODES } from "./constants.js";
 import { IncomingMessage } from "./incoming-message.js";
 class OutgoingMessage extends Writable {
@@ -74,11 +77,14 @@ class ServerResponse extends OutgoingMessage {
   statusCode = 200;
   statusMessage = "";
   _streaming = false;
-  _soupMsg;
+  _bridge;
   _timeoutTimer = null;
-  constructor(soupMsg) {
+  constructor(bridge) {
     super();
-    this._soupMsg = soupMsg;
+    this._bridge = bridge;
+    bridge.connect("close", () => {
+      this.emit("close");
+    });
   }
   /** Set a timeout for the response. Emits 'timeout' if response not sent within msecs. */
   setTimeout(msecs, callback) {
@@ -131,8 +137,8 @@ class ServerResponse extends OutgoingMessage {
     }
   }
   /**
-   * Send status + headers to the client via Soup and switch to streaming (chunked) mode.
-   * Called on the first write() — subsequent writes append chunks and unpause.
+   * Push our header map to the bridge and call write_head() on first
+   * write. Idempotent.
    */
   _startStreaming() {
     if (this._streaming) return;
@@ -142,67 +148,37 @@ class ServerResponse extends OutgoingMessage {
       clearTimeout(this._timeoutTimer);
       this._timeoutTimer = null;
     }
-    this._soupMsg.set_status(this.statusCode, this.statusMessage || null);
-    const responseHeaders = this._soupMsg.get_response_headers();
-    responseHeaders.set_encoding(Soup.Encoding.CHUNKED);
-    if (!this._headers.has("connection")) {
-      responseHeaders.replace("Connection", "close");
-    }
     for (const [key, value] of this._headers) {
       if (Array.isArray(value)) {
-        for (const v of value) {
-          responseHeaders.append(key, v);
-        }
+        for (const v of value) this._bridge.append_header(key, v);
       } else {
-        responseHeaders.replace(key, value);
+        this._bridge.set_header(key, value);
       }
     }
+    this._bridge.write_head(this.statusCode, this.statusMessage || null);
   }
-  /** Writable stream _write — sends headers on first call, then appends + flushes each chunk. */
+  /** Writable stream _write — sends headers on first call, then appends each chunk. */
   _write(chunk, encoding, callback) {
     const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
     this._startStreaming();
-    const responseBody = this._soupMsg.get_response_body();
-    responseBody.append(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
-    this._soupMsg.unpause();
+    this._bridge.write_chunk(new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength));
     callback();
   }
-  /** Called by Writable.end() — completes the body (streaming) or sends batch response (no-body). */
+  /** Called by Writable.end() — finishes the bridge response. */
   _final(callback) {
-    if (this._streaming) {
-      const responseBody = this._soupMsg.get_response_body();
-      responseBody.complete();
-      this._soupMsg.unpause();
-    } else {
-      this._sendBatchResponse();
-    }
-    this.finished = true;
-    callback();
-  }
-  /** Batch response — sends status + headers + empty/no body in one shot (for responses without write()). */
-  _sendBatchResponse() {
-    if (this.headersSent) return;
-    this.headersSent = true;
-    if (this._timeoutTimer) {
-      clearTimeout(this._timeoutTimer);
-      this._timeoutTimer = null;
-    }
-    this._soupMsg.set_status(this.statusCode, this.statusMessage || null);
-    const responseHeaders = this._soupMsg.get_response_headers();
-    if (!this._headers.has("connection")) {
-      responseHeaders.replace("Connection", "close");
-    }
-    for (const [key, value] of this._headers) {
-      if (Array.isArray(value)) {
-        for (const v of value) {
-          responseHeaders.append(key, v);
+    if (!this._streaming) {
+      for (const [key, value] of this._headers) {
+        if (Array.isArray(value)) {
+          for (const v of value) this._bridge.append_header(key, v);
+        } else {
+          this._bridge.set_header(key, value);
         }
-      } else {
-        responseHeaders.replace(key, value);
       }
+      this._bridge.write_head(this.statusCode, this.statusMessage || null);
     }
-    const contentType = this._headers.get("content-type") || "text/plain";
-    this._soupMsg.set_response(contentType, Soup.MemoryUse.COPY, new Uint8Array(0));
+    this._bridge.end();
+    this.finished = true;
+    callback();
   }
   /** Write status + headers + body in one call (convenience). */
   end(chunk, encoding, callback) {
@@ -228,14 +204,18 @@ class Server extends EventEmitter {
   keepAliveTimeout = 5e3;
   headersTimeout = 6e4;
   requestTimeout = 3e5;
-  _soupServer = null;
+  _bridge = null;
   _address = null;
+  /** Exposes the underlying Soup.Server so consumers (e.g. WebSocketServer
+   *  in `@gjsify/ws`) can register additional handlers (websocket, path-
+   *  specific) on the same server instance without port-sharing conflicts. */
+  get soupServer() {
+    return this._bridge?.soup_server ?? null;
+  }
   constructor(optionsOrListener, requestListener) {
     super();
     const listener = typeof optionsOrListener === "function" ? optionsOrListener : requestListener;
-    if (listener) {
-      this.on("request", listener);
-    }
+    if (listener) this.on("request", listener);
   }
   listen(...args) {
     let port = 0;
@@ -248,110 +228,139 @@ class Server extends EventEmitter {
     }
     if (callback) this.once("listening", callback);
     try {
-      this._soupServer = new Soup.Server({});
-      this._soupServer.add_handler(null, (server, msg, path) => {
-        this._handleRequest(msg, path);
+      this._bridge = new BridgeServer();
+      this._bridge.connect("request-received", (_self, req, res) => {
+        this._handleRequest(req, res);
       });
-      this._soupServer.listen_local(port, Soup.ServerListenOptions.IPV4_ONLY);
+      this._bridge.connect("upgrade", (_self, req, iostream, _head) => {
+        this._handleUpgrade(req, iostream);
+      });
+      this._bridge.connect("error-occurred", (_self, msg) => {
+        this.emit("error", new Error(msg));
+      });
+      this._bridge.listen(port, hostname);
       ensureMainLoop();
-      const listeners = this._soupServer.get_listeners();
-      let actualPort = port;
-      if (listeners && listeners.length > 0) {
-        const addr = listeners[0].get_local_address();
-        if (addr && typeof addr.get_port === "function") {
-          actualPort = addr.get_port();
-        }
-      }
       this.listening = true;
-      this._address = { port: actualPort, family: "IPv4", address: hostname };
+      this._address = { port: this._bridge.port, family: "IPv4", address: this._bridge.address || hostname };
       _activeServers.add(this);
       deferEmit(this, "listening");
     } catch (err) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (this.listenerCount("error") === 0) {
-        throw error;
-      }
-      deferEmit(this, "error", error);
+      const nodeErr = createNodeError(err, "listen", { address: hostname, port });
+      deferEmit(this, "error", nodeErr);
     }
     return this;
   }
-  _handleRequest(soupMsg, path) {
+  _handleRequest(bridgeReq, bridgeRes) {
     const req = new IncomingMessage();
-    const res = new ServerResponse(soupMsg);
-    req.method = soupMsg.get_method();
-    req.url = soupMsg.get_uri().get_path();
-    const query = soupMsg.get_uri().get_query();
-    if (query) req.url += "?" + query;
+    const res = new ServerResponse(bridgeRes);
+    req.method = bridgeReq.method;
+    req.url = bridgeReq.url;
     req.httpVersion = "1.1";
-    const requestHeaders = soupMsg.get_request_headers();
-    requestHeaders.foreach((name, value) => {
+    const pairs = bridgeReq.header_pairs ?? [];
+    for (let i = 0; i + 1 < pairs.length; i += 2) {
+      const name = pairs[i];
+      const value = pairs[i + 1];
       const lower = name.toLowerCase();
       req.rawHeaders.push(name, value);
       if (lower in req.headers) {
         const existing = req.headers[lower];
-        if (Array.isArray(existing)) {
-          existing.push(value);
-        } else {
-          req.headers[lower] = [existing, value];
-        }
+        if (Array.isArray(existing)) existing.push(value);
+        else req.headers[lower] = [existing, value];
       } else {
         req.headers[lower] = value;
       }
+    }
+    req.socket = new ServerRequestSocket(
+      bridgeReq.remote_address ?? "127.0.0.1",
+      bridgeReq.remote_port ?? 0,
+      this._address?.address ?? "127.0.0.1",
+      this._address?.port ?? 0,
+      bridgeRes
+    );
+    const body = bridgeReq.get_body();
+    if (body.length > 0) req._pushBody(body);
+    else req._pushBody(null);
+    bridgeReq.connect("aborted_signal", () => {
+      if (!req.aborted) {
+        req.aborted = true;
+        req.emit("aborted");
+      }
+    });
+    bridgeReq.connect("close", () => {
+      req.emit("close");
     });
-    const connectionHeader = (req.headers["connection"] || "").toLowerCase();
-    const upgradeHeader = (req.headers["upgrade"] || "").toLowerCase();
-    if (connectionHeader.includes("upgrade") && upgradeHeader && this.listenerCount("upgrade") > 0) {
-      let ioStream = null;
-      try {
-        ioStream = soupMsg.steal_connection();
-      } catch (err) {
+    try {
+      const result = this.emit("request", req, res);
+      if (result instanceof Promise || result !== null && typeof result === "object" && typeof result.then === "function") {
+        result.catch((err) => {
+          console.error("[HTTP] Unhandled error in async request handler:", err);
+          if (!res.headersSent) {
+            try {
+              res.writeHead(500);
+              res.end("Internal Server Error");
+            } catch {
+            }
+          }
+        });
       }
-      if (ioStream) {
-        const socket = new NetSocket();
-        socket._setupFromIOStream(ioStream);
-        this.emit("upgrade", req, socket, Buffer.alloc(0));
-        return;
+    } catch (err) {
+      console.error("[HTTP] Unhandled error in request handler:", err);
+      if (!res.headersSent) {
+        try {
+          res.writeHead(500);
+          res.end("Internal Server Error");
+        } catch {
+        }
       }
     }
-    const body = soupMsg.get_request_body();
-    if (body && body.data && body.data.length > 0) {
-      req._pushBody(body.data);
-    } else {
-      req._pushBody(null);
+  }
+  _handleUpgrade(bridgeReq, iostream) {
+    const req = new IncomingMessage();
+    req.method = bridgeReq.method;
+    req.url = bridgeReq.url;
+    req.httpVersion = "1.1";
+    const pairs = bridgeReq.header_pairs ?? [];
+    for (let i = 0; i + 1 < pairs.length; i += 2) {
+      const name = pairs[i];
+      const value = pairs[i + 1];
+      const lower = name.toLowerCase();
+      req.rawHeaders.push(name, value);
+      req.headers[lower] = value;
+    }
+    if (this.listenerCount("upgrade") > 0) {
+      const socket = new NetSocket();
+      socket._attachOutputOnly(iostream);
+      this.emit("upgrade", req, socket, Buffer.alloc(0));
     }
-    soupMsg.pause();
-    res.on("finish", () => {
-      soupMsg.unpause();
-    });
-    this.emit("request", req, res);
   }
   address() {
     return this._address;
   }
   /**
    * Register a WebSocket handler on this server (GJS only).
-   * Delegates to Soup.Server.add_websocket_handler().
+   * Delegates to the underlying `Soup.Server.add_websocket_handler()`.
    * @param path URL path to handle WebSocket upgrades (e.g., '/ws')
    * @param callback Called for each new WebSocket connection with the Soup.WebsocketConnection
    */
   addWebSocketHandler(path, callback) {
-    if (!this._soupServer) {
+    if (!this._bridge) {
       throw new Error("Server must be listening before adding WebSocket handlers. Call listen() first.");
     }
-    this._soupServer.add_websocket_handler(
+    const soupServer = this._bridge.soup_server;
+    soupServer.add_websocket_handler(
       path,
       null,
       null,
-      (_srv, _msg, _path, connection) => {
+      (_srv, _msg, _p, connection) => {
         callback(connection);
       }
     );
   }
   close(callback) {
     if (callback) this.once("close", callback);
-    if (this._soupServer) {
-      this._soupServer.disconnect();
-      this._soupServer = null;
+    if (this._bridge) {
+      this._bridge.close();
+      this._bridge = null;
     }
     this.listening = false;
     _activeServers.delete(this);

package/lib/types/incoming-message.d.ts

@@ -15,9 +15,12 @@ export declare class IncomingMessage extends Readable {
     complete: boolean;
     socket: any;
     aborted: boolean;
+    /** Node.js legacy alias for socket — needed by engine.io and other HTTP consumers. */
+    get connection(): any;
     private _timeoutTimer;
     constructor();
     _read(_size: number): void;
+    protected _autoClose(): void;
     /** Finish the readable stream with the body data (used by server-side handler). */
     _pushBody(body: Uint8Array | null): void;
     setTimeout(msecs: number, callback?: () => void): this;

package/lib/types/listen-error.spec.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => Promise<void>;
+export default _default;

package/lib/types/server-request-socket.d.ts

@@ -0,0 +1,32 @@
+import { Duplex } from 'node:stream';
+import type { Response as BridgeResponse } from '@gjsify/http-soup-bridge';
+export declare class ServerRequestSocket extends Duplex {
+    readonly remoteAddress: string;
+    readonly remotePort: number;
+    readonly localAddress: string;
+    readonly localPort: number;
+    readonly remoteFamily = "IPv4";
+    readonly encrypted: boolean;
+    readonly connecting = false;
+    readonly pending = false;
+    bytesRead: number;
+    bytesWritten: number;
+    private readonly _bridgeRes;
+    private _bridgePaused;
+    constructor(remoteAddress: string, remotePort: number, localAddress: string, localPort: number, bridgeRes: BridgeResponse, encrypted?: boolean);
+    pause(): this;
+    resume(): this;
+    _read(_size: number): void;
+    _write(_chunk: unknown, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void;
+    destroySoon(): void;
+    setTimeout(_timeout: number, cb?: () => void): this;
+    setNoDelay(_noDelay?: boolean): this;
+    setKeepAlive(_enable?: boolean, _delay?: number): this;
+    ref(): this;
+    unref(): this;
+    address(): {
+        address: string;
+        family: string;
+        port: number;
+    };
+}

package/lib/types/server.d.ts

@@ -1,6 +1,6 @@
-import Soup from '@girs/soup-3.0';
 import { EventEmitter } from 'node:events';
 import { Writable } from 'node:stream';
+import { type Response as BridgeResponse } from '@gjsify/http-soup-bridge';
 import { IncomingMessage } from './incoming-message.js';
 /**
  * OutgoingMessage — Base class for ServerResponse and ClientRequest.
@@ -32,15 +32,18 @@ export declare class OutgoingMessage extends Writable {
 }
 /**
  * ServerResponse — Writable stream representing an HTTP response.
- * Extends OutgoingMessage for shared header management.
+ *
+ * Holds a `BridgeResponse` from `@gjsify/http-soup-bridge`. All header /
+ * status / body operations delegate to the bridge, which handles the
+ * underlying Soup.ServerMessage in C-space (no JS-visible boxed types).
  */
 export declare class ServerResponse extends OutgoingMessage {
     statusCode: number;
     statusMessage: string;
     private _streaming;
-    private _soupMsg;
+    private _bridge;
     private _timeoutTimer;
-    constructor(soupMsg: Soup.ServerMessage);
+    constructor(bridge: BridgeResponse);
     /** Set a timeout for the response. Emits 'timeout' if response not sent within msecs. */
     setTimeout(msecs: number, callback?: () => void): this;
     /** Write the status line and headers. */
@@ -54,21 +57,24 @@ export declare class ServerResponse extends OutgoingMessage {
     /** Add trailing headers for chunked transfer encoding. */
     addTrailers(headers: Record<string, string>): void;
     /**
-     * Send status + headers to the client via Soup and switch to streaming (chunked) mode.
-     * Called on the first write() — subsequent writes append chunks and unpause.
+     * Push our header map to the bridge and call write_head() on first
+     * write. Idempotent.
      */
     private _startStreaming;
-    /** Writable stream _write — sends headers on first call, then appends + flushes each chunk. */
+    /** Writable stream _write — sends headers on first call, then appends each chunk. */
     _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
-    /** Called by Writable.end() — completes the body (streaming) or sends batch response (no-body). */
+    /** Called by Writable.end() — finishes the bridge response. */
     _final(callback: (error?: Error | null) => void): void;
-    /** Batch response — sends status + headers + empty/no body in one shot (for responses without write()). */
-    private _sendBatchResponse;
     /** Write status + headers + body in one call (convenience). */
     end(chunk?: unknown, encoding?: BufferEncoding | (() => void), callback?: () => void): this;
 }
 /**
- * HTTP Server wrapping Soup.Server.
+ * HTTP Server — wraps a `@gjsify/http-soup-bridge` Server.
+ *
+ * Public API matches Node.js `http.Server`. Internal differences from the
+ * pre-bridge version are invisible to consumers (Hono / Express / MCP /
+ * engine.io / `@gjsify/ws`) — they continue to use `.on('request', …)`,
+ * `.on('upgrade', …)`, `.listen()`, `.close()`, `.address()`, etc.
  */
 export declare class Server extends EventEmitter {
     listening: boolean;
@@ -77,14 +83,19 @@ export declare class Server extends EventEmitter {
     keepAliveTimeout: number;
     headersTimeout: number;
     requestTimeout: number;
-    private _soupServer;
+    private _bridge;
     private _address;
+    /** Exposes the underlying Soup.Server so consumers (e.g. WebSocketServer
+     *  in `@gjsify/ws`) can register additional handlers (websocket, path-
+     *  specific) on the same server instance without port-sharing conflicts. */
+    get soupServer(): unknown;
     constructor(requestListener?: ((req: IncomingMessage, res: ServerResponse) => void) | Record<string, unknown>);
     constructor(options: Record<string, unknown>, requestListener?: (req: IncomingMessage, res: ServerResponse) => void);
     listen(port?: number, hostname?: string, backlog?: number, callback?: () => void): this;
     listen(port?: number, hostname?: string, callback?: () => void): this;
     listen(port?: number, callback?: () => void): this;
     private _handleRequest;
+    private _handleUpgrade;
     address(): {
         port: number;
         family: string;
@@ -92,7 +103,7 @@ export declare class Server extends EventEmitter {
     } | null;
     /**
      * Register a WebSocket handler on this server (GJS only).
-     * Delegates to Soup.Server.add_websocket_handler().
+     * Delegates to the underlying `Soup.Server.add_websocket_handler()`.
      * @param path URL path to handle WebSocket upgrades (e.g., '/ws')
      * @param callback Called for each new WebSocket connection with the Soup.WebsocketConnection
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/http",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "description": "Node.js http module for Gjs",
   "module": "lib/esm/index.js",
   "types": "lib/types/index.d.ts",
@@ -21,7 +21,7 @@
     "build:test:gjs": "gjsify build src/test.mts --app gjs --outfile test.gjs.mjs",
     "build:test:node": "gjsify build src/test.mts --app node --outfile test.node.mjs",
     "test": "yarn build:gjsify && yarn build:test && yarn test:node && yarn test:gjs",
-    "test:gjs": "gjs -m test.gjs.mjs",
+    "test:gjs": "gjsify run test.gjs.mjs",
     "test:node": "node test.node.mjs"
   },
   "keywords": [
@@ -30,20 +30,21 @@
     "http"
   ],
   "devDependencies": {
-    "@gjsify/cli": "^0.1.13",
-    "@gjsify/unit": "^0.1.13",
+    "@gjsify/cli": "^0.2.0",
+    "@gjsify/unit": "^0.2.0",
     "@types/node": "^25.6.0",
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@girs/gio-2.0": "^2.88.0-4.0.0-rc.3",
-    "@girs/glib-2.0": "^2.88.0-4.0.0-rc.3",
-    "@girs/soup-3.0": "^3.6.6-4.0.0-rc.3",
-    "@gjsify/buffer": "^0.1.13",
-    "@gjsify/events": "^0.1.13",
-    "@gjsify/net": "^0.1.13",
-    "@gjsify/stream": "^0.1.13",
-    "@gjsify/url": "^0.1.13",
-    "@gjsify/utils": "^0.1.13"
+    "@girs/gio-2.0": "^2.88.0-4.0.0-rc.9",
+    "@girs/glib-2.0": "^2.88.0-4.0.0-rc.9",
+    "@girs/soup-3.0": "^3.6.6-4.0.0-rc.9",
+    "@gjsify/buffer": "^0.2.0",
+    "@gjsify/events": "^0.2.0",
+    "@gjsify/http-soup-bridge": "^0.2.0",
+    "@gjsify/net": "^0.2.0",
+    "@gjsify/stream": "^0.2.0",
+    "@gjsify/url": "^0.2.0",
+    "@gjsify/utils": "^0.2.0"
   }
 }

package/src/incoming-message.ts

@@ -21,6 +21,9 @@ export class IncomingMessage extends Readable {
   socket: any = null;
   aborted = false;
 
+  /** Node.js legacy alias for socket — needed by engine.io and other HTTP consumers. */
+  get connection() { return this.socket; }
+
   private _timeoutTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor() {
@@ -31,6 +34,9 @@ export class IncomingMessage extends Readable {
     // Data is pushed externally via _pushBody or _pushStream
   }
 
+  // 'close' means connection lost, not body-stream end — don't auto-emit after 'end'.
+  protected _autoClose(): void { /* 'close' is emitted via destroy() only */ }
+
   /** Finish the readable stream with the body data (used by server-side handler). */
   _pushBody(body: Uint8Array | null): void {
     if (body && body.length > 0) {