@gjsify/http 0.1.13 → 0.2.0

package/src/listen-error.spec.ts

@@ -0,0 +1,73 @@
+// Ported from refs/node-test/parallel/test-net-server-listen-handle.js
+// Original: MIT license, Node.js contributors
+// Tests that http.Server emits 'error' with code EADDRINUSE when port is busy.
+
+import { describe, it, expect } from '@gjsify/unit';
+import * as http from 'node:http';
+
+export default async () => {
+
+  await describe('http.Server listen error', async () => {
+
+    await it('should emit error with EADDRINUSE when port is already in use', async () => {
+      // First server binds a random port
+      const server1 = http.createServer();
+      const port = await new Promise<number>((resolve, reject) => {
+        server1.on('error', reject);
+        server1.listen(0, () => {
+          const addr = server1.address() as { port: number };
+          resolve(addr.port);
+        });
+      });
+
+      try {
+        // Second server tries to bind the same port — must emit 'error'
+        const error = await new Promise<any>((resolve, reject) => {
+          const server2 = http.createServer();
+          server2.on('error', resolve);
+          server2.on('listening', () => {
+            server2.close();
+            reject(new Error('Expected EADDRINUSE but server started successfully'));
+          });
+          server2.listen(port);
+        });
+
+        expect(error.code).toBe('EADDRINUSE');
+        expect(error.syscall).toBe('listen');
+        expect(typeof error.port).toBe('number');
+        expect(error.port).toBe(port);
+      } finally {
+        server1.close();
+      }
+    });
+
+    await it('should include address and port in error message', async () => {
+      const server1 = http.createServer();
+      const port = await new Promise<number>((resolve, reject) => {
+        server1.on('error', reject);
+        server1.listen(0, () => {
+          const addr = server1.address() as { port: number };
+          resolve(addr.port);
+        });
+      });
+
+      try {
+        const error = await new Promise<any>((resolve, reject) => {
+          const server2 = http.createServer();
+          server2.on('error', resolve);
+          server2.on('listening', () => {
+            server2.close();
+            reject(new Error('Expected EADDRINUSE'));
+          });
+          server2.listen(port);
+        });
+
+        expect(error.message).toContain('EADDRINUSE');
+        expect(error.message).toContain('listen');
+      } finally {
+        server1.close();
+      }
+    });
+
+  });
+};

package/src/server-request-socket.ts

@@ -0,0 +1,88 @@
+// `req.socket` for our HTTP server.
+//
+// Reference: Node.js lib/net.js Socket interface
+// Reimplemented for GJS — `@gjsify/http-soup-bridge` owns the underlying
+// TCP connection, so a real `Gio.Socket` is not directly accessible from
+// JS. This class satisfies the net.Socket duck-type expected by HTTP
+// consumers (Hono, MCP SDK, engine.io, …) using values copied off the
+// bridge `Request` instance at construction time.
+//
+// Extends Duplex (not EventEmitter) so that `instanceof stream.Duplex`
+// checks and stream API calls (`pipe`, `pause`, `resume`) work. `_read`
+// and `_write` are no-ops because the bridge owns the actual bytes.
+
+import { Duplex } from 'node:stream';
+import type { Response as BridgeResponse } from '@gjsify/http-soup-bridge';
+
+export 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 = 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).
+  private readonly _bridgeRes: BridgeResponse;
+  private _bridgePaused = false;
+
+  constructor(
+    remoteAddress: string,
+    remotePort: number,
+    localAddress: string,
+    localPort: number,
+    bridgeRes: BridgeResponse,
+    encrypted = false,
+  ) {
+    super({ allowHalfOpen: true });
+    this.remoteAddress = remoteAddress;
+    this.remotePort = remotePort;
+    this.localAddress = localAddress;
+    this.localPort = localPort;
+    this.encrypted = encrypted;
+    this._bridgeRes = bridgeRes;
+  }
+
+  pause(): this {
+    if (this._bridgePaused) return this;
+    this._bridgePaused = true;
+    return super.pause() as this;
+  }
+
+  resume(): this {
+    if (!this._bridgePaused) return super.resume() as this;
+    this._bridgePaused = false;
+    return super.resume() as this;
+  }
+
+  // The bridge owns the TCP connection — no data flows through this Duplex.
+  _read(_size: number): void {}
+  _write(_chunk: unknown, _encoding: BufferEncoding, cb: (err?: Error | null) => void): void { cb(); }
+
+  destroySoon(): void {
+    if (!this.writableEnded) this.end();
+    if (this.writableFinished)
+      this.destroy();
+    else
+      this.once('finish', () => this.destroy());
+  }
+
+  setTimeout(_timeout: number, cb?: () => void): this {
+    if (cb) this.once('timeout', cb);
+    return this;
+  }
+
+  setNoDelay(_noDelay?: boolean): this { return this; }
+  setKeepAlive(_enable?: boolean, _delay?: number): this { return this; }
+  ref(): this { return this; }
+  unref(): this { return this; }
+
+  address(): { address: string; family: string; port: number } {
+    return { address: this.localAddress, family: 'IPv4', port: this.localPort };
+  }
+}

