@nwire/studio 0.12.1 → 0.13.1

package/src/lib/manifest.ts

@@ -0,0 +1,139 @@
+/**
+ * Native manifest access — pure selectors over `@nwire/scan`'s `Manifest`.
+ *
+ * Studio reads the deep manifest directly. Types are `import type` from
+ * `@nwire/scan` — erased at build, so `typescript` never
+ * enters the browser bundle. Selectors are pure so they unit-test without a DOM.
+ */
+import type { Manifest, ManifestModel, GraphNode, GraphEdge, EdgeType } from "@nwire/scan";
+
+export type { Manifest, ManifestModel, GraphNode, GraphEdge, EdgeType };
+
+/** The manifest version this Studio build understands. */
+export const SUPPORTED_MANIFEST_VERSION = 3;
+
+/**
+ * A normalized view over a manifest — tolerant of missing/old fields. Never
+ * throws on a partial manifest; callers render empty states instead.
+ */
+export interface ManifestView {
+  readonly manifest: Manifest;
+  readonly model: ManifestModel;
+  /** True when the manifest version differs from what this build understands. */
+  readonly versionMismatch: boolean;
+  /** Nodes of one graph kind (e.g. "action", "app", "capability"). */
+  byKind(kind: string): GraphNode[];
+  /** A node by id (`"${kind}:${name}"`). */
+  node(id: string): GraphNode | undefined;
+  /** Edges touching a node — `dir` filters to outgoing/incoming/both. */
+  edgesOf(id: string, dir?: "out" | "in" | "both"): GraphEdge[];
+  /** Edges of a given type. */
+  edgesByType(type: EdgeType): GraphEdge[];
+}
+
+/**
+ * Flat per-kind array key → graph node kind. Used to synthesize a model when a
+ * manifest predates the deep `model` (resilience: older/partial manifests still
+ * browse in Inspect). Mirrors `@nwire/scan`'s graph kinds.
+ */
+const FLAT_KIND: ReadonlyArray<readonly [string, string]> = [
+  ["apps", "app"],
+  ["actions", "action"],
+  ["events", "event"],
+  ["actors", "actor"],
+  ["projections", "projection"],
+  ["queries", "query"],
+  ["resolvers", "resolver"],
+  ["routes", "route"],
+  ["workflows", "workflow"],
+  ["externalCalls", "externalCall"],
+  ["inboundWebhooks", "inboundWebhook"],
+  ["outboxes", "outbox"],
+  ["inboxes", "inbox"],
+  ["crons", "cron"],
+  ["commands", "command"],
+  ["hooks", "hook"],
+  ["plugins", "plugin"],
+  ["sinks", "sinkStage"],
+  ["bindings", "binding"],
+  ["resources", "resource"],
+  ["errors", "error"],
+];
+
+const NODE_DISPLAY_FIELDS = new Set(["name", "app", "description", "public", "source"]);
+
+/**
+ * Build a node+edge model from a manifest's flat per-kind arrays — the fallback
+ * for manifests without a deep `model`. Nodes cover every present kind; edges
+ * cover the statically-derivable ones (action→event `emits`, query→projection
+ * `reads`). Pure.
+ */
+export function synthesizeModel(manifest: Manifest): ManifestModel {
+  const m = manifest as unknown as Record<string, unknown>;
+  const nodes: GraphNode[] = [];
+  const edges: GraphEdge[] = [];
+  const seen = new Set<string>();
+
+  for (const [key, kind] of FLAT_KIND) {
+    const list = m[key];
+    if (!Array.isArray(list)) continue;
+    for (const raw of list as Record<string, unknown>[]) {
+      const name =
+        typeof raw.name === "string" ? raw.name : typeof raw.id === "string" ? raw.id : undefined;
+      if (!name) continue;
+      const id = `${kind}:${name}`;
+      if (seen.has(id)) continue;
+      seen.add(id);
+
+      const data: Record<string, unknown> = {};
+      for (const [k, v] of Object.entries(raw)) {
+        if (!NODE_DISPLAY_FIELDS.has(k) && v !== undefined) data[k] = v;
+      }
+      nodes.push({
+        id,
+        kind,
+        name,
+        source: raw.source as GraphNode["source"],
+        intent: {
+          description: typeof raw.description === "string" ? raw.description : undefined,
+          public: raw.public === true,
+        },
+        data,
+      });
+
+      if (kind === "action" && Array.isArray(raw.emits)) {
+        for (const ev of raw.emits as string[])
+          edges.push({ from: id, to: `event:${ev}`, type: "emits" });
+      }
+      if (kind === "query" && typeof raw.projection === "string") {
+        edges.push({ from: id, to: `projection:${raw.projection}`, type: "reads" });
+      }
+    }
+  }
+  return { nodes, edges };
+}
+
+/** Build a tolerant view over a raw manifest object. */
+export function manifestView(manifest: Manifest): ManifestView {
+  const model: ManifestModel =
+    manifest.model && Array.isArray(manifest.model.nodes) && manifest.model.nodes.length
+      ? manifest.model
+      : synthesizeModel(manifest);
+  const nodes = model.nodes ?? [];
+  const edges = model.edges ?? [];
+  const byId = new Map<string, GraphNode>(nodes.map((n) => [n.id, n]));
+  const version = (manifest as { version?: number }).version;
+
+  return {
+    manifest,
+    model,
+    versionMismatch: typeof version === "number" && version !== SUPPORTED_MANIFEST_VERSION,
+    byKind: (kind) => nodes.filter((n) => n.kind === kind),
+    node: (id) => byId.get(id),
+    edgesOf: (id, dir = "both") =>
+      edges.filter((e) =>
+        dir === "out" ? e.from === id : dir === "in" ? e.to === id : e.from === id || e.to === id,
+      ),
+    edgesByType: (type) => edges.filter((e) => e.type === type),
+  };
+}

