@fuzdev/fuz_app 0.67.0 → 0.67.1

package/dist/testing/cross_backend/spawn_backend.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spawn_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/spawn_backend.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAQ,KAAK,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAI5D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAIvD,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC7B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAmID;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAU,QAAQ,aAAa,KAAG,OAAO,CAAC,aAAa,CA8FhF,CAAC"}
+{"version":3,"file":"spawn_backend.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/spawn_backend.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAQ,KAAK,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAI5D,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAIvD,6EAA6E;AAC7E,MAAM,WAAW,aAAa;IAC7B,yFAAyF;IACzF,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAC/B,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;OAGG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AA4ID;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAU,QAAQ,aAAa,KAAG,OAAO,CAAC,aAAa,CAiHhF,CAAC"}

package/dist/testing/cross_backend/spawn_backend.js

@@ -31,6 +31,14 @@ import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { dirname } from 'node:path';
 /** Number of ms between health-probe attempts. Tuned to be cheap on busy CI runners. */
 const HEALTH_PROBE_INTERVAL_MS = 100;
+/**
+ * Grace window after teardown's SIGTERM before escalating to SIGKILL on the
+ * process group. A well-behaved backend exits within milliseconds; this only
+ * fires for one that ignores SIGTERM or whose graceful shutdown never
+ * completes (e.g. a runtime whose `server.stop()` promise never resolves), so
+ * the await below can't strand the whole run forever.
+ */
+const TEARDOWN_SIGKILL_GRACE_MS = 3_000;
 /**
  * Sleep helper for the probe loop. Resolves after `ms`.
  */
@@ -208,10 +216,30 @@ export const spawn_backend = async (config) => {
         live_teardowns.delete(teardown_sync);
         if (exit_info !== null)
             return;
-        // Wait for the child to actually exit so callers can be sure the
-        // port is free.
+        // Wait for the child to actually exit so callers can be sure the port
+        // is free. A backend that ignores SIGTERM — or whose graceful shutdown
+        // wedges (e.g. a runtime whose `server.stop()` never resolves) — would
+        // otherwise hang this await forever and strand the run, so escalate to
+        // SIGKILL on the process group after a grace window. SIGKILL is
+        // uncatchable, so the child then exits and the `'exit'` listener
+        // resolves. Defense-in-depth: the per-runtime adapter shutdown is the
+        // primary fix; this guarantees teardown completes regardless.
         await new Promise((resolve) => {
-            child.once('exit', () => resolve());
+            const kill_timer = setTimeout(() => {
+                if (child.pid !== undefined && exit_info === null) {
+                    try {
+                        // Negative pid → process group.
+                        process.kill(-child.pid, 'SIGKILL');
+                    }
+                    catch {
+                        // Already dead; ignore.
+                    }
+                }
+            }, TEARDOWN_SIGKILL_GRACE_MS);
+            child.once('exit', () => {
+                clearTimeout(kill_timer);
+                resolve();
+            });
         });
     };
     live_teardowns.add(teardown_sync);

package/dist/testing/cross_backend/testing_server_bun.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing_server_bun.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_bun.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6B9B,OAAO,KAAK,EAAc,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAehF,kDAAkD;AAClD,eAAO,MAAM,0BAA0B,QAAO,oBA+B5C,CAAC"}
+{"version":3,"file":"testing_server_bun.d.ts","sourceRoot":"../src/lib/","sources":["../../../src/lib/testing/cross_backend/testing_server_bun.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,CAAC;AA6B9B,OAAO,KAAK,EAAc,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAehF,kDAAkD;AAClD,eAAO,MAAM,0BAA0B,QAAO,oBA0D5C,CAAC"}

package/dist/testing/cross_backend/testing_server_bun.js

@@ -43,8 +43,35 @@ export const create_bun_testing_adapter = () => ({
             websocket,
         });
         const handle = {
-            shutdown: async () => {
-                await server.stop();
+            // Bun bug (1.3.14): after a *server-initiated* WebSocket close
+            // (`ServerWebSocket.close()` / `hono/bun`'s `WSContext.close()`),
+            // `server.stop()` never resolves — Bun doesn't decrement its
+            // active-connection count for a server-closed socket, so the stop
+            // waits forever for a connection it already closed. The trigger is
+            // orthogonal to HTTP load, hono-vs-raw `Bun.serve`, in-vs-cross
+            // process, the force flag (`stop()`/`stop(false)`/`stop(true)` all
+            // hang), and the client runtime — a single server-closed WS is
+            // necessary and sufficient. Client-initiated close or leaving the
+            // socket open both stop cleanly in ~0ms. In this suite the trigger is
+            // `create_ws_auth_guard` closing the socket on `session_revoke_all`
+            // (the `ws.cross.test.ts` close-on-revoke case) — the only
+            // server-initiated WS close, which is why teardown hangs there and
+            // not under HTTP-only or client-closed WS traffic.
+            //
+            // So initiate a force-close (`true` drops active connections, no
+            // drain) but DON'T await it: awaiting hangs `start_testing_server`'s
+            // shutdown forever — `built.close()` and `exit(0)` never run, and the
+            // spawning harness blocks on a child that never exits (observed as a
+            // multi-minute hang needing SIGKILL). The force-close still tears the
+            // live sockets down; the `exit(0)` the core fires immediately after
+            // does the real teardown a few ms later. Node/Deno don't need this —
+            // their `shutdown()`/`close()` resolve normally. The `.catch` guards a
+            // future Bun that rejects rather than hangs; if a future Bun resolves
+            // the promise after a server-initiated close, revert to
+            // `await server.stop(true)` to mirror the Node/Deno adapters.
+            shutdown: () => {
+                void Promise.resolve(server.stop(true)).catch(() => { });
+                return Promise.resolve();
             },
             native: server,
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fuzdev/fuz_app",
-  "version": "0.67.0",
+  "version": "0.67.1",
   "description": "fullstack app library",
   "glyph": "🗝",
   "logo": "logo.svg",
@@ -14,6 +14,8 @@
     "build": "gro build",
     "check": "gro check",
     "test": "gro test",
+    "test:cross": "FUZ_TEST_CROSS_BACKEND=1 vitest run --project cross_backend_ts_node --project cross_backend_ts_deno --project cross_backend_ts_bun",
+    "test:cross:spine-stub": "FUZ_TEST_CROSS_BACKEND=1 vitest run --project cross_backend_spine_stub",
     "benchmark:cross-impl": "gro run src/benchmarks/cross_impl.bench.ts",
     "preview": "vite preview",
     "deploy": "gro deploy"