package/src/server.ts

@@ -1,13 +1,28 @@
 // Reference: Node.js lib/_http_server.js
-// Reimplemented for GJS using Soup.Server
+// Reimplemented for GJS using the @gjsify/http-soup-bridge native package.
+//
+// Why the bridge: see STATUS.md "Upstream GJS Patch Candidates" — two
+// distinct GJS↔libsoup binding races (Boxed-Source GC race + shared
+// `GMainContext` ref imbalance) make any in-JS Soup.Server wiring
+// SIGSEGV silently after a non-GJS HTTP client (MCP Inspector subprocess,
+// Node.js fetch, browser EventSource) sends a chunked SSE response. The
+// bridge keeps every libsoup boxed type C-side; JS only sees plain
+// GObject ref-counted bridge classes (`Server` / `Request` / `Response`)
+// whose lifetime SpiderMonkey GC cannot race against. Same pattern as
+// `@gjsify/webrtc-native`.
 
-import Soup from '@girs/soup-3.0';
 import Gio from '@girs/gio-2.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,
+  type Request as BridgeRequest,
+  type Response as BridgeResponse,
+} 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';
 
@@ -92,19 +107,27 @@ export 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 class ServerResponse extends OutgoingMessage {
   statusCode = 200;
   statusMessage = '';
 
   private _streaming = false;
-  private _soupMsg: Soup.ServerMessage;
+  private _bridge: BridgeResponse;
   private _timeoutTimer: ReturnType<typeof setTimeout> | null = null;
 
-  constructor(soupMsg: Soup.ServerMessage) {
+  constructor(bridge: BridgeResponse) {
     super();
-    this._soupMsg = soupMsg;
+    this._bridge = bridge;
+    // Translate the bridge's `'close'` signal into a Node-style 'close'
+    // event for consumers (Hono, MCP transport, engine.io, etc.).
+    bridge.connect('close', () => {
+      this.emit('close');
+    });
   }
 
   /** Set a timeout for the response. Emits 'timeout' if response not sent within msecs. */
@@ -156,8 +179,6 @@ export class ServerResponse extends OutgoingMessage {
 
   /** Flush headers (send them immediately). */
   flushHeaders(): void {
-    // In our Soup-based implementation, headers are sent with the body.
-    // This is a no-op but marks headersSent for compatibility.
     if (!this.headersSent) {
       this.headersSent = true;
     }
@@ -165,17 +186,16 @@ export class ServerResponse extends OutgoingMessage {
 
   /** Add trailing headers for chunked transfer encoding. */
   addTrailers(headers: Record<string, string>): void {
-    // Soup.Server doesn't support HTTP trailers natively.
-    // Store for compatibility but they won't be sent.
+    // Soup.Server doesn't support HTTP trailers natively. Stored for
+    // compatibility but not transmitted.
     for (const [key, value] of Object.entries(headers)) {
-      // Trailers are appended after the body in chunked encoding
       this._headers.set('trailer-' + key.toLowerCase(), value);
     }
   }
 
   /**
-   * 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(): void {
     if (this._streaming) return;
@@ -187,83 +207,42 @@ export class ServerResponse extends OutgoingMessage {
       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 as string);
+        this._bridge.set_header(key, value as string);
       }
     }
+
+    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: any, encoding: string, callback: (error?: Error | null) => void): void {
     const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding as BufferEncoding);
     this._startStreaming();
-    const responseBody = this._soupMsg.get_response_body();
-    // GJS overload: append(data: Uint8Array) — single argument, no MemoryUse parameter
-    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: (error?: Error | null) => void): void {
-    if (this._streaming) {
-      // Streaming mode — signal no more chunks
-      const responseBody = this._soupMsg.get_response_body();
-      responseBody.complete();
-      this._soupMsg.unpause();
-    } else {
-      // Batch mode — no write() was called (e.g. redirects, 204, empty end())
-      this._sendBatchResponse();
-    }
-    this.finished = true;
-    callback();
-  }
-
-  /** Batch response — sends status + headers + empty/no body in one shot (for responses without write()). */
-  private _sendBatchResponse(): void {
-    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) {
+      // Batch mode — push headers + status then end with no body. The
+      // bridge's `end()` on a fresh Response sends an empty body.
+      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 as string);
         }
-      } else {
-        responseHeaders.replace(key, value as string);
       }
+      this._bridge.write_head(this.statusCode, this.statusMessage || null);
     }
-
-    // Empty body — use set_response so Soup knows the response is complete.
-    const contentType = (this._headers.get('content-type') as string) || '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). */
@@ -285,14 +264,20 @@ export class ServerResponse extends OutgoingMessage {
   }
 }
 
-// GC guard — GJS garbage-collects objects with no JS references. When frameworks
-// like Koa/Express create an http.Server inside .listen() and the caller discards
-// the return value, the Server (and its Soup.Server) gets collected after ~10s.
-// This Set keeps a strong reference to every listening server.
+// GC guard — GJS garbage-collects objects with no JS references. When
+// frameworks like Koa/Express create an http.Server inside .listen() and
+// the caller discards the return value, the Server (and its bridge
+// underneath) gets collected after ~10 s. This Set keeps a strong
+// reference to every listening server.
 const _activeServers = new Set<Server>();
 
 /**
- * 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 class Server extends EventEmitter {
   listening = false;
@@ -302,9 +287,16 @@ export class Server extends EventEmitter {
   headersTimeout = 60000;
   requestTimeout = 300000;
 
-  private _soupServer: Soup.Server | null = null;
+  private _bridge: BridgeServer | null = null;
   private _address: { port: number; family: string; address: string } | null = 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(): unknown {
+    return this._bridge?.soup_server ?? null;
+  }
+
   constructor(requestListener?: ((req: IncomingMessage, res: ServerResponse) => void) | Record<string, unknown>);
   constructor(options: Record<string, unknown>, requestListener?: (req: IncomingMessage, res: ServerResponse) => void);
   constructor(
@@ -312,11 +304,8 @@ export class Server extends EventEmitter {
     requestListener?: (req: IncomingMessage, res: ServerResponse) => void,
   ) {
     super();
-    // Support Node.js signature: new Server(options, listener)
     const listener = typeof optionsOrListener === 'function' ? optionsOrListener : requestListener;
-    if (listener) {
-      this.on('request', listener);
-    }
+    if (listener) this.on('request', listener);
   }
 
   listen(port?: number, hostname?: string, backlog?: number, callback?: () => void): this;
@@ -336,110 +325,127 @@ export class Server extends EventEmitter {
     if (callback) this.once('listening', callback);
 
     try {
-      this._soupServer = new Soup.Server({});
+      this._bridge = new BridgeServer();
 
-      // Add a catch-all handler
-      this._soupServer.add_handler(null, (server: Soup.Server, msg: Soup.ServerMessage, path: string) => {
-        this._handleRequest(msg, path);
+      this._bridge.connect('request-received', (_self: BridgeServer, req: BridgeRequest, res: BridgeResponse) => {
+        this._handleRequest(req, res);
       });
 
-      this._soupServer.listen_local(port, Soup.ServerListenOptions.IPV4_ONLY);
-      ensureMainLoop();
+      this._bridge.connect('upgrade', (_self: BridgeServer, req: BridgeRequest, iostream: Gio.IOStream, _head: unknown) => {
+        this._handleUpgrade(req, iostream);
+      });
 
-      // Get the actual port from listeners
-      const listeners = this._soupServer.get_listeners();
-      let actualPort = port;
-      if (listeners && listeners.length > 0) {
-        const addr = listeners[0].get_local_address() as Gio.InetSocketAddress;
-        if (addr && typeof addr.get_port === 'function') {
-          actualPort = addr.get_port();
-        }
-      }
+      this._bridge.connect('error-occurred', (_self: BridgeServer, msg: string) => {
+        this.emit('error', new Error(msg));
+      });
+
+      this._bridge.listen(port, hostname);
+
+      ensureMainLoop();
 
       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: unknown) {
-      const error = err instanceof Error ? err : new Error(String(err));
-      if (this.listenerCount('error') === 0) {
-        // No error listener — throw like Node.js does for unhandled EventEmitter errors
-        throw error;
-      }
-      deferEmit(this, 'error', error);
+      const nodeErr = createNodeError(err, 'listen', { address: hostname, port });
+      deferEmit(this, 'error', nodeErr);
     }
 
     return this;
   }
 
-  private _handleRequest(soupMsg: Soup.ServerMessage, path: string): void {
+  private _handleRequest(bridgeReq: BridgeRequest, bridgeRes: BridgeResponse): void {
     const req = new IncomingMessage();
-    const res = new ServerResponse(soupMsg);
+    const res = new ServerResponse(bridgeRes);
 
-    // Populate request properties
-    req.method = soupMsg.get_method();
-    req.url = soupMsg.get_uri().get_path();
-    const query = soupMsg.get_uri().get_query();
-    if (query) req.url += '?' + query;
+    req.method = bridgeReq.method;
+    req.url = bridgeReq.url;
     req.httpVersion = '1.1';
 
-    // Parse headers
-    const requestHeaders = soupMsg.get_request_headers();
-    requestHeaders.foreach((name: string, value: string) => {
+    // header_pairs is [name, value, 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 as string, value];
-        }
+        if (Array.isArray(existing)) existing.push(value);
+        else req.headers[lower] = [existing as string, 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,
+    ) as unknown as import('net').Socket;
+
+    // Push body bytes (pre-buffered by libsoup) and EOF. Body is exposed
+    // as a method (not a property) on the bridge — GIR-marshalled
+    // `uint8[]` properties get cleared by the time JS reads them.
+    const body = bridgeReq.get_body();
+    if (body.length > 0) req._pushBody(body);
+    else req._pushBody(null);
+
+    // Translate bridge 'aborted_signal' / 'close' into req events.
+    bridgeReq.connect('aborted_signal', () => {
+      if (!req.aborted) {
+        req.aborted = true;
+        req.emit('aborted');
+      }
+    });
+    bridgeReq.connect('close', () => {
+      req.emit('close');
     });
 
-    // Check for HTTP upgrade request (WebSocket, etc.)
-    // Reference: Node.js lib/_http_server.js — emits 'upgrade' with (req, socket, head)
-    const connectionHeader = (req.headers['connection'] as string || '').toLowerCase();
-    const upgradeHeader = (req.headers['upgrade'] as string || '').toLowerCase();
-    if (connectionHeader.includes('upgrade') && upgradeHeader && this.listenerCount('upgrade') > 0) {
-      // Steal the raw TCP connection from Soup before it sends a response.
-      // This gives us a Gio.IOStream positioned after the parsed HTTP request.
-      let ioStream: Gio.IOStream | null = null;
-      try {
-        ioStream = soupMsg.steal_connection();
-      } catch (err) {
-        // steal_connection() may fail if Soup has already started processing
-        // the response or if the connection is in an unexpected state.
+    // Emit synchronously. Async handler rejections that escape user code
+    // are caught here so they surface on stderr instead of becoming silent
+    // GLib-callback rejections.
+    try {
+      const result = this.emit('request', req, res) as unknown;
+      if (result instanceof Promise || (result !== null && typeof result === 'object' && typeof (result as { then?: unknown }).then === 'function')) {
+        (result as Promise<unknown>).catch((err: unknown) => {
+          console.error('[HTTP] Unhandled error in async request handler:', err);
+          if (!res.headersSent) {
+            try { res.writeHead(500); res.end('Internal Server Error'); } catch { /* ignore */ }
+          }
+        });
       }
