@webjsdev/server 0.8.27 → 0.8.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webjsdev/server",
-  "version": "0.8.27",
+  "version": "0.8.29",
   "type": "module",
   "description": "webjs dev/prod server: SSR, router, API, server actions, live reload",
   "main": "index.js",
@@ -51,5 +51,8 @@
   ],
   "engines": {
     "node": ">=24.0.0"
+  },
+  "optionalDependencies": {
+    "amaro": "^1.1.10"
   }
 }

package/src/action-seed-bun.js

@@ -0,0 +1,67 @@
+/**
+ * Bun install for SSR action-result seeding (#472, #529).
+ *
+ * Bun has no `module.registerHooks`, so the seed facade is installed via a
+ * `Bun.plugin` `onLoad`, the Bun analog of the Node load hook in
+ * `action-seed.js`. This module is dynamically imported by `registerSeedHooks`
+ * ONLY when `serverRuntime()` is `'bun'`, so the `Bun.*` global is never
+ * referenced on Node (the same isolation as `listener-bun.js`).
+ *
+ * The faceting DECISION (`isSeedCandidate`) and the facade SOURCE
+ * (`buildSeedFacade`) are the shared, runtime-neutral helpers passed in, so Node
+ * and Bun emit byte-identical facades that feed the same `AsyncLocalStorage`
+ * collector. The only Bun-specific glue here is the plugin shell + reading the
+ * source via `Bun.file`.
+ *
+ * Bun's `onLoad` `args.path` includes any query (verified), so the facade's
+ * `?webjs-seed-orig` passthrough and a dev `?t=` re-import are both seen, exactly
+ * like the Node hook's URL.
+ *
+ * UNLIKE Node's hook, a Bun `onLoad` registered for a filter MUST return a
+ * `{ contents, loader }` object for EVERY match; returning `undefined` to defer
+ * to the default loader is an error ("onLoad() expects an object returned"). So
+ * the non-facet cases (the `?webjs-seed-orig` passthrough, a `.server.*` with no
+ * `'use server'`, an unenumerable `export *`) are handled by reading and
+ * RETURNING the real source ourselves with the extension's loader, which is the
+ * same module Bun would have loaded.
+ */
+
+/**
+ * Install the `Bun.plugin` seed `onLoad`. Idempotency is the caller's
+ * responsibility (`registerSeedHooks` guards on `_registered`).
+ *
+ * @param {{
+ *   isSeedCandidate: (specifier: string) => boolean,
+ *   buildSeedFacade: (origSpec: string, absPath: string, src: string) => (string | null),
+ *   serverFileRe: RegExp,
+ * }} helpers
+ */
+export function installBunSeedPlugin({ isSeedCandidate, buildSeedFacade, serverFileRe }) {
+  Bun.plugin({
+    name: 'webjs-action-seed',
+    setup(build) {
+      // The filter is a cheap path pre-screen (`*.server.*`, optional query).
+      build.onLoad({ filter: serverFileRe }, async (args) => {
+        const absPath = args.path.split('?')[0];
+        // `.ts` / `.mts` strip via the `ts` loader; `.js` / `.mjs` via `js`.
+        const loader = /\.m?ts$/.test(absPath) ? 'ts' : 'js';
+        // Read the real source. A genuine read failure (missing file) propagates,
+        // which Bun reports as a load error exactly as it would without the plugin.
+        const src = await Bun.file(absPath).text();
+        try {
+          // Facet only a `'use server'` candidate (not the `?webjs-seed-orig`
+          // passthrough); a non-candidate or a passthrough falls through to the
+          // raw source below.
+          if (isSeedCandidate(args.path)) {
+            const source = buildSeedFacade(args.path, absPath, src);
+            if (source != null) return { contents: source, loader: 'js' };
+          }
+        } catch {
+          // Fail-open: any faceting error serves the raw source (no seeding for
+          // this module), the Bun analog of the Node hook's `nextLoad` fallback.
+        }
+        return { contents: src, loader };
+      });
+    },
+  });
+}

package/src/action-seed.js

