fix(hot): end SSE requests that arrive after close()

instance.close() left `context.hot` set while `handle()` silently
returned, so a request to the hot path after close received no
response, no `next()`, and hung until the socket timed out.

Detach the SSE intercept on close so requests fall through to the
regular middleware, and answer 404 from `handle()` for requests that
raced the intercept.

Author: bjohansebas

src/hot.js

@@ -358,7 +358,14 @@ function createHot(compiler, userOptions) {
   return {
     path,
     handle(req, res) {
-      if (closed) return;
+      // A request can race `close()` past the middleware intercept — end it
+      // instead of leaving it hanging without a response.
+      if (closed) {
+        res.writeHead(404);
+        res.end();
+
+        return;
+      }
 
       eventStream.handler(req, res);
 

src/index.js

@@ -617,6 +617,9 @@ function wdm(compiler, options = {}, isPlugin = false) {
   instance.close = (callback = noop) => {
     if (filledContext.hot) {
       filledContext.hot.close();
+      // Also detach the SSE intercept so later requests fall through to the
+      // regular middleware instead of reaching the closed hot instance.
+      filledContext.hot = undefined;
     }
     filledContext.watching.close(callback);
   };

test/hot.test.js

@@ -455,6 +455,30 @@ describe("createHot", () => {
     hot.close();
   });
 
+  it("responds 404 instead of hanging when a client connects after close()", () => {
+    const compiler = makeFakeCompiler();
+    const hot = createHot(compiler, {});
+
+    hot.close();
+
+    /** @type {number | undefined} */
+    let statusCode;
+    let ended = false;
+    const res = {
+      writeHead: (code) => {
+        statusCode = code;
+      },
+      end: () => {
+        ended = true;
+      },
+    };
+
+    hot.handle({}, res);
+
+    expect(statusCode).toBe(404);
+    expect(ended).toBe(true);
+  });
+
   it("does not re-send the catch-up sync to already connected clients", () => {
     const compiler = makeFakeCompiler();
     const hot = createHot(compiler, {});

test/middleware.test.js

@@ -7033,6 +7033,29 @@ describe.each([
       );
     });
 
+    it("does not hang hot requests made after instance.close()", async () => {
+      const compiler = getCompiler(webpackConfig);
+      [server, req, instance] = await frameworkFactory(
+        name,
+        framework,
+        compiler,
+        { hot: true },
+      );
+
+      await waitUntilValid(instance);
+      await new Promise((resolve) => {
+        instance.close(resolve);
+      });
+
+      // The SSE intercept is detached, so the request must get a regular
+      // (non-stream) response instead of hanging forever.
+      const response = await req.get("/__webpack_hmr");
+
+      expect(response.headers["content-type"] || "").not.toMatch(
+        /text\/event-stream/,
+      );
+    });
+
     it("does not intercept the default hot path when hot is disabled", async () => {
       const compiler = getCompiler(webpackConfig);
       [server, req, instance] = await frameworkFactory(

types/hot.d.ts

@@ -75,6 +75,7 @@ declare const HOT_DEFAULT_HEARTBEAT: number;
  * @typedef {object} EventStream
  * @property {(req: IncomingMessage, res: ServerResponse) => void} handler attach a new client
  * @property {(payload: Payload | { action: string }) => void} publish publish a payload to every client
+ * @property {(res: ServerResponse, payload: Payload | { action: string }) => void} publishTo publish a payload to a single client
  * @property {() => void} close end every client and stop the heartbeat
  */
 declare const HOT_DEFAULT_PATH: "/__webpack_hmr";
@@ -225,6 +226,17 @@ type EventStream = {
           action: string;
         },
   ) => void;
+  /**
+   * publish a payload to a single client
+   */
+  publishTo: (
+    res: ServerResponse,
+    payload:
+      | Payload
+      | {
+          action: string;
+        },
+  ) => void;
   /**
    * end every client and stop the heartbeat
    */