fix(engine): keep capture diagnostics on stderr

.oxlintrc.json

@@ -24,7 +24,10 @@
         "packages/cli/src/capture/**/*.ts",
         "packages/cli/src/registry/**/*.ts",
         "packages/cli/src/templates/**/*.ts",
-        "packages/cli/src/telemetry/**/*.ts"
+        "packages/cli/src/telemetry/**/*.ts",
+        "packages/engine/src/services/browserManager.ts",
+        "packages/engine/src/services/frameCapture.ts",
+        "packages/engine/src/services/parallelCoordinator.ts"
       ],
       "excludeFiles": ["**/*.test.ts", "**/*.test.tsx", "packages/cli/src/telemetry/feedback.ts"],
       "rules": {

docs/packages/engine.mdx

@@ -86,6 +86,10 @@ These are rendering internals. Their result and error conventions differ by
 operation: browser and capture orchestration throws, FFmpeg wrappers generally
 return result objects, and teardown helpers avoid masking the original failure.
 
+Browser and frame-capture diagnostics, including motion-blur reports, go to
+stderr. This keeps stdout available for machine-readable results such as
+`hyperframes benchmark --json`.
+
 ## Related topics
 
 <CardGroup cols={2}>

packages/engine/src/services/browserManager.test.ts

@@ -1396,6 +1396,23 @@ describe("browser pool", () => {
     _setPuppeteerForTests(undefined);
   });
 
+  it("keeps the launch diagnostic on stderr when a command emits JSON", async () => {
+    const stdout = vi.spyOn(console, "log").mockImplementation(() => {});
+    const stderr = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const result = await acquireBrowser(["--no-sandbox"], poolCfg);
+      await result.release();
+
+      expect(stderr).toHaveBeenCalledWith(
+        expect.stringMatching(/^\[BrowserManager\] Browser launched/),
+      );
+      expect(stdout).not.toHaveBeenCalled();
+    } finally {
+      stdout.mockRestore();
+      stderr.mockRestore();
+    }
+  });
+
   it("sequential acquires with pool enabled return the same browser", async () => {
     const first = await acquireBrowser(["--no-sandbox"], poolCfg);
     const second = await acquireBrowser(["--no-sandbox"], poolCfg);

packages/engine/src/services/browserManager.ts

@@ -887,7 +887,7 @@ async function launchBrowser(
     const gpuFlags = fingerprint.args.filter(
       (a) => a.startsWith("--use-gl=") || a.startsWith("--use-angle="),
     );
-    console.log(
+    console.error(
       `[BrowserManager] Browser launched (${browserVersion}, ${captureMode}, gl=${gpuFlags.join(" ") || "default"}, headlessShell=${!!fingerprint.executablePath}, platform=${process.platform})`,
     );
 

packages/engine/src/services/frameCapture-motionBlur.test.ts

@@ -637,7 +637,7 @@ describe("a stall on a motion-blurred frame names the step in progress", () => {
 });
 
 describe("the per-session blur line", () => {
-  const log = () => vi.spyOn(console, "log").mockImplementation(() => {});
+  const log = () => vi.spyOn(console, "error").mockImplementation(() => {});
   const askForBlur = (report: object) => {
     const page = (globalThis as Record<string, unknown>).window as Record<string, unknown>;
     page.__hfMotionBlur = { report: () => report };
@@ -647,6 +647,7 @@ describe("the per-session blur line", () => {
 
   it("is logged once, after the session's first captured frame, from the page's report", async () => {
     const spy = log();
+    const stdout = vi.spyOn(console, "log").mockImplementation(() => {});
     askForBlur({ state: "on", reasonCode: null, movers: 4, failedFrames: 0 });
     const session = makeSession({ motionBlur: undefined });
     await captureFrameToBuffer(session, 0, 0);
@@ -656,6 +657,7 @@ describe("the per-session blur line", () => {
       .map(([line]) => line)
       .filter((l) => `${l}`.includes("[motion-blur]"));
     expect(lines).toEqual(["[motion-blur] on reasonCode=null movers=4 failedFrames=0"]);
+    expect(stdout).not.toHaveBeenCalled();
   });
 
   it("says why blur is off for the session", async () => {

packages/engine/src/services/frameCapture.test.ts

@@ -186,6 +186,41 @@ describe("classifyPageError", () => {
     return { session, pageListeners, runtimeListeners };
   }
 
+  it("keeps browser diagnostics on stderr and in the session buffer", async () => {
+    const stdout = vi.spyOn(console, "log").mockImplementation(() => {});
+    const stderr = vi.spyOn(console, "error").mockImplementation(() => {});
+    try {
+      const { session, pageListeners } = await listenedSession();
+      const emit = (type: string, text: string, url = "") =>
+        pageListeners.get("console")?.({
+          type: () => type,
+          text: () => text,
+          location: () => ({ url }),
+        });
+      emit("info", "[hyperframes] render runtime fps");
+      emit("warn", "GPU readback warning");
+      emit("error", "[HyperFrames] composition script error: scene TypeError: x");
+      emit("error", "Failed to load resource", "https://fonts.gstatic.com/font.woff2");
+
+      expect(stderr.mock.calls).toEqual([
+        ["[HyperFrames] render runtime fps"],
+        ["[Browser:WARN] GPU readback warning"],
+        ["[Browser:ERROR] [HyperFrames] composition script error: scene TypeError: x"],
+      ]);
+      expect(stdout).not.toHaveBeenCalled();
+      expect(session.browserConsoleBuffer).toEqual([
+        "[HyperFrames] render runtime fps",
+        "[Browser:WARN] GPU readback warning",
+        "[Browser:ERROR] [HyperFrames] composition script error: scene TypeError: x",
+        "[Browser] Failed to load resource",
+      ]);
+      expect(session.pageErrors).toEqual(["runtime-error:scene TypeError: x"]);
+    } finally {
+      stdout.mockRestore();
+      stderr.mockRestore();
+    }
+  });
+
   it("records the page's uncaught errors from scripts it loaded from the server", async () => {
     const { session, pageListeners, runtimeListeners } = await listenedSession();
     const loaded = (url: string, resourceType: string) => ({
@@ -227,7 +262,7 @@ describe("classifyPageError", () => {
   it("logs a scene callback error once per render, and never as a page error", async () => {
     const memo: SubTimelineWaitMemo = {};
     const sessions = [await listenedSession(memo), await listenedSession(memo)];
-    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const log = vi.spyOn(console, "error").mockImplementation(() => {});
     const text = `${SCENE_CALLBACK_ERROR_PREFIX} "scene" TypeError: x`;
     for (const { pageListeners } of sessions) {
       for (let i = 0; i < 2; i++) {

packages/engine/src/services/frameCapture.ts

@@ -985,15 +985,15 @@ async function initDrawElementOrTransparentBackground(
   if ((session.config?.useDrawElement ?? false) && supersampling) {
     session.deGateReason = "supersampling";
     session.deFallbackTrigger = "supersampling";
-    console.log(
+    console.error(
       "[engine] --experimental-fast-capture disabled for this render: drawElementImage " +
         "ignores deviceScaleFactor, so scaled (DPR other than 1) output uses screenshot capture.",
     );
   }
   if ((session.config?.useDrawElement ?? false) && !supersampling && forceScreenshot) {
     session.deGateReason = "render_mode_hint";
     session.deFallbackTrigger = "render_mode_hint";
-    console.log(
+    console.error(
       "[engine] fast capture falls back to screenshot: render-mode compatibility " +
         "hint forced screenshot capture (e.g. raw requestAnimationFrame composition).",
     );
@@ -1045,7 +1045,7 @@ async function initDrawElementOrTransparentBackground(
     if (!supportsDrawElement) {
       session.deGateReason = "unsupported_chrome";
       session.deFallbackTrigger = "unsupported_chrome";
-      console.log(
+      console.error(
         `[engine] fast capture falls back to ${session.launchCaptureMode} capture: ` +
           "this Chrome build does not implement canvas.drawElementImage (Dev/Canary-only " +
           "feature); run `hyperframes browser ensure --force` to fetch a supported " +
@@ -1097,7 +1097,7 @@ async function initDrawElementOrTransparentBackground(
       // "screenshot": on a BeginFrame-launched browser (Linux fast capture)
       // Page.captureScreenshot hangs for the full protocol timeout, while
       // beginFrameCapture is the platform's normal baseline path.
-      console.log(
+      console.error(
         `[engine] fast capture falls back to ${session.launchCaptureMode} capture: ` +
           "SwiftShader (software rasterizer, no GPU egress to skip, drawElement is " +
           "parity-or-slower; see fast-capture-limitations.md)",
@@ -1121,7 +1121,7 @@ async function initDrawElementOrTransparentBackground(
       const routeWholeRender = async (reason: string, trigger: string, message: string) => {
         session.deGateReason = reason;
         session.deFallbackTrigger = trigger;
-        console.log(
+        console.error(
           `[engine] fast capture falls back to ${session.launchCaptureMode} capture: ${message}`,
         );
         await routeToFallback();
@@ -1222,7 +1222,7 @@ async function initDrawElementOrTransparentBackground(
       if (!forceDE && !threeD.ok) {
         session.deGateReason = "3d_init_failed";
         session.deFallbackTrigger = "3d_init_failed";
-        console.log(
+        console.error(
           `[engine] fast capture falls back to ${session.launchCaptureMode} capture: ` +
             `3D projection init failed (${threeD.reason ?? "unknown"})`,
         );
@@ -1305,7 +1305,7 @@ async function cssEffectRiskFrames(
     );
     return live && withFramesAfterCallback(live, scan.callbackFrom, fps, totalFrames);
   } catch (error) {
-    console.log(
+    console.error(
       `[engine] fast capture: effect scan failed (${error instanceof Error ? error.message : String(error)})`,
     );
     return null;
@@ -1386,7 +1386,7 @@ export async function completeDeferredDrawElementInit(session: CaptureSession):
   if (!session.deInitDeferred || !session.onBeforeCapture) return;
   const page = session.page;
   const logInitPhase = (phase: string) =>
-    console.log(`[initSession:${session.captureMode}] ${phase} (deferred drawElement init)`);
+    console.error(`[initSession:${session.captureMode}] ${phase} (deferred drawElement init)`);
   await finalizeDrawElementInit(session, page, logInitPhase, {
     transparent: session.options.format === "png",
     forceDE: process.env.HF_FORCE_DRAWELEMENT === "1",
@@ -2654,14 +2654,14 @@ export async function initializeSession(session: CaptureSession): Promise<void>
   const { page, serverUrl } = session;
 
   // Forward browser console to host. HyperFrames runtime logs get a dedicated
-  // prefix so page-context observability is visible in producer stdout.
+  // prefix so page-context observability is visible in producer stderr.
   page.on("console", (msg: ConsoleMessage) => {
     const type = msg.type();
     const text = msg.text();
     const locationUrl = msg.location()?.url ?? "";
     const diagnostic = formatConsoleDiagnostic(type, text, locationUrl);
     if (!diagnostic.suppressHostLog && !loggedEarlierInRender(session, text)) {
-      console.log(diagnostic.text);
+      console.error(diagnostic.text);
     }
     appendBrowserDiagnostic(session, diagnostic.text);
 
@@ -2738,7 +2738,7 @@ export async function initializeSession(session: CaptureSession): Promise<void>
     session.config?.pageNavigationTimeout ?? DEFAULT_CONFIG.pageNavigationTimeout;
   const initStart = Date.now();
   const logInitPhase = (phase: string) => {
-    console.log(`[initSession:${session.captureMode}] ${phase} (${Date.now() - initStart}ms)`);
+    console.error(`[initSession:${session.captureMode}] ${phase} (${Date.now() - initStart}ms)`);
   };
   const gotoEntryPage = async (): Promise<void> => {
     appendBrowserDiagnostic(
@@ -4684,7 +4684,7 @@ async function captureFrameCore(
     session.capturePerf.frameMs.push(captureTimeMs);
     if (session.capturePerf.frames === 1) {
       const blur = await describePageMotionBlur(session.page).catch(() => null);
-      if (blur) console.log(blur);
+      if (blur) console.error(blur);
     }
 
     // Retain this freshly-captured buffer so the following static frames can reuse it.
@@ -4774,7 +4774,7 @@ export async function captureFrameToBuffer(
             // works. Counted here rather than in captureFrameCore's catch: the
             // deadline rejects from outside it, so that catch never runs.
             session.deFrameTimeouts = (session.deFrameTimeouts ?? 0) + 1;
-            console.log(
+            console.error(
               `[engine] fast capture frame ${frameIndex}: capture exceeded ` +
                 `${DE_FRAME_TIMEOUT_MS}ms; renderer stalled after drawElementImage ` +
                 `(PRINFRA-488). Failing the drawElement attempt so the whole render ` +
@@ -5037,7 +5037,7 @@ export async function captureFramesBatchPipelined(
       session.deNcprFallbacks = (session.deNcprFallbacks ?? 0) + 1;
       throw new DrawElementCaptureError(frameIndices[failedAt] ?? failedAt, reason, error);
     } else {
-      console.log(
+      console.error(
         `[engine] fast capture: batch produce failed at frame ` +
           `${frameIndices[failedAt] ?? "?"} (${error ?? "?"}); ` +
           `re-capturing ${frameIndices.length - failedAt} frame(s) per-frame`,
@@ -5136,7 +5136,7 @@ export async function closeCaptureSession(session: CaptureSession): Promise<void
   }
   if (session.page && !session.pageReleased) {
     const blur = await describePageMotionBlurAtEnd(session.page);
-    if (blur) console.log(blur);
+    if (blur) console.error(blur);
   }
   // Realized static-dedup telemetry: how much the cache actually helped this
   // render (vs the prediction logged at arm time). Both capture paths
@@ -5149,7 +5149,7 @@ export async function closeCaptureSession(session: CaptureSession): Promise<void
     const total = captured + reused;
     const pct = total > 0 ? Math.round((reused / total) * 100) : 0;
     const avgTotalMs = captured > 0 ? Math.round(session.capturePerf.totalMs / captured) : 0;
-    console.log(
+    console.error(
       `[static-dedup] reused ${reused}/${total} frame(s) (${pct}%), ` +
         `est. ~${reused * avgTotalMs}ms saved (avg ${avgTotalMs}ms/frame)`,
     );

packages/engine/src/services/pageMotionBlur.test.ts

@@ -163,7 +163,8 @@ describe("closeCaptureSession", () => {
   afterEach(() => vi.restoreAllMocks());
 
   it("logs the blur's closing line once, before the page closes", async () => {
-    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const log = vi.spyOn(console, "error").mockImplementation(() => {});
+    const stdout = vi.spyOn(console, "log").mockImplementation(() => {});
     const order: string[] = [];
     vi.stubGlobal("window", {
       __hfMotionBlur: {
@@ -188,6 +189,7 @@ describe("closeCaptureSession", () => {
       "[motion-blur] on reasonCode=null movers=1 failedFrames=2 (session end)",
     ]);
     expect(order).toEqual(["read", "close"]);
+    expect(stdout).not.toHaveBeenCalled();
     vi.unstubAllGlobals();
   });
 });

packages/engine/src/services/parallelCoordinator.ts

@@ -611,7 +611,7 @@ async function captureFrameRange(
       if (signal?.aborted) throw new Error("Parallel worker cancelled");
       const time = (i * captureOptions.fps.den) / captureOptions.fps.num;
       if (dbg && i < task.startFrame + dbgWin) {
-        console.log(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms produce ${i} start`);
+        console.error(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms produce ${i} start`);
       }
       const { encodeResult } = await runCaptureOperation("frame_capture", i, () =>
         captureFrameToBufferPipelined(session, i - outputOffset, time),
@@ -623,23 +623,25 @@ async function captureFrameRange(
       // and would otherwise surface as an unhandled rejection during teardown.
       encodeResult.catch(() => {});
       if (dbg && i < task.startFrame + dbgWin) {
-        console.log(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms produce ${i} kicked`);
+        console.error(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms produce ${i} kicked`);
       }
       if (prev) {
         if (dbg && prev.idx < task.startFrame + dbgWin) {
-          console.log(
+          console.error(
             `[par:w${task.workerId}] +${Date.now() - dbgT0}ms drain ${prev.idx} await-encode`,
           );
         }
         const buf = await awaitEncode(prev.idx, prev.encodeResult);
         if (dbg && prev.idx < task.startFrame + dbgWin) {
-          console.log(
+          console.error(
             `[par:w${task.workerId}] +${Date.now() - dbgT0}ms drain ${prev.idx} encoded ${buf.length}B`,
           );
         }
         await onFrameBuffer(prev.idx, buf, session);
         if (dbg && prev.idx < task.startFrame + dbgWin) {
-          console.log(`[par:w${task.workerId}] +${Date.now() - dbgT0}ms drain ${prev.idx} written`);
+          console.error(
+            `[par:w${task.workerId}] +${Date.now() - dbgT0}ms drain ${prev.idx} written`,
+          );
         }
         framesCaptured++;
         if (onFrameCaptured) onFrameCaptured(task.workerId, prev.idx);
@@ -714,7 +716,7 @@ export function selectVerifySampleIndicesForTask(
  */
 /** HF_DE_PAR_DEBUG=1 gated per-worker trace line (message built lazily). */
 function logParDebug(message: () => string): void {
-  if (process.env.HF_DE_PAR_DEBUG === "1") console.log(message());
+  if (process.env.HF_DE_PAR_DEBUG === "1") console.error(message());
 }
 
 /**
@@ -736,7 +738,7 @@ function assertDiskSampleAboveFloor(
       { kind: "psnr", frameIndex: idx, failedDb: db, verifyThresholdDb: verifyMinDb },
     );
   }
-  console.log(
+  console.error(
     `[Parallel] drawElement disk self-verify passed (worker ${workerId}, frame ${idx}, ` +
       `${db === Infinity ? "inf" : db.toFixed(1)}dB)`,
   );