@zerotal/monitor 1.0.0

package/src/alerting.ts

@@ -0,0 +1,173 @@
+/**
+ * Threshold-based alerting over the live snapshot. The provider evaluates these
+ * on a short interval; a newly-firing alert is logged, recorded (so it shows in
+ * the panel), and dispatched to any handlers registered via {@link onAlert} —
+ * wire those to `@zerotal/notifications`, Slack, PagerDuty, etc.
+ *
+ * Alerts are edge-triggered: each fires once when it crosses its threshold and
+ * resets when it recovers, so handlers aren't spammed every tick.
+ */
+import type { MonitorSnapshot } from "./store/types.ts";
+
+export interface AlertThresholds {
+  /** Fire when the 5xx rate exceeds this %. Default: 5. */
+  errorRatePct?: number;
+  /** Fire when pending jobs across queues exceed this. Default: 500. */
+  queuePending?: number;
+  /** Fire when p95 latency exceeds this many ms. Default: 2000. */
+  p95Ms?: number;
+  /** Fire when transaction rollbacks in the window exceed this. Default: 10. */
+  rolledBackInWindow?: number;
+}
+
+export interface AlertNotice {
+  id: string;
+  level: "warning" | "critical";
+  title: string;
+  detail: string;
+  /** Human label for the breaching metric, e.g. "p95 latency". */
+  metric: string;
+  /** Observed value at firing time. */
+  value: number;
+  /** Configured threshold it crossed. */
+  threshold: number;
+  /** Unit for value/threshold: "ms" | "%" | "". */
+  unit: string;
+}
+
+const DEFAULTS: Required<AlertThresholds> = {
+  errorRatePct: 5,
+  queuePending: 500,
+  p95Ms: 2000,
+  rolledBackInWindow: 10,
+};
+
+/** Evaluate the snapshot against thresholds; returns the currently-breaching alerts. */
+export function evaluateAlerts(
+  snap: MonitorSnapshot,
+  thresholds: AlertThresholds = {},
+): AlertNotice[] {
+  const t = { ...DEFAULTS, ...thresholds };
+  const out: AlertNotice[] = [];
+
+  const errCard = snap.statCards.find((c) => c.label === "Error rate");
+  const errRate = errCard ? parseFloat(errCard.value) || 0 : 0;
+  if (errRate > t.errorRatePct) {
+    out.push({
+      id: "error-rate",
+      level: errRate > t.errorRatePct * 2 ? "critical" : "warning",
+      title: "Elevated error rate",
+      detail: `${errRate.toFixed(1)}% of requests are 5xx (threshold ${t.errorRatePct}%).`,
+      metric: "error rate",
+      value: +errRate.toFixed(1),
+      threshold: t.errorRatePct,
+      unit: "%",
+    });
+  }
+
+  const p95 = snap.percentiles.find((p) => p.label === "p95")?.value ?? 0;
+  if (p95 > t.p95Ms) {
+    out.push({
+      id: "p95-latency",
+      level: p95 > t.p95Ms * 2 ? "critical" : "warning",
+      title: "Slow responses",
+      detail: `p95 latency is ${p95}ms (threshold ${t.p95Ms}ms).`,
+      metric: "p95 latency",
+      value: p95,
+      threshold: t.p95Ms,
+      unit: "ms",
+    });
+  }
+
+  const pending = snap.queues.reduce((a, q) => a + q.pending, 0);
+  if (pending > t.queuePending) {
+    out.push({
+      id: "queue-backlog",
+      level: "warning",
+      title: "Queue backlog",
+      detail: `${pending} jobs pending across ${snap.queues.length} queues (threshold ${t.queuePending}).`,
+      metric: "pending jobs",
+      value: pending,
+      threshold: t.queuePending,
+      unit: "",
+    });
+  }
+
+  if (snap.transactions.rolledBack > t.rolledBackInWindow) {
+    out.push({
+      id: "tx-rollbacks",
+      level: "warning",
+      title: "Transaction rollbacks",
+      detail: `${snap.transactions.rolledBack} rollbacks in the window (threshold ${t.rolledBackInWindow}).`,
+      metric: "rollbacks",
+      value: snap.transactions.rolledBack,
+      threshold: t.rolledBackInWindow,
+      unit: "",
+    });
+  }
+
+  return out;
+}
+
+/**
+ * Decide which currently-breaching alerts should actually fire now.
+ *
+ * Edge-triggered + cooldown: an alert fires when it first crosses its threshold,
+ * and won't fire again within `cooldownMs` even if it recovers and re-breaches.
+ * This stops an oscillating metric (e.g. p95 hovering around the limit) from
+ * paging an operator — or flooding the feed — every time it dips back over.
+ *
+ * Mutates `firing` (the in-flight episode set) and `lastFired` (id → timestamp)
+ * in place, and returns the subset of `active` to record/dispatch. Pass `now` so
+ * the decision is deterministic and testable; `cooldownMs <= 0` disables cooldown
+ * (re-fire on every fresh breach).
+ */
+export function alertsToFire(
+  active: AlertNotice[],
+  firing: Set<string>,
+  lastFired: Map<string, number>,
+  now: number,
+  cooldownMs: number,
+): AlertNotice[] {
+  const toFire: AlertNotice[] = [];
+  for (const a of active) {
+    if (firing.has(a.id)) continue; // already firing this episode
+    firing.add(a.id);
+    const last = lastFired.get(a.id);
+    // Suppress only when it HAS fired before and is still within the cooldown.
+    if (last !== undefined && cooldownMs > 0 && now - last < cooldownMs) continue;
+    lastFired.set(a.id, now);
+    toFire.push(a);
+  }
+  return toFire;
+}
+
+// ── Handler registry ────────────────────────────────────────────────────────────
+
+type AlertHandler = (alert: AlertNotice) => void | Promise<void>;
+const _handlers: AlertHandler[] = [];
+
+/**
+ * Register a handler called once whenever a monitor alert fires. Returns an
+ * unsubscribe function. Wire it to notifications:
+ *
+ *   onAlert((a) => Notification.route("slack", SLACK_URL).notify(new MonitorAlert(a)));
+ */
+export function onAlert(fn: AlertHandler): () => void {
+  _handlers.push(fn);
+  return () => {
+    const i = _handlers.indexOf(fn);
+    if (i >= 0) _handlers.splice(i, 1);
+  };
+}
+
+/** @internal — fan an alert out to registered handlers (errors swallowed). */
+export function _dispatchAlert(alert: AlertNotice): void {
+  for (const h of _handlers) {
+    try {
+      void h(alert);
+    } catch {
+      /* a handler must never break alerting */
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,171 @@
+/**
+ * Configuration for `@zerotal/monitor`, authored in `config/monitor.ts`:
+ *
+ *   import { MonitorConfig } from "@zerotal/monitor";
+ *   export default MonitorConfig({
+ *     path: "/monitor",
+ *     auth: (user) => user?.role === "admin",
+ *   });
+ */
+import { deepMerge, isDevSurfaceAllowed } from "@zerotal/core";
+import type { RetentionMode } from "./store/MonitorDb.ts";
+import type { AlertThresholds } from "./alerting.ts";
+
+export interface MonitorConfigShape {
+  /** URL prefix the panel mounts at. Default: `/monitor`. */
+  path?: string;
+  /** Browser tab title / sidebar heading. Default: `Super Panel`. */
+  title?: string;
+  /** Sub-label under the title. Default: `Zerotal Ops`. */
+  subtitle?: string;
+  /**
+   * Authorization gate. Receives the authenticated user (or undefined) and
+   * must return true to allow access. Default: allow only outside production.
+   */
+  auth?: (user: unknown) => boolean | Promise<boolean>;
+  /** Install the recorder middleware to capture live request data. Default: true. */
+  record?: boolean;
+  /** Auto-refresh cadence in milliseconds while "Live" is on. Default: 3000. */
+  refreshMs?: number;
+  /** Apdex satisfaction threshold (T) in ms. Default: 100. */
+  apdexTargetMs?: number;
+  /** Queries at/above this many ms count as "slow". Default: 100. */
+  slowQueryMs?: number;
+  /** Requests at/above this many ms count as "slow" (Slow Requests widget). Default: 1000. */
+  slowRequestMs?: number;
+  /**
+   * Capture request/response headers and bodies on each request (Telescope-style),
+   * shown in the request trace. Off by default — it buffers bodies and is
+   * privacy-sensitive. Sensitive headers (authorization/cookie) and body keys
+   * (password/token/secret/…) are redacted automatically.
+   */
+  capturePayloads?: boolean;
+  /** Truncate captured request/response bodies to this many bytes. Default: 65536. */
+  payloadMaxBytes?: number;
+  /**
+   * Cache built snapshots for this many ms, keyed by range, so overlapping reads
+   * (panel poll + Prometheus scrape + alert loop) share one build. Mutating actions
+   * invalidate it. Default: 1000. Set `0` to always build fresh.
+   */
+  snapshotCacheMs?: number;
+  /**
+   * SQLite file the panel persists to, so history survives restarts and the
+   * 1h/24h/7d ranges trace real data. Default: `storage/monitor.sqlite`. Use
+   * `:memory:` for an ephemeral, in-process store.
+   */
+  storage?: string;
+  /** Days of history to keep before pruning. Default: 7. */
+  retentionDays?: number;
+  /** What to do with data past retention: `delete` it or `archive` it. Default: `delete`. */
+  retentionMode?: RetentionMode;
+  /**
+   * Expose a Prometheus text-exposition endpoint. Default: `false` (opt-in).
+   * The endpoint is unauthenticated (a scraper can't satisfy user-auth), so it
+   * ships off; enable it only when you protect `metricsPath` at the network
+   * layer (firewall/ingress) or scope it to a private interface.
+   */
+  metrics?: boolean;
+  /** Path for the Prometheus endpoint. Default: `/metrics`. Protect it at the network layer. */
+  metricsPath?: string;
+  /** Evaluate threshold alerts on a short interval. Default: `true`. */
+  alerts?: boolean;
+  /** Alert thresholds (error rate, queue backlog, p95, rollbacks). */
+  alertThresholds?: AlertThresholds;
+  /**
+   * Minimum gap (ms) before the same alert can fire again after it recovers and
+   * re-breaches. Stops an oscillating metric from re-paging / re-flooding the feed
+   * for one ongoing issue. Default: 30 min. Set `0` to fire on every fresh breach.
+   */
+  alertCooldownMs?: number;
+  /**
+   * Slack-compatible webhook URL. When set, every newly-firing alert is POSTed to
+   * it as JSON (`{ text, level, title, detail }`) so alerts page someone instead of
+   * only lighting up the panel. Dependency-free (uses `fetch`); delivery is
+   * best-effort. For richer routing, register a handler with `onAlert()` instead.
+   */
+  alertWebhook?: string;
+  /** Accent colour (hex) for the panel chrome. Default: Zerotal orange. */
+  accent?: string;
+  /** Version string shown in the System footer. */
+  zerotalVersion?: string;
+  /** Region label shown in the System footer. */
+  region?: string;
+  /** Deploy SHA shown in the System footer. */
+  deploy?: string;
+  /**
+   * Switch contributed sections off by id — `{ scheduler: false }` keeps the
+   * scheduler installed but drops its section from the panel. Anything absent
+   * here is on.
+   */
+  sections?: Record<string, boolean>;
+}
+
+export interface ResolvedMonitorConfig extends MonitorConfigShape {
+  path: string;
+  title: string;
+  subtitle: string;
+  record: boolean;
+  refreshMs: number;
+  apdexTargetMs: number;
+  slowQueryMs: number;
+  slowRequestMs: number;
+  snapshotCacheMs: number;
+  storage: string;
+  retentionDays: number;
+  retentionMode: RetentionMode;
+  metrics: boolean;
+  metricsPath: string;
+  alerts: boolean;
+  alertCooldownMs: number;
+  capturePayloads: boolean;
+  payloadMaxBytes: number;
+  accent: string;
+  /** Always set after MonitorConfig() applies defaults. */
+  auth: (user: unknown) => boolean | Promise<boolean>;
+}
+
+// The default gate keys off the framework's own APP_ENV (via the shared
+// fail-closed predicate), NOT NODE_ENV — which Bun leaves unset, so a
+// documented `APP_ENV=production` deploy would otherwise expose the panel.
+// Only explicitly non-prod envs get open-by-default access; everything else
+// (unset, staging, production) must supply an explicit `auth` predicate.
+const defaultAuthOpen = (): boolean => isDevSurfaceAllowed(Bun.env["APP_ENV"] ?? "");
+
+const defaults: ResolvedMonitorConfig = {
+  path: "/monitor",
+  title: "Super Panel",
+  subtitle: "Zerotal Ops",
+  record: true,
+  refreshMs: 3000,
+  apdexTargetMs: 100,
+  slowQueryMs: 100,
+  slowRequestMs: 1000,
+  snapshotCacheMs: 1000,
+  storage: "storage/monitor.sqlite",
+  retentionDays: 7,
+  retentionMode: "delete",
+  metrics: false,
+  metricsPath: "/metrics",
+  alerts: true,
+  alertCooldownMs: 30 * 60 * 1000,
+  capturePayloads: false,
+  payloadMaxBytes: 65536,
+  accent: "#f97316",
+  // deepMerge can't carry a function through, so MonitorConfig() reattaches the
+  // real predicate; this default keeps the type honest and is the prod-safe gate.
+  auth: () => defaultAuthOpen(),
+};
+
+export function MonitorConfig(options: Partial<MonitorConfigShape> = {}): ResolvedMonitorConfig {
+  const merged = deepMerge(defaults, options) as ResolvedMonitorConfig;
+  // deepMerge can't carry a function through; reattach the auth callback.
+  if (options.auth) merged.auth = options.auth;
+  else if (!merged.auth) merged.auth = () => defaultAuthOpen();
+  return merged;
+}
+
+declare module "@zerotal/core" {
+  interface ConfigRegistry {
+    monitor: MonitorConfigShape;
+  }
+}

package/src/facades/Monitor.ts

@@ -0,0 +1,75 @@
+/**
+ * The `Monitor` facade — a thin, always-available entry point for feeding the
+ * monitoring store from application code. Use it to record data the recorder
+ * middleware can't see automatically (SQL queries, outgoing HTTP calls, cache
+ * hits, sent mail, deploys):
+ *
+ *   import { Monitor } from "@zerotal/monitor";
+ *   Monitor.recordQuery({ sql, ms, location: "PostController@index" });
+ *   Monitor.recordHttp({ host: "api.stripe.com", ms: 412 });
+ *   Monitor.recordCache(hit, key);
+ *   Monitor.recordMail({ subject, to, mailer, status: "sent", ms, body });
+ *
+ * Every method is a no-op if the monitor provider hasn't booted, so it's safe
+ * to call unconditionally.
+ */
+import { RequestContext } from "@zerotal/core";
+import { _getStore } from "../instance.ts";
+import { addContext } from "../recorder/ctxBuffers.ts";
+import type { MonitorStore } from "../MonitorStore.ts";
+
+type StoreMethods = Pick<
+  MonitorStore,
+  | "recordRequest"
+  | "recordException"
+  | "recordQuery"
+  | "recordHttp"
+  | "recordCache"
+  | "recordMail"
+  | "recordDeploy"
+  | "recordJob"
+  | "snapshot"
+>;
+
+function call<K extends keyof StoreMethods>(
+  method: K,
+  ...args: Parameters<StoreMethods[K]>
+): ReturnType<StoreMethods[K]> | undefined {
+  const store = _getStore();
+  if (!store) return undefined;
+
+  return (store[method] as (...a: unknown[]) => unknown)(...args) as ReturnType<StoreMethods[K]>;
+}
+
+export const Monitor = {
+  recordRequest: (...a: Parameters<MonitorStore["recordRequest"]>) => call("recordRequest", ...a),
+  recordException: (...a: Parameters<MonitorStore["recordException"]>) =>
+    call("recordException", ...a),
+  recordQuery: (...a: Parameters<MonitorStore["recordQuery"]>) => call("recordQuery", ...a),
+  recordHttp: (...a: Parameters<MonitorStore["recordHttp"]>) => call("recordHttp", ...a),
+  recordCache: (...a: Parameters<MonitorStore["recordCache"]>) => call("recordCache", ...a),
+  recordMail: (...a: Parameters<MonitorStore["recordMail"]>) => call("recordMail", ...a),
+  recordDeploy: (...a: Parameters<MonitorStore["recordDeploy"]>) => call("recordDeploy", ...a),
+  recordJob: (...a: Parameters<MonitorStore["recordJob"]>) => call("recordJob", ...a),
+  /**
+   * Attach custom metadata to the current request or Flow action so it shows on
+   * the trace — tenant, plan, feature flags, anything useful for debugging:
+   *
+   *   Monitor.context({ tenant: tenant.id, plan: user.plan });
+   *
+   * No-op outside a request/action scope.
+   */
+  context(data: Record<string, unknown>): void {
+    const ctx = RequestContext.tryGet();
+    if (ctx) addContext(ctx as object, data);
+  },
+  /** Read the current aggregated snapshot (used by the page; rarely needed directly). */
+  snapshot: (...a: Parameters<MonitorStore["snapshot"]>) => {
+    const store = _getStore();
+    return store ? store.snapshot(...a) : undefined;
+  },
+  /** The live store instance, if booted. */
+  get store(): MonitorStore | undefined {
+    return _getStore();
+  },
+} as const;

package/src/index.ts

@@ -0,0 +1,62 @@
+/**
+ * `@zerotal/monitor` — a production monitoring & queue dashboard for Zerotal.
+ *
+ * A server-driven Flow panel ("Super Panel") with eight tabs: Overview,
+ * Requests, Exceptions, Queues, Mail, Database, Cache and System. It records
+ * live request/exception data via middleware, reads queues/scheduler/health
+ * from the running app, and exposes a `Monitor` facade for everything else.
+ *
+ * @example
+ * // bootstrap/providers.ts
+ * import { FlowProvider } from "@zerotal/flow";
+ * import { MonitorProvider } from "@zerotal/monitor";
+ * export default [FlowProvider, MonitorProvider];
+ *
+ * @example
+ * // config/monitor.ts
+ * import { MonitorConfig } from "@zerotal/monitor";
+ * export default MonitorConfig({ path: "/monitor", auth: (u) => u?.role === "admin" });
+ */
+
+// Provider + config
+export { MonitorProvider } from "./provider/MonitorProvider.ts";
+export { MonitorConfig } from "./config.ts";
+export type { MonitorConfigShape, ResolvedMonitorConfig } from "./config.ts";
+
+// Facade + store
+export { Monitor } from "./facades/Monitor.ts";
+export { MonitorStore } from "./MonitorStore.ts";
+export type { MonitorStoreOptions } from "./MonitorStore.ts";
+
+// Prometheus exporter
+export { renderPrometheus } from "./prometheus.ts";
+
+// Alerting
+export { evaluateAlerts, onAlert } from "./alerting.ts";
+export type { AlertThresholds, AlertNotice } from "./alerting.ts";
+
+// Recorder + guard
+export { installMonitorEventBridge } from "./recorder/MonitorEventBridge.ts";
+export { MonitorAuthMiddleware } from "./middleware/MonitorAuthMiddleware.ts";
+export { MonitorPayloadMiddleware } from "./middleware/MonitorPayloadMiddleware.ts";
+
+// UI
+// The contribution surface. Packages push into the `monitor.panel` binding
+// rather than importing these types; they're exported for app-authored sections.
+export { MonitorPanel } from "./panel.ts";
+export type {
+  MonitorPanelHost,
+  MonitorSection,
+  MonitorSectionData,
+  MonitorStat,
+  MonitorTable,
+  MonitorTableColumn,
+  MonitorTone,
+  MonitorRow,
+} from "./panel.ts";
+
+export { MonitorPage } from "./ui/MonitorPage.tsx";
+export { MonitorLayout } from "./ui/MonitorLayout.tsx";
+
+// Data shapes
+export type * from "./store/types.ts";

package/src/instance.ts

@@ -0,0 +1,16 @@
+/**
+ * Process-wide handle to the active {@link MonitorStore}. The provider sets it
+ * during boot; the recorder middleware and the {@link ./facades/Monitor.ts}
+ * facade read it without needing the IoC container in hand.
+ */
+import type { MonitorStore } from "./MonitorStore.ts";
+
+let _store: MonitorStore | undefined;
+
+export function _setStore(store: MonitorStore | undefined): void {
+  _store = store;
+}
+
+export function _getStore(): MonitorStore | undefined {
+  return _store;
+}

package/src/middleware/MonitorAuthMiddleware.ts

@@ -0,0 +1,20 @@
+/**
+ * Guards the monitoring panel. Resolves the panel config from the container and
+ * runs its `auth(user)` predicate; denies access otherwise. Mirrors the admin
+ * package's guard so behaviour is consistent across Zerotal's ops surfaces.
+ */
+import type { Pipe, NextFn, HttpContext } from "@zerotal/core";
+import { currentApp } from "@zerotal/core";
+import type { ResolvedMonitorConfig } from "../config.ts";
+
+export class MonitorAuthMiddleware implements Pipe<HttpContext> {
+  async handle(http: HttpContext, next: NextFn): Promise<Response | void> {
+    const config = currentApp().container.makeSync("monitor") as ResolvedMonitorConfig;
+    const user = (http as { user?: unknown }).user ?? null;
+    const allowed = await config.auth(user);
+    if (!allowed) {
+      return Response.redirect("/login", 302);
+    }
+    return next();
+  }
+}

package/src/middleware/MonitorPayloadMiddleware.ts

@@ -0,0 +1,96 @@
+/**
+ * Captures request/response headers and bodies for the request trace (Telescope's
+ * payload watcher). Opt-in via `capturePayloads` — the provider registers it
+ * globally only when enabled. Bodies are read from clones so the handler still gets
+ * the originals, and sensitive headers/keys are redacted before anything is stored.
+ */
+import type { Pipe, NextFn, HttpContext } from "@zerotal/core";
+import { currentApp } from "@zerotal/core";
+import { addPayload } from "../recorder/ctxBuffers.ts";
+import type { ResolvedMonitorConfig } from "../config.ts";
+
+const REDACT_HEADERS = new Set(["authorization", "cookie", "set-cookie", "proxy-authorization"]);
+const REDACT_KEY = /pass(word)?|token|secret|api[-_]?key|authorization|credit[-_]?card|cvv/i;
+const REDACTED = "[redacted]";
+
+function redactHeaders(headers: Headers): Record<string, string> {
+  const out: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    out[key] = REDACT_HEADERS.has(key.toLowerCase()) ? REDACTED : value;
+  });
+  return out;
+}
+
+/** Recursively mask values of sensitive keys when the body parses as JSON. */
+function redactJson(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(redactJson);
+  if (value && typeof value === "object") {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      out[k] = REDACT_KEY.test(k) ? REDACTED : redactJson(v);
+    }
+    return out;
+  }
+  return value;
+}
+
+function clip(s: string, maxBytes: number): string {
+  return s.length > maxBytes ? `${s.slice(0, maxBytes)}…(truncated)` : s;
+}
+
+function redactBody(raw: string, maxBytes: number): string {
+  if (!raw) return "";
+  try {
+    return clip(JSON.stringify(redactJson(JSON.parse(raw))), maxBytes);
+  } catch {
+    return clip(raw, maxBytes); // not JSON — keep raw, just truncated
+  }
+}
+
+export class MonitorPayloadMiddleware implements Pipe<HttpContext> {
+  async handle(http: HttpContext, next: NextFn): Promise<Response | void> {
+    let maxBytes = 65536;
+    let monitorPath = "/monitor";
+    try {
+      const cfg = currentApp().container.makeSync("monitor") as ResolvedMonitorConfig;
+      maxBytes = cfg.payloadMaxBytes;
+      monitorPath = cfg.path;
+    } catch {
+      /* config not ready — use defaults */
+    }
+
+    // Don't capture the panel's own traffic or framework internals.
+    const path = http.url.pathname;
+    if (path.startsWith(monitorPath) || path.startsWith("/metrics") || path.startsWith("/__")) {
+      return next();
+    }
+
+    // Request body from a clone so the handler can still read the original. Skip huge
+    // bodies (best-effort via content-length) to avoid buffering large uploads.
+    let reqBody = "";
+    try {
+      const len = Number(http.request.headers.get("content-length") ?? 0);
+      if (http.request.body && len <= maxBytes * 16) reqBody = await http.request.clone().text();
+    } catch {
+      /* unreadable / streamed body — skip */
+    }
+    const reqHeaders = redactHeaders(http.request.headers);
+
+    const result = await next();
+
+    let resBody = "";
+    try {
+      if (http.response) resBody = await http.response.clone().text();
+    } catch {
+      /* streamed / binary response — skip */
+    }
+
+    addPayload(http, {
+      reqHeaders,
+      reqBody: redactBody(reqBody, maxBytes),
+      resBody: clip(resBody, maxBytes),
+    });
+
+    return result;
+  }
+}