@@ -18,11 +18,18 @@
  * The framework promise is "what you write is what you see in the browser source
  * tab", not "what you write is the exact function object that runs server-side"
  * (the RPC stub already replaces the action on the client). So we install a
- * SERVER-SIDE transparent facade via Node's synchronous `module.registerHooks`
- * (Node 24+, main-thread): for a `'use server'` `*.server.*` module, the load
- * hook returns a facade that re-exports each function wrapped in a `Proxy`. The
- * Proxy records `(file, fn, args) -> result` into an ambient `AsyncLocalStorage`
- * collector WHENEVER a collector is active, and is a pure passthrough otherwise.
+ * SERVER-SIDE transparent facade at module load: for a `'use server'`
+ * `*.server.*` module, the load hook returns a facade that re-exports each
+ * function wrapped in a `Proxy`. The Proxy records `(file, fn, args) -> result`
+ * into an ambient `AsyncLocalStorage` collector WHENEVER a collector is active,
+ * and is a pure passthrough otherwise.
+ *
+ * The facade SOURCE and the wrapping (`__seedWrap`, `buildSeedFacade`) are
+ * runtime-neutral; only the INSTALL mechanism differs by runtime (`#529`), chosen
+ * by `serverRuntime()`: Node uses the synchronous `module.registerHooks` load
+ * hook (Node 24+, main-thread); Bun uses a `Bun.plugin` `onLoad` (Bun has no
+ * `module.registerHooks`). Both feed the same `AsyncLocalStorage` collector and
+ * emit the same seed wire, so a page seeds identically on either runtime.
  *
  * Recording is gated entirely by the ALS collector, which is established ONLY
  * around the SSR page render (`collectSeeds`). The RPC endpoint path runs with
@@ -48,6 +55,7 @@ import { fileURLToPath } from 'node:url';
 import { stringify } from '@webjsdev/core';
 import { hashFile } from './actions.js';
 import { isStreamable } from './action-stream.js';
+import { serverRuntime } from './listener-core.js';
 
 /** Ambient per-render seed collector. `Map<key, value>` or undefined. */
 const als = new AsyncLocalStorage();
@@ -205,6 +213,17 @@ function buildFacade(origUrl, absPath, exports) {
   const file = JSON.stringify(absPath);
   let out = `import * as __orig from ${origSpec};\n`;
   out += `import { __seedWrap as __w } from ${JSON.stringify(SELF_URL)};\n`;
+  // Fail-open catch-all (#535). Re-export every named binding of the real module.
+  // An explicit `export const NAME = __w(...)` below SHADOWS the matching star
+  // binding (an explicit export wins over a star re-export of the same name, with
+  // no SyntaxError), so an enumerated export is still wrapped and seeded. A named
+  // export the `extractExportNames` regex MISSED (exotic syntax, an unusual
+  // re-export form, a codegen-produced export) is NOT enumerated below, so it
+  // flows through this star unwrapped: it resolves and works over a normal RPC,
+  // just is not seeded, instead of being dropped and crashing the importer with
+  // `undefined`. `export *` does not carry `default`, which the explicit default
+  // line below still handles.
+  out += `export * from ${origSpec};\n`;
   for (const n of exports.names) {
     const k = JSON.stringify(n);
     out += `export const ${n} = __w(${file}, ${k}, __orig[${k}]);\n`;
@@ -215,13 +234,46 @@ function buildFacade(origUrl, absPath, exports) {
   return out;
 }
 
-/** Match `*.server.{js,ts,mjs,mts}` (optionally with a query). */
-const SERVER_FILE_RE = /\.server\.m?[jt]s(\?|$)/;
+/** Match `*.server.{js,ts,mjs,mts}` (optionally with a query). Also the Bun plugin filter. */
+export const SERVER_FILE_RE = /\.server\.m?[jt]s(\?|$)/;
 /** The `'use server'` directive in the file head. */
 const USE_SERVER_RE = /^\s*(['"])use server\1\s*;?\s*$/m;
 
 /**
- * The synchronous `module.registerHooks` load hook. For a `'use server'`
+ * Whether a load specifier (a Node file URL or a Bun file path, with an optional
+ * query) is a faceting candidate: a `*.server.*` module that is NOT the facade's
+ * own `?webjs-seed-orig` passthrough of the real module. Runtime-neutral.
+ * @param {string} specifier
+ * @returns {boolean}
+ */
+export function isSeedCandidate(specifier) {
+  return SERVER_FILE_RE.test(specifier) && !specifier.includes('webjs-seed-orig');
+}
+
+/**
+ * Build the wrapping facade for a candidate module's source, or null to pass it
+ * through unwrapped (no `'use server'`, a non-enumerable `export *`, or no
+ * exports). Runtime-neutral: the caller passes the load specifier (URL on Node,
+ * path on Bun) used as the facade's `?webjs-seed-orig` import base, plus the
+ * absolute file path (the hash basis) and the already-read source.
+ * @param {string} origSpec the real module's load specifier (URL or path), no seed query
+ * @param {string} absPath the real module's absolute file path
+ * @param {string} src the module source
+ * @returns {string | null} facade source, or null for passthrough
+ */
+export function buildSeedFacade(origSpec, absPath, src) {
+  const head = src.split('\n').slice(0, 5).join('\n');
+  if (!USE_SERVER_RE.test(head)) return null;
+  const exports = extractExportNames(src);
+  // A `export *` re-export cannot be enumerated; skip faceting (passthrough)
+  // so we never emit a facade that silently drops re-exported bindings.
+  if (exports.hasStar) return null;
+  if (exports.names.length === 0 && !exports.hasDefault) return null;
+  return buildFacade(origSpec, absPath, exports);
+}
+
+/**
+ * The synchronous `module.registerHooks` load hook (Node). For a `'use server'`
  * `*.server.*` module it returns a wrapping facade; for everything else
  * (including the `?webjs-seed-orig` passthrough of the real module) it defers to
  * `nextLoad`. Fail-open: any error defers to `nextLoad`, so a load that the hook
@@ -232,19 +284,11 @@ const USE_SERVER_RE = /^\s*(['"])use server\1\s*;?\s*$/m;
  */
 function seedLoadHook(url, context, nextLoad) {
   try {
-    if (!SERVER_FILE_RE.test(url)) return nextLoad(url, context);
-    // The facade's own `?webjs-seed-orig` import must load the REAL module.
-    if (url.includes('webjs-seed-orig')) return nextLoad(url, context);
+    if (!isSeedCandidate(url)) return nextLoad(url, context);
     const absPath = fileURLToPath(url.split('?')[0]);
     const src = readFileSync(absPath, 'utf8');
-    const head = src.split('\n').slice(0, 5).join('\n');
-    if (!USE_SERVER_RE.test(head)) return nextLoad(url, context);
-    const exports = extractExportNames(src);
-    // A `export *` re-export cannot be enumerated; skip faceting (passthrough)
-    // so we never emit a facade that silently drops re-exported bindings.
-    if (exports.hasStar) return nextLoad(url, context);
-    if (exports.names.length === 0 && !exports.hasDefault) return nextLoad(url, context);
-    const source = buildFacade(url, absPath, exports);
+    const source = buildSeedFacade(url, absPath, src);
+    if (source == null) return nextLoad(url, context);
     return { source, format: 'module', shortCircuit: true };
   } catch {
     return nextLoad(url, context);
@@ -253,15 +297,36 @@ function seedLoadHook(url, context, nextLoad) {
 
 /**
  * Install the seed load hook (idempotent). Called once at boot from `dev.js`
- * when seeding is enabled, BEFORE any action module is imported (ESM caches by
- * URL, so a module loaded before the hook would never be faceted). A no-op on a
- * second call.
+ * when seeding is enabled, BEFORE any action module is imported (a module loaded
+ * before the hook would already be cached unwrapped). The install mechanism is
+ * chosen by `serverRuntime()` (#529): Node's synchronous `module.registerHooks`,
+ * or a `Bun.plugin` `onLoad` on Bun. A no-op on a second call. Async because the
+ * Bun path dynamically imports `action-seed-bun.js` (so the `Bun.*` global is
+ * never referenced on Node); the Node path resolves synchronously.
+ * @returns {Promise<void>}
  */
-export function registerSeedHooks() {
-  _enabled = true;
+export async function registerSeedHooks() {
   if (_registered) return;
   _registered = true;
+
+  if (serverRuntime() === 'bun') {
+    // Bun has no module.registerHooks; install the same facade via Bun.plugin.
+    const { installBunSeedPlugin } = await import('./action-seed-bun.js');
+    installBunSeedPlugin({ isSeedCandidate, buildSeedFacade, serverFileRe: SERVER_FILE_RE });
+    _enabled = true;
+    return;
+  }
+
+  // A runtime that is neither Node-with-registerHooks nor Bun: seeding stays
+  // OFF (fail-open). `seedingEnabled()` is false, ssr.js emits no seed block,
+  // and the client RPC stub falls back to a normal fetch. Never wrong data.
+  if (typeof nodeModule.registerHooks !== 'function') {
+    console.warn('[webjs] SSR action-result seeding (#472) is disabled: this runtime has neither module.registerHooks nor Bun.plugin. Async-render components re-fetch on hydration; no correctness impact.');
+    return;
+  }
+
   nodeModule.registerHooks({ load: seedLoadHook });
+  _enabled = true;
 }
 
 /**

package/src/dev.js

@@ -1,50 +1,15 @@
 import { createServer as createHttp1Server } from 'node:http';
 import { stat, readFile, watch as fsWatch } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
-import { createGzip, createBrotliCompress, constants as zlibConstants } from 'node:zlib';
 import { join, extname, resolve, dirname, relative, sep } from 'node:path';
 import { createRequire } from 'node:module';
-// Namespace import, NOT `import { stripTypeScriptTypes }`. On Node < 22.13 the
-// `stripTypeScriptTypes` named export does not exist, and a NAMED import of a
-// missing builtin export is a LINK-TIME SyntaxError that fires before any
-// module body runs, which would defeat the Node-version preflight (issue #238)
-// by crashing the import of @webjsdev/server itself. A namespace import links
-// on every Node (the property is just `undefined` at runtime on old Node), so
-// importing @webjsdev/server succeeds and `assertNodeVersion()` at the top of
-// createRequestHandler throws the clean "you need Node 24+" message instead.
-import * as nodeModule from 'node:module';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 // Server-side `.ts` imports are handled natively by Node 24+'s default
-// type-stripping (`process.features.typescript === 'strip'`). No loader
-// hook required. The browser-bound TypeScript request handler uses
-// `module.stripTypeScriptTypes` for the same transform, so SSR and
-// hydration produce identical JS.
-//
-// Runtime backing: Node ships `stripTypeScriptTypes` via the `amaro`
-// package internally (wraps SWC's WASM TypeScript transform in a
-// position-preserving strip-only mode). If the framework ever needs
-// to run on Bun, Deno, or another runtime that does NOT expose the
-// equivalent built-in, we will need to install `amaro` directly (or
-// an equivalent: Sucrase preserves lines but not columns; SWC's
-// strip-only also works). The fast-path `stripTs` helper would
-// change one import line.
-//
-// Suppress the one-shot ExperimentalWarning that Node prints the
-// first time `stripTypeScriptTypes` is called. The API is committed
-// per Node 24's release notes; the warning is a holdover. We keep
-// every other warning intact.
-const _origEmitWarning = process.emitWarning.bind(process);
-process.emitWarning = function (warning, type, code, ctor) {
-  const msg = warning && warning.message ? warning.message : String(warning);
-  if (
-    (type === 'ExperimentalWarning' || (warning && warning.name === 'ExperimentalWarning')) &&
-    msg.includes('stripTypeScriptTypes')
-  ) {
-    return;
-  }
-  return _origEmitWarning(warning, type, code, ctor);
-};
+// type-stripping (`process.features.typescript === 'strip'`) or by Bun. The
+// BROWSER-bound `.ts` request handler erases types via the pluggable stripper in
+// `./ts-strip.js` (Node's built-in `module.stripTypeScriptTypes`, or `amaro` on
+// Bun), so SSR and hydration produce identical JS on either runtime (#508).
 
 import { buildRouteTable, matchPage, matchApi } from './router.js';
 import { generateRouteTypes } from './route-types.js';
@@ -61,6 +26,7 @@ import {
   hashFile,
 } from './actions.js';
 import { registerSeedHooks } from './action-seed.js';
+import { stripTypeScript, ensureStripper } from './ts-strip.js';
 import { defaultLogger } from './logger.js';
 import { assertNodeVersion } from './node-version.js';
 import { applyEnvValidation } from './env-schema.js';
@@ -68,6 +34,16 @@ import { withRequest, setCspNonce, setBodyLimits, setRequestId, requestId as get
 import { buildInfoResponse } from './build-info.js';
 import { readCspConfig, mintNonce, buildCspHeader, cspHeaderName } from './csp.js';
 import { attachWebSocket } from './websocket.js';
+import {
+  SseHub,
+  serverRuntime,
+  isCompressible,
+  installProcessHandlers,
+  makeShutdown,
+  negotiateEncoding,
+  createCompressor,
+  varyWithAcceptEncoding,
+} from './listener-core.js';
 import { scanBareImports, resolveVendorImports, serveDownloadedBundle, clearVendorCache, hasVendorPin, readPinFile, prunePinToReachable } from './vendor.js';
 import { buildModuleGraph, transitiveDeps, reachableFromEntries, resolveImport } from './module-graph.js';
 import { primeComponentRegistry, findOrphanComponents, scanComponents } from './component-scanner.js';
@@ -441,6 +417,10 @@ export async function createRequestHandler(opts) {
   // Throw a clear Error here so an embedded host (Express/Fastify/Bun/Deno)
   // gets the actionable message at boot, not a cryptic API failure mid-request.
   assertNodeVersion({ onFail: 'throw' });
+  // Resolve the TS stripper backend at boot (#508): the Node built-in, or amaro
+  // on Bun. Doing it here pays the (one-time) amaro import up front and surfaces
+  // a missing-amaro error at boot rather than on the first `.ts` request.
+  await ensureStripper();
   const appDir = resolve(opts.appDir);
   // Load <appDir>/.env into process.env BEFORE anything else.
   // buildActionIndex below imports server-only files (lib/*.server.ts,
@@ -528,7 +508,7 @@ export async function createRequestHandler(opts) {
   // Read once (not per-rebuild): the hook is global and cannot be cleanly
   // un-installed, so toggling needs a restart. Disabled -> no hook, no ambient
   // collector wrap in ssr.js, and module loading stays byte-identical.
-  if (await readSeedEnabled(appDir)) registerSeedHooks();
+  if (await readSeedEnabled(appDir)) await registerSeedHooks();
 
   // When an app commits a vendor pin (.webjs/vendor/importmap.json) it carries a
   // deterministic vendor map that is cheap to read (one file, no analysis, no
@@ -1402,26 +1382,28 @@ export async function startServer(opts) {
   const compress = opts.compress ?? !dev;
   const logger = opts.logger || defaultLogger({ dev });
 
-  /** @type {Set<import('node:http').ServerResponse>} */
-  const sseClients = new Set();
-  const app = await createRequestHandler({
-    ...opts,
-    logger,
-    onReload: () => {
-      for (const res of sseClients) {
-        try { res.write(`event: reload\ndata: now\n\n`); } catch {}
-      }
-    },
-    // Dev error overlay (#264): push a frame to every open tab over the SAME
-    // SSE channel. A distinct `webjs-error` event name (NOT `error`, which is
-    // EventSource's native connection-error event) carries the JSON frame.
-    onDevError: (frame) => {
-      const data = JSON.stringify(frame);
-      for (const res of sseClients) {
-        try { res.write(`event: webjs-error\ndata: ${data}\n\n`); } catch {}
-      }
-    },
-  });
+  // Runtime-neutral SSE registry + fanout (shared by the node:http and Bun.serve
+  // shells via listener-core.js, so live-reload + the dev error overlay behave
+  // identically on both). Built before the handler so its onReload / onDevError
+  // callbacks can fan out through it.
+  const hub = new SseHub();
+  let app;
+  try {
+    app = await createRequestHandler({
+      ...opts,
+      logger,
+      onReload: () => hub.reload(),
+      // Dev error overlay (#264): push a frame to every open tab over the SAME
+      // SSE channel. A distinct `webjs-error` event name (NOT `error`, which is
+      // EventSource's native connection-error event) carries the JSON frame.
+      onDevError: (frame) => hub.devError(frame),
+    });
+  } catch (e) {
+    // The hub starts its keepalive interval in its constructor (before this
+    // await), so a boot failure must clear it rather than leak a live timer.
+    hub.closeAll();
+    throw e;
+  }
 
   /** @type {AbortController | null} */
   let watcherAbort = null;
@@ -1451,14 +1433,42 @@ export async function startServer(opts) {
     })();
   }
 
-  // SSE keepalive: send a comment frame every 25s to defeat proxy idle timeouts.
-  // Cheap (no event listeners on the client side) and safe: comments are ignored.
-  const keepalive = setInterval(() => {
-    for (const res of sseClients) {
-      try { res.write(`: ka\n\n`); } catch {}
-    }
-  }, 25_000);
-  keepalive.unref();
+  // Inbound server timeouts (issue #237). On node these are the node:http
+  // built-ins; on Bun the node `requestTimeout` maps to Bun's single
+  // `idleTimeout`. Defends against slowloris and hung connections. Overridable
+  // via `webjs.requestTimeoutMs` / `headersTimeoutMs` / `keepAliveTimeoutMs` in
+  // package.json or the matching WEBJS_*_MS env vars; `0` disables that timeout.
+  const timeouts = await readServerTimeoutsFromApp(app.appDir);
+
+  // The shared context both listener shells consume. The transport-specific glue
+  // (node:http `res.write`, Bun.serve streaming Response) lives in each shell;
+  // the SSE registry, the live-reload path predicate, the WS module loader, and
+  // the lifecycle wiring are shared via listener-core.js so the shells can't drift.
+  /** @type {import('./listener-types.js').ListenerContext} */
+  const ctx = { app, dev, compress, logger, hub, port, basePathStr: basePath(), timeouts, watcherAbort };
+
+  // Pick the adapter by runtime. Bun is Request/Response-native, so its shell
+  // skips the node:http bridge (toWebRequest/sendWebResponse) for ~1.9x more
+  // req/s on the listening path (#511); the Bun shell is dynamically imported so
+  // the `Bun.*` global is never referenced on Node.
+  if (serverRuntime() === 'bun') {
+    const { startBunListener } = await import('./listener-bun.js');
+    return startBunListener(ctx);
+  }
+  return startNodeListener(ctx);
+}
+
+/**
+ * The node:http listener shell: the original `startServer` socket path, now
+ * reading the shared `ListenerContext`. Bridges node `IncomingMessage` ->
+ * `Request` (`toWebRequest`) and `Response` -> `ServerResponse`
+ * (`sendWebResponse`), emits 103 Early Hints, and drives SSE + WS over node
+ * primitives, sharing the SSE registry + lifecycle wiring with the Bun shell.
+ * @param {import('./listener-types.js').ListenerContext} ctx
+ * @returns {{ server: import('node:http').Server, close: () => Promise<void> }}
+ */
+function startNodeListener(ctx) {
+  const { app, dev, compress, logger, hub, port, basePathStr, timeouts, watcherAbort } = ctx;
 
   const server = makeHttpServer(async (req, res) => {
     try {
@@ -1468,7 +1478,7 @@ export async function startServer(opts) {
       // base-path-stripped pathname so the reload stream answers at
       // `<basePath>/__webjs/events` under a sub-path deploy (#256). With no
       // basePath this is a pure pass-through (the bare path still matches).
-      if (stripBasePath(url.pathname, basePath()) === '/__webjs/events') {
+      if (stripBasePath(url.pathname, basePathStr) === '/__webjs/events') {
         if (!dev) { res.writeHead(404); res.end(); return; }
         res.writeHead(200, {
           'content-type': 'text/event-stream',
@@ -1476,7 +1486,13 @@ export async function startServer(opts) {
           connection: 'keep-alive',
         });
         res.write(`event: hello\ndata: webjs\n\n`);
-        sseClients.add(res);
+        // Register a node client wrapper in the shared hub: the fanout + keepalive
+        // live in SseHub; only the transport write (res.write / res.end) is local.
+        const client = {
+          send: (s) => { try { res.write(s); } catch {} },
+          close: () => { try { res.end(); } catch {} },
+        };
+        hub.add(client);
         // Replay an unresolved dev error (#264) so a tab that connects AFTER the
         // breaking edit (e.g. opened via a fresh navigation) still shows the
         // overlay, not only the tab that was open when the error fired.
@@ -1484,7 +1500,7 @@ export async function startServer(opts) {
         if (pending) {
           try { res.write(`event: webjs-error\ndata: ${JSON.stringify(pending)}\n\n`); } catch {}
         }
-        res.socket?.on('close', () => sseClients.delete(res));
+        res.socket?.on('close', () => hub.remove(client));
         return;
       }
 
@@ -1519,16 +1535,10 @@ export async function startServer(opts) {
     }
   });
 
-  // Inbound server timeouts (issue #237), node:http built-ins. Defends against
-  // slowloris and hung connections: `requestTimeout` bounds the time to receive
-  // the WHOLE request, `headersTimeout` the time to receive just the headers
-  // (node measures both from the same request start, so it is kept strictly
-  // under requestTimeout to actually fire), and `keepAliveTimeout` the idle
-  // window before a kept-alive socket is closed. Secure production defaults,
-  // overridable via `webjs.requestTimeoutMs` / `headersTimeoutMs` /
-  // `keepAliveTimeoutMs` in package.json or the matching WEBJS_*_MS env vars.
-  // A value of 0 disables that timeout (node's own no-limit sentinel).
-  const timeouts = await readServerTimeoutsFromApp(app.appDir);
+  // node:http built-in timeouts: `requestTimeout` bounds the time to receive the
+  // WHOLE request, `headersTimeout` just the headers (kept strictly under
+  // requestTimeout so it actually fires), `keepAliveTimeout` the idle window
+  // before a kept-alive socket is closed.
   server.requestTimeout = timeouts.requestTimeout;
   server.headersTimeout = timeouts.headersTimeout;
   server.keepAliveTimeout = timeouts.keepAliveTimeout;
@@ -1546,7 +1556,10 @@ export async function startServer(opts) {
     app.warmup();
   });
 
-  const shutdown = gracefulShutdown(server, sseClients, logger);
+  const closeServer = () => new Promise((resolve, reject) => {
+    server.close((err) => (err ? reject(err) : resolve(undefined)));
+  });
+  const shutdown = makeShutdown({ closeServer, hub, logger });
   process.once('SIGINT', () => shutdown('SIGINT'));
   process.once('SIGTERM', () => shutdown('SIGTERM'));
 
@@ -1559,6 +1572,9 @@ export async function startServer(opts) {
     server,
     close: () => new Promise((r) => {
       if (watcherAbort) watcherAbort.abort();
+      // Clear the shared SSE keepalive timer so repeated startServer/close cycles
+      // (e.g. across a test run) don't accumulate live intervals.
+      hub.closeAll();
       server.close(() => r());
     }),
   };
@@ -1963,54 +1979,6 @@ function makeHttpServer(handler) {
   return createHttp1Server(handler);
 }
 
-/**
- * Install once-only process error handlers. Idempotent across multiple
- * `startServer` calls in the same process.
- *
- * @param {import('./logger.js').Logger} logger
- * @param {() => void} onFatal
- */
-function installProcessHandlers(logger, onFatal) {
-  if (/** @type any */ (globalThis).__webjsProcHandlers) return;
-  /** @type any */ (globalThis).__webjsProcHandlers = true;
-  process.on('unhandledRejection', (reason) => {
-    logger.error('unhandledRejection', {
-      err: reason instanceof Error ? reason.stack || reason.message : String(reason),
-    });
-  });
-  process.on('uncaughtException', (err) => {
-    logger.error('uncaughtException', { err: err.stack || err.message });
-    // Begin orderly shutdown; process state may be corrupt.
-    try { onFatal(); } catch {}
-  });
-}
-
-function gracefulShutdown(server, sseClients, logger) {
-  let shuttingDown = false;
-  return (signal) => {
-    if (shuttingDown) return;
-    shuttingDown = true;
-    logger.info(`received ${signal}, shutting down`);
-    for (const res of sseClients) {
-      try { res.end(); } catch {}
-    }
-    sseClients.clear();
-    server.close((err) => {
-      if (err) {
-        logger.error('server close error', { err: String(err) });
-        process.exit(1);
-      }
-      logger.info('bye');
-      process.exit(0);
-    });
-    // Hard-fail after 10s if we can't drain.
-    setTimeout(() => {
-      logger.warn('shutdown timed out, forcing exit');
-      process.exit(1);
-    }, 10_000).unref();
-  };
-}
-
 /* ------------ helpers ------------ */
 
 /** @param {import('node:http').IncomingMessage} req @param {URL} url */
@@ -2068,21 +2036,18 @@ async function sendWebResponse(res, webRes, req, opts) {
     headers[k] = v;
   });
 
-  // Negotiate compression.
+  // Negotiate compression via the SHARED seam (listener-core.js), so the node and
+  // Bun shells negotiate + compress identically (brotli > gzip > deflate, node:zlib
+  // both sides). Skip a body that is already content-encoded (a route.ts returning
+  // pre-compressed bytes), and merge into any pre-existing `Vary` rather than
+  // clobbering it (`isCompressible` already excludes `text/event-stream`).
   let compressor = null;
-  if (opts?.compress && req && webRes.body && isCompressible(headers['content-type'])) {
-    const accept = String(req.headers['accept-encoding'] || '');
-    if (/(?:^|,\s*)br(?:;|,|$)/.test(accept)) {
-      compressor = createBrotliCompress({
-        params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 4 },
-      });
-      headers['content-encoding'] = 'br';
-    } else if (/(?:^|,\s*)gzip(?:;|,|$)/.test(accept)) {
-      compressor = createGzip({ level: 6 });
-      headers['content-encoding'] = 'gzip';
-    }
+  if (opts?.compress && req && webRes.body && !headers['content-encoding'] && isCompressible(headers['content-type'])) {
+    const encoding = negotiateEncoding(req.headers['accept-encoding']);
+    compressor = createCompressor(encoding);
     if (compressor) {
-      headers['vary'] = 'Accept-Encoding';
+      headers['content-encoding'] = encoding;
+      headers['vary'] = varyWithAcceptEncoding(typeof headers['vary'] === 'string' ? headers['vary'] : '');
       delete headers['content-length'];
     }
   }
@@ -2114,13 +2079,6 @@ async function sendWebResponse(res, webRes, req, opts) {
   res.end();
 }
 
-/** @param {string | string[] | undefined} contentType */
-function isCompressible(contentType) {
-  if (!contentType) return false;
-  const ct = Array.isArray(contentType) ? contentType[0] : contentType;
-  return /^(?:text\/|application\/(?:javascript|json|xml|wasm|manifest)|image\/svg\+xml)/i.test(ct);
-}
-
 /**
  * Read a file and return a Response with appropriate caching.
  * Dev: no-cache (always revalidate).
@@ -2201,12 +2159,16 @@ async function exists(p) {
  * rules catch these at edit time. There is no bundler fallback;
  * webjs is buildless end-to-end.
  *
+ * The backend is the runtime-appropriate stripper (#508): Node 24+'s built-in
+ * `module.stripTypeScriptTypes`, or `amaro` on Bun (byte-identical, equally
+ * position-preserving), resolved once via `./ts-strip.js`.
+ *
  * @param {string} source
  * @param {string} _abs  (unused; preserved for symmetry with prior signature)
  * @returns {Promise<string>}
  */
 async function stripTs(source, _abs) {
-  return nodeModule.stripTypeScriptTypes(source);
+  return stripTypeScript(source);
 }
 
 /**