package/src/lib/metadata.ts

@@ -0,0 +1,52 @@
+/**
+ * Metadata flattening — turn a nested record (envelope, payload, error) into a
+ * flat list of dot-notation `key → value` entries for the inspector. Pure +
+ * unit-tested; the component renders + copies what this returns.
+ */
+
+/** A primitive leaf value the inspector can render + copy. */
+export type MetaValue = string | number | boolean | null;
+
+/** One flattened entry — `a.b.c` → value, with the value's JS type. */
+export interface MetaEntry {
+  readonly path: string;
+  readonly value: MetaValue;
+  readonly type: "string" | "number" | "boolean" | "null";
+}
+
+function typeOf(v: MetaValue): MetaEntry["type"] {
+  if (v === null) return "null";
+  if (typeof v === "number") return "number";
+  if (typeof v === "boolean") return "boolean";
+  return "string";
+}
+
+/**
+ * Flatten an arbitrary value into dot-notation leaf entries. Objects recurse by
+ * key; arrays recurse by index (`items.0.id`). Primitives become a single
+ * entry. `undefined` and functions are dropped. Cycles are guarded.
+ */
+export function flattenMetadata(input: unknown, prefix = ""): MetaEntry[] {
+  return walk(input, prefix, new WeakSet());
+}
+
+function walk(value: unknown, prefix: string, seen: WeakSet<object>): MetaEntry[] {
+  if (value === null) return [{ path: prefix || "value", value: null, type: "null" }];
+  if (value === undefined || typeof value === "function") return [];
+  if (typeof value !== "object") {
+    const v = value as MetaValue;
+    return [{ path: prefix || "value", value: v, type: typeOf(v) }];
+  }
+  if (seen.has(value as object))
+    return [{ path: prefix || "value", value: "[circular]", type: "string" }];
+  seen.add(value as object);
+
+  const out: MetaEntry[] = [];
+  const entries: [string, unknown][] = Array.isArray(value)
+    ? value.map((v, i) => [String(i), v])
+    : Object.entries(value as Record<string, unknown>);
+  for (const [k, v] of entries) {
+    out.push(...walk(v, prefix ? `${prefix}.${k}` : k, seen));
+  }
+  return out;
+}

package/src/lib/node-metrics.ts

