fix: address review feedback on the CPU benchmark harness

Settle in-flight CDP requests when the inspector socket closes or errors, and
guard the message parse. A webapp that exited mid-run previously left every
send() pending, so the bench hung until the suite timeout with nothing
explaining why; a parse throw inside the listener surfaced as an
uncaughtException and tore down the runner. send() now also rejects instead of
hanging when the socket is already closed.

Unref both event-loop-utilization interval timers so a throw between start and
stop cannot keep a vitest worker alive.

Make eventLoopUtilizationMonitor.enable() idempotent: a second call previously
started another interval and overwrote the only stored cleanup callback,
leaking the first.

Validate --top in the profile analyzer. A non-numeric value produced NaN, and
slice(0, NaN) silently printed empty tables that looked like an empty profile.

Keep the release note behavioural, without the env var name.

Author: ericallam

.server-changes/reduce-webapp-cpu-on-worker-routes.md

@@ -3,4 +3,4 @@ area: webapp
 type: improvement
 ---
 
-Cut webapp CPU usage by about a quarter on the routes that workers call most, freeing headroom at the same request rate. Detailed event-loop blocking diagnostics are now off by default (set `EVENT_LOOP_MONITOR_ENABLED=1` to restore them); the event-loop utilization metric is unaffected.
+Cut webapp CPU usage by about a quarter on the routes that workers call most, freeing headroom at the same request rate. Detailed event-loop blocking traces are no longer recorded by default, because producing them was itself a large part of that cost.

apps/webapp/app/eventLoopMonitor.server.ts

@@ -123,6 +123,10 @@ export const eventLoopUtilizationMonitor = singleton("eventLoopUtilizationMonito
 
   return {
     enable: () => {
+      if (stop) {
+        return;
+      }
+
       console.log("🥸  Initializing event loop utilization monitor");
 
       stop = startEventLoopUtilizationMonitoring();

apps/webapp/test/bench/analyzeProfile.ts

@@ -31,8 +31,15 @@ function parseArgs(argv: string[]): {
 
   for (let i = 0; i < argv.length; i++) {
     const arg = argv[i]!;
-    if (arg === "--top") top = Number(argv[++i]);
-    else if (arg === "--json") json = argv[++i];
+    if (arg === "--top") {
+      const raw = argv[++i];
+      const parsed = Number(raw);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        console.error(`--top expects a positive number, got "${raw ?? ""}"`);
+        process.exit(1);
+      }
+      top = parsed;
+    } else if (arg === "--json") json = argv[++i];
     else if (arg === "--root") root = resolve(argv[++i]!);
     else if (!arg.startsWith("--")) profilePath = arg;
   }

apps/webapp/test/bench/lib/cdp.ts

@@ -68,17 +68,37 @@ class CdpSession {
   private nextId = 1;
   private pending = new Map<number, { resolve: (v: any) => void; reject: (e: Error) => void }>();
 
+  /**
+   * Anything that ends the socket has to settle the in-flight requests. If the
+   * profiled webapp exits mid-run, an unsettled `send()` would otherwise hang
+   * until the suite-level timeout with nothing explaining why.
+   */
   private constructor(ws: WebSocket) {
     this.ws = ws;
     this.ws.on("message", (data) => {
-      const msg = JSON.parse(data.toString()) as CdpMessage;
+      let msg: CdpMessage;
+      try {
+        msg = JSON.parse(data.toString()) as CdpMessage;
+      } catch {
+        return;
+      }
       if (msg.id === undefined) return;
       const waiter = this.pending.get(msg.id);
       if (!waiter) return;
       this.pending.delete(msg.id);
       if (msg.error) waiter.reject(new Error(`${msg.error.message} (${msg.error.code})`));
       else waiter.resolve(msg.result);
     });
+
+    const rejectAll = (reason: string) => {
+      for (const waiter of this.pending.values()) {
+        waiter.reject(new Error(reason));
+      }
+      this.pending.clear();
+    };
+
+    this.ws.on("error", (err: Error) => rejectAll(`CDP socket error: ${err.message}`));
+    this.ws.on("close", () => rejectAll("CDP socket closed before the response arrived"));
   }
 
   /**
@@ -96,6 +116,10 @@ class CdpSession {
   }
 
   send<T = any>(method: string, params: Record<string, unknown> = {}): Promise<T> {
+    if (this.ws.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error(`CDP socket is not open, cannot send ${method}`));
+    }
+
     const id = this.nextId++;
     const promise = new Promise<T>((resolve, reject) => {
       this.pending.set(id, { resolve, reject });
@@ -155,13 +179,16 @@ export class WebappProfiler {
 
     void this.evaluateElu();
 
-    this.eluTimer = setInterval(() => {
+    const timer = setInterval(() => {
       void this.evaluateElu().then((utilization) => {
         if (utilization !== undefined) {
           this.eluSamples.push({ atMs: Date.now() - this.eluStartedAt, utilization });
         }
       });
     }, intervalMs);
+
+    timer.unref();
+    this.eluTimer = timer;
   }
 
   /**

internal-packages/run-engine/src/engine/bench/inspectorProfiler.ts

@@ -97,12 +97,15 @@ export class InProcessProfiler {
     this.eluSamples = [];
     this.lastElu = performance.eventLoopUtilization();
 
-    this.eluTimer = setInterval(() => {
+    const timer = setInterval(() => {
       const current = performance.eventLoopUtilization();
       const diff = performance.eventLoopUtilization(current, this.lastElu!);
       this.lastElu = current;
       this.eluSamples.push(Number.isFinite(diff.utilization) ? diff.utilization : 0);
     }, intervalMs);
+
+    timer.unref();
+    this.eluTimer = timer;
   }
 
   stopEluSampling(): EluStats {