-      if (ioStream) {
-        const socket = new NetSocket();
-        socket._setupFromIOStream(ioStream);
-        // head: any data after HTTP headers — empty for upgrade requests
-        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 { /* ignore */ }
       }
     }
+  }
 
-    // Get request body
-    const body = soupMsg.get_request_body();
-    if (body && body.data && body.data.length > 0) {
-      req._pushBody(body.data);
-    } else {
-      req._pushBody(null);
-    }
-
-    // Pause Soup's processing — we'll set the response when ServerResponse.end() is called
-    soupMsg.pause();
+  private _handleUpgrade(bridgeReq: BridgeRequest, iostream: Gio.IOStream): void {
+    const req = new IncomingMessage();
+    req.method = bridgeReq.method;
+    req.url = bridgeReq.url;
+    req.httpVersion = '1.1';
 
-    res.on('finish', () => {
-      soupMsg.unpause();
-    });
+    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;
+    }
 
-    this.emit('request', req, res);
+    if (this.listenerCount('upgrade') > 0) {
+      const socket = new NetSocket();
+      socket._attachOutputOnly(iostream);
+      this.emit('upgrade', req, socket, Buffer.alloc(0));
+    }
   }
 
   address(): { port: number; family: string; address: string } | null {
@@ -448,7 +454,7 @@ export class Server extends EventEmitter {
 
   /**
    * 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
    */
@@ -456,12 +462,20 @@ export class Server extends EventEmitter {
     path: string,
     callback: (connection: unknown) => void,
   ): void {
-    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 as {
+      add_websocket_handler: (
+        p: string | null,
+        origin: string | null,
+        protocols: string[] | null,
+        cb: (srv: unknown, msg: unknown, p: string, conn: unknown) => void,
+      ) => void;
+    };
+    soupServer.add_websocket_handler(
       path, null, null,
-      (_srv: Soup.Server, _msg: Soup.ServerMessage, _path: string, connection: unknown) => {
+      (_srv, _msg, _p, connection) => {
         callback(connection);
       },
     );
@@ -470,9 +484,9 @@ export class Server extends EventEmitter {
   close(callback?: (err?: Error) => void): this {
     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;

package/src/test.mts

@@ -8,5 +8,6 @@ import extendedTestSuite from './extended.spec.js';
 import streamingTestSuite from './streaming.spec.js';
 import timeoutTestSuite from './timeout.spec.js';
 import upgradeTestSuite from './upgrade.spec.js';
+import listenErrorTestSuite from './listen-error.spec.js';
 
-run({testSuite, clientTestSuite, extendedTestSuite, streamingTestSuite, timeoutTestSuite, upgradeTestSuite});
+run({testSuite, clientTestSuite, extendedTestSuite, streamingTestSuite, timeoutTestSuite, upgradeTestSuite, listenErrorTestSuite});