@@ -0,0 +1,242 @@
+/**
+ * Node metrics — fold the live telemetry feed into per-primitive and per-app
+ * rollups the Topology and Map canvases overlay on their nodes.
+ *
+ * Pure + framework-free so it unit-tests without a DOM. The runtime + forge
+ * push records keyed by *which* primitive each is about under different field
+ * names (`action` / `query` / `projection` / `event` / `actor` / `workflow` /
+ * `call`); `nodeIdOf` normalizes any record to the graph node id
+ * (`"${kind}:${name}"`) the manifest uses, so a record lights up exactly the
+ * node it belongs to. `appName` carries the owning app for the Map rollup.
+ *
+ * Metrics are derived, not stored: same records in → same metrics out, so a
+ * telemetry refresh updates counts in place without moving any node.
+ */
+import type { TelemetryRecord } from "./telemetry";
+import { isFailure } from "./telemetry";
+
+/** Per-node rollup overlaid on a Topology wiring node (or a Map BC row). */
+export interface NodeMetrics {
+  /** Total records seen for this node (throughput). */
+  readonly count: number;
+  /** Of those, how many were failures. */
+  readonly errors: number;
+  /** Median duration in ms, when any record carried one (else undefined). */
+  readonly p50?: number;
+  /** ISO timestamp of the most recent record. */
+  readonly lastTs?: string;
+}
+
+/** Per-app rollup overlaid on a Map bounded-context card. */
+export interface AppMetrics {
+  /** Dispatches (actions + queries) attributed to this app. */
+  readonly dispatches: number;
+  /** Failure records attributed to this app. */
+  readonly errors: number;
+  /** Total records (any kind) — drives the "live" pulse. */
+  readonly total: number;
+  /** ISO timestamp of the most recent record for this app. */
+  readonly lastTs?: string;
+}
+
+/** Recent-activity windows feeding edge animation + counts. */
+export interface MetricsRollup {
+  /** node id → metrics. */
+  readonly byNode: ReadonlyMap<string, NodeMetrics>;
+  /** app name → metrics. */
+  readonly byApp: ReadonlyMap<string, AppMetrics>;
+  /** Total records folded — `0` means "no run yet" (neutral placeholders). */
+  readonly total: number;
+}
+
+const EMPTY: MetricsRollup = { byNode: new Map(), byApp: new Map(), total: 0 };
+
+/** Kinds the Map counts as a "dispatch" (the everyday request count). */
+const DISPATCH_KINDS: ReadonlySet<string> = new Set(["action.dispatched", "query.executed"]);
+
+function str(v: unknown): string | undefined {
+  return typeof v === "string" && v ? v : undefined;
+}
+
+/**
+ * The graph node id (`"${kind}:${name}"`) a telemetry record is about, or
+ * `null` when the record names no primitive (stage / hook records). Reads the
+ * kind-specific name field the runtime/forge stamp:
+ *   action.* → `action`   query.* → `query`   projection.* → `projection`
+ *   event.* / listener.* → `event` (string name, or `event.name` object)
+ *   actor.* / timer.* → `actor`   reaction.* → `workflow`
+ *   external.call.* → `externalCall:<call>`
+ */
+export function nodeIdOf(rec: TelemetryRecord): string | null {
+  const base = rec.kind.split(".")[0] ?? rec.kind;
+  switch (base) {
+    case "action": {
+      // dlq.recorded also carries `action`; routed here only via its own kind.
+      const name = str(rec.action);
+      return name ? `action:${name}` : null;
+    }
+    case "query": {
+      const name = str(rec.query);
+      return name ? `query:${name}` : null;
+    }
+    case "projection": {
+      const name = str(rec.projection);
+      return name ? `projection:${name}` : null;
+    }
+    case "actor":
+    case "timer": {
+      const name = str(rec.actor);
+      return name ? `actor:${name}` : null;
+    }
+    case "reaction": {
+      const name = str(rec.workflow);
+      return name ? `workflow:${name}` : null;
+    }
+    case "dlq": {
+      const name = str(rec.action);
+      return name ? `action:${name}` : null;
+    }
+    case "event":
+    case "listener": {
+      // `event` is a string (event.emitted / listener.fired) or an
+      // EventMessage object (event.published / .deduped) carrying its name
+      // under `eventName` (forge's EventMessage) or `name`.
+      const ev = rec.event;
+      const obj = ev as { eventName?: unknown; name?: unknown } | undefined;
+      const name = str(ev) ?? str(obj?.eventName) ?? str(obj?.name);
+      return name ? `event:${name}` : null;
+    }
+    case "external": {
+      const name = str(rec.call);
+      return name ? `externalCall:${name}` : null;
+    }
+    default:
+      return null;
+  }
+}
+
+/** Median of a numeric list (sorted copy). Empty → undefined. */
+function median(ns: number[]): number | undefined {
+  if (ns.length === 0) return undefined;
+  const s = [...ns].sort((a, b) => a - b);
+  const mid = Math.floor(s.length / 2);
+  return s.length % 2 ? s[mid]! : Math.round((s[mid - 1]! + s[mid]!) / 2);
+}
+
+type NodeAccum = { count: number; errors: number; durations: number[]; lastTs?: string };
+type AppAccum = { dispatches: number; errors: number; total: number; lastTs?: string };
+
+function laterTs(a: string | undefined, b: string | undefined): string | undefined {
+  if (!a) return b;
+  if (!b) return a;
+  return a >= b ? a : b;
+}
+
+/**
+ * Fold a telemetry record list into per-node + per-app metrics. Deterministic:
+ * the same records always yield the same rollup, so the canvas updates counts
+ * without re-laying-out. Tolerant of unknown kinds (they just don't attribute).
+ */
+export function rollupMetrics(records: readonly TelemetryRecord[]): MetricsRollup {
+  if (records.length === 0) return EMPTY;
+
+  const nodeAcc = new Map<string, NodeAccum>();
+  const appAcc = new Map<string, AppAccum>();
+
+  for (const rec of records) {
+    const failed = isFailure(rec);
+    const ts = str(rec.ts);
+
+    const id = nodeIdOf(rec);
+    if (id) {
+      let n = nodeAcc.get(id);
+      if (!n) {
+        n = { count: 0, errors: 0, durations: [] };
+        nodeAcc.set(id, n);
+      }
+      n.count++;
+      if (failed) n.errors++;
+      if (typeof rec.durationMs === "number") n.durations.push(rec.durationMs);
+      n.lastTs = laterTs(n.lastTs, ts);
+    }
+
+    const app = str(rec.appName);
+    if (app) {
+      let a = appAcc.get(app);
+      if (!a) {
+        a = { dispatches: 0, errors: 0, total: 0 };
+        appAcc.set(app, a);
+      }
+      a.total++;
+      if (DISPATCH_KINDS.has(rec.kind)) a.dispatches++;
+      if (failed) a.errors++;
+      a.lastTs = laterTs(a.lastTs, ts);
+    }
+  }
+
+  const byNode = new Map<string, NodeMetrics>();
+  for (const [id, n] of nodeAcc) {
+    byNode.set(id, {
+      count: n.count,
+      errors: n.errors,
+      p50: median(n.durations),
+      lastTs: n.lastTs,
+    });
+  }
+
+  const byApp = new Map<string, AppMetrics>();
+  for (const [name, a] of appAcc) {
+    byApp.set(name, {
+      dispatches: a.dispatches,
+      errors: a.errors,
+      total: a.total,
+      lastTs: a.lastTs,
+    });
+  }
+
+  return { byNode, byApp, total: records.length };
+}
+
+/**
+ * Per-edge activity for the wiring graph: an edge is "active" when both its
+ * endpoints saw a record within the recency window, so the canvas can animate
+ * live edges and label them with the lighter end's throughput. Keyed by the
+ * `"${from}=>${to}"` ids the wiring graph mints.
+ */
+export interface EdgeActivity {
+  /** Records attributed to the edge's destination node (its throughput). */
+  readonly volume: number;
+  /** True when the destination saw a record this window — animate it. */
+  readonly active: boolean;
+}
+
+/**
+ * Resolve per-edge activity from the node rollup: an edge carries the volume
+ * of its target node and is active when that node has any throughput. Pure;
+ * derived entirely from `byNode` so it never thrashes the layout.
+ */
+export function edgeActivity(
+  byNode: ReadonlyMap<string, NodeMetrics>,
+  edges: ReadonlyArray<{ id: string; from: string; to: string }>,
+): Map<string, EdgeActivity> {
+  const out = new Map<string, EdgeActivity>();
+  for (const e of edges) {
+    const m = byNode.get(e.to);
+    const volume = m?.count ?? 0;
+    out.set(e.id, { volume, active: volume > 0 });
+  }
+  return out;
+}
+
+/** Format a metric count for display — a dim em dash before any run. */
+export function fmtCount(n: number | undefined): string {
+  return n == null || n === 0 ? "—" : String(n);
+}
+
+/** Format a p50 latency — "—" when none yet, "<1ms" / "12ms" / "1.2s" otherwise. */
+export function fmtLatency(ms: number | undefined): string {
+  if (ms == null) return "—";
+  if (ms < 1) return "<1ms";
+  if (ms < 1000) return `${Math.round(ms)}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}

package/src/lib/operate.ts

@@ -0,0 +1,114 @@
+/**
+ * Operate — pure helpers behind the Run + Commands panels.
+ *
+ * Process lifecycle, env parsing, script ordering, and status presentation. No
+ * DOM, no fetch — the panels own I/O; this owns the maths so it unit-tests
+ * cleanly.
+ */
+
+export type ProcessStatus = "idle" | "starting" | "running" | "stopping" | "exited" | "crashed";
+
+export interface ManagedProcess {
+  id: string;
+  topology: string;
+  port?: number;
+  startedAt: string;
+  status: ProcessStatus;
+  pid?: number;
+  exitCode?: number | null;
+  signal?: string | null;
+  errorMessage?: string;
+  /** "studio" — spawned here; "external" — discovered from .nwire/processes. */
+  source?: "studio" | "external";
+  env?: Record<string, string>;
+}
+
+export interface LogLine {
+  seq: number;
+  ts: string;
+  stream: "stdout" | "stderr";
+  line: string;
+}
+
+export interface ScriptEntry {
+  name: string;
+  command: string;
+}
+
+/**
+ * Parse a `KEY=value` block (one per line) into an env object. Skips blanks +
+ * `#` comments + malformed keys; strips matching surrounding quotes.
+ */
+export function parseEnvInput(raw: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq < 1) continue;
+    const k = trimmed.slice(0, eq).trim();
+    const v = trimmed.slice(eq + 1).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) continue;
+    const dequoted =
+      (v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))
+        ? v.slice(1, -1)
+        : v;
+    out[k] = dequoted;
+  }
+  return out;
+}
+
+/**
+ * package.json scripts ordered for the picker: `nwire`-prefixed first
+ * (framework shorthands operators reach for most), then the rest — each group
+ * alphabetical.
+ */
+export function sortScripts(scripts: readonly ScriptEntry[]): ScriptEntry[] {
+  const byName = (a: ScriptEntry, b: ScriptEntry) => a.name.localeCompare(b.name);
+  const nwire = scripts.filter((s) => s.name.startsWith("nwire")).sort(byName);
+  const others = scripts.filter((s) => !s.name.startsWith("nwire")).sort(byName);
+  return [...nwire, ...others];
+}
+
+/** StatusBadge tone for a process status. */
+export type StatusTone = "live" | "warn" | "error" | "idle";
+
+export function statusTone(status: ProcessStatus): StatusTone {
+  switch (status) {
+    case "running":
+      return "live";
+    case "starting":
+    case "stopping":
+      return "warn";
+    case "crashed":
+      return "error";
+    case "exited":
+    case "idle":
+      return "idle";
+  }
+}
+
+/** Short, stable process id for display (first uuid segment). */
+export function shortId(id: string): string {
+  return id.split("-")[0] ?? id.slice(0, 8);
+}
+
+/** Human "Ns/Nm/Nh ago" from an ISO timestamp; `now` injected for testability. */
+export function timeAgo(iso: string, now: number): string {
+  const s = Math.max(0, Math.floor((now - new Date(iso).getTime()) / 1000));
+  if (s < 60) return `${s}s ago`;
+  if (s < 3600) return `${Math.floor(s / 60)}m ago`;
+  return `${Math.floor(s / 3600)}h ago`;
+}
+
+/** A process is live (running) or transitioning (starting/stopping). */
+export function isActive(status: ProcessStatus): boolean {
+  return status === "running" || status === "starting" || status === "stopping";
+}
+
+/** The wire `/_nwire/*` routes to — the most-recently-started running process. */
+export function activeProcess(processes: readonly ManagedProcess[]): ManagedProcess | undefined {
+  const running = processes.filter((p) => p.status === "running");
+  if (running.length === 0) return undefined;
+  return [...running].sort((a, b) => b.startedAt.localeCompare(a.startedAt))[0];
+}

package/src/lib/pipeline-flow.ts

@@ -0,0 +1,120 @@
+/**
+ * Pipeline flow — turns raw `source.stage` / `sink.stage` telemetry records
+ * into the inbound and outbound stage rows for one correlation, so the Trace
+ * view can draw the full flow: inbound pipeline → execute/fold (the event
+ * tree) → outbound pipeline.
+ *
+ * Pure + framework-free so it unit-tests without a DOM. The server's inspect
+ * endpoint streams every telemetry kind; this just selects the two stage
+ * kinds, scopes them to a correlation, and orders them the way they ran
+ * (position early → middle → terminal, then by timestamp within a position).
+ */
+
+/** A `source.stage` telemetry record (inbound pipeline). */
+export interface SourceStageRecord {
+  kind: "source.stage";
+  stage: string;
+  position: StagePosition;
+  stageKind?: string;
+  message?: { name?: string; kind?: "command" | "event" };
+  correlationId?: string;
+  tenant?: string;
+  shortCircuited: boolean;
+  durationMs: number;
+  appName: string;
+  ts: string;
+}
+
+/** A `sink.stage` telemetry record (outbound pipeline). */
+export interface SinkStageRecord {
+  kind: "sink.stage";
+  stage: string;
+  position: StagePosition;
+  stageKind?: string;
+  event: string;
+  correlationId?: string;
+  tenant?: string;
+  shortCircuited: boolean;
+  durationMs: number;
+  appName: string;
+  ts: string;
+}
+
+export type StagePosition = "early" | "middle" | "terminal";
+export type StageRecord = SourceStageRecord | SinkStageRecord;
+
+/** One row in the rendered pipeline. */
+export interface StageRow {
+  direction: "inbound" | "outbound";
+  stage: string;
+  position: StagePosition;
+  stageKind?: string;
+  /** Inbound: the message name; outbound: the event name. */
+  label: string;
+  shortCircuited: boolean;
+  durationMs: number;
+  appName: string;
+  ts: string;
+}
+
+export interface PipelineFlow {
+  inbound: StageRow[];
+  outbound: StageRow[];
+}
+
+const POSITION_ORDER: Record<StagePosition, number> = { early: 0, middle: 1, terminal: 2 };
+
+/** True for the two stage-telemetry kinds this view cares about. */
+export function isStageRecord(rec: { kind?: string }): rec is StageRecord {
+  return rec.kind === "source.stage" || rec.kind === "sink.stage";
+}
+
+function order(a: StageRow, b: StageRow): number {
+  const byPos = POSITION_ORDER[a.position] - POSITION_ORDER[b.position];
+  return byPos !== 0 ? byPos : a.ts.localeCompare(b.ts);
+}
+
+/**
+ * Build the inbound + outbound stage rows for one correlation. Records with
+ * no correlationId are excluded (they can't be tied to a trace). When
+ * `correlationId` is undefined, returns empty flows.
+ */
+export function pipelineFlow(
+  records: readonly StageRecord[],
+  correlationId: string | undefined,
+): PipelineFlow {
+  if (!correlationId) return { inbound: [], outbound: [] };
+  const inbound: StageRow[] = [];
+  const outbound: StageRow[] = [];
+  for (const rec of records) {
+    if (rec.correlationId !== correlationId) continue;
+    if (rec.kind === "source.stage") {
+      inbound.push({
+        direction: "inbound",
+        stage: rec.stage,
+        position: rec.position,
+        stageKind: rec.stageKind,
+        label: rec.message?.name ?? "",
+        shortCircuited: rec.shortCircuited,
+        durationMs: rec.durationMs,
+        appName: rec.appName,
+        ts: rec.ts,
+      });
+    } else {
+      outbound.push({
+        direction: "outbound",
+        stage: rec.stage,
+        position: rec.position,
+        stageKind: rec.stageKind,
+        label: rec.event,
+        shortCircuited: rec.shortCircuited,
+        durationMs: rec.durationMs,
+        appName: rec.appName,
+        ts: rec.ts,
+      });
+    }
+  }
+  inbound.sort(order);
+  outbound.sort(order);
+  return { inbound, outbound };
+}