test: prove SSE broadcast with two real pages and a mid-connection publish

Two browser pages connected to the same server both apply a single
edit — broadcast proven end to end. The unit variant also stops passing
vacuously: it now publishes while both SSE clients are attached instead
of only observing the per-client connect-time sync.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: bjohansebas

test/e2e/client.test.js

@@ -1,6 +1,6 @@
 import collectConsole, { normalizeConsole } from "../helpers/console-collector";
 import createHotApp from "../helpers/hot-app";
-import runBrowser from "../helpers/run-browser";
+import runBrowser, { runPage } from "../helpers/run-browser";
 
 jest.setTimeout(120000);
 
@@ -102,6 +102,26 @@ describe("hot client (browser)", () => {
     expect(await readReloadMarker(page)).toBe(true);
   });
 
+  it("broadcasts one build to every connected page", async () => {
+    app = await createHotApp({ code: acceptedApp("v1") });
+    ({ page, browser } = await runBrowser());
+    const pageTwo = await runPage(browser);
+
+    await page.goto(app.url);
+    await pageTwo.goto(app.url);
+    await waitForAppText(page, "v1");
+    await waitForAppText(pageTwo, "v1");
+
+    // One edit, one publish  ed build — every connected page applies it.
+    app.edit(acceptedApp("v2"));
+    await waitForAppText(page, "v2");
+    await waitForAppText(pageTwo, "v2");
+
+    expect(
+      await pageTwo.evaluate(() => document.getElementById("app").textContent),
+    ).toBe("v2");
+  });
+
   it("falls back to a full reload when the update is not accepted", async () => {
     app = await createHotApp({ code: unacceptedApp("v1") });
     ({ page, browser } = await runBrowser());

test/middleware.test.js

@@ -7299,13 +7299,26 @@ describe.each([
 
         await waitUntilValid(instance);
 
-        const [first, second] = await Promise.all([
-          readSseEvents(server, "/__webpack_hmr"),
-          readSseEvents(server, "/__webpack_hmr"),
+        const events = Promise.all([
+          readSseEvents(server, "/__webpack_hmr", 1500),
+          readSseEvents(server, "/__webpack_hmr", 1500),
         ]);
 
-        expect(first.some((event) => event.action === "sync")).toBe(true);
-        expect(second.some((event) => event.action === "sync")).toBe(true);
+        // Broadcast while both clients are attached — the connect-time sync
+        // alone is written per client and would make this pass vacuously.
+        await new Promise((resolve) => {
+          setTimeout(resolve, 300);
+        });
+        instance.context.hot.publish({ action: "broadcast-check" });
+
+        const [first, second] = await events;
+
+        expect(first.some((event) => event.action === "broadcast-check")).toBe(
+          true,
+        );
+        expect(second.some((event) => event.action === "broadcast-check")).toBe(
+          true,
+        );
       });
     });
   });