station-kit 1.0.9 → 2.0.0

package/src/server/middleware/rate-limit.ts

@@ -15,11 +15,20 @@ interface BucketEntry {
   resetAt: number;
 }
 
+/** Upper bound on tracked buckets so unique keys can't grow the map unbounded. */
+const MAX_BUCKETS = 10_000;
+
 export function rateLimiter(options: RateLimitOptions = {}) {
   const windowMs = options.windowMs ?? 60_000;
   const max = options.max ?? 100;
   const keyFn = options.keyFn ?? ((c: Context) => {
-    return (c.get("apiKeyId") as string) ?? c.req.header("x-forwarded-for") ?? "anonymous";
+    const apiKeyId = c.get("apiKeyId") as string | undefined;
+    if (apiKeyId) return apiKeyId;
+    // Key on the socket's address, NOT x-forwarded-for: that header is
+    // client-controlled, so keying on it lets an attacker mint a fresh
+    // bucket per request and bypass the limit entirely.
+    const incoming = (c.env as { incoming?: { socket?: { remoteAddress?: string } } })?.incoming;
+    return incoming?.socket?.remoteAddress ?? "anonymous";
   });
 
   const buckets = new Map<string, BucketEntry>();
@@ -39,6 +48,16 @@ export function rateLimiter(options: RateLimitOptions = {}) {
 
     let entry = buckets.get(key);
     if (!entry || now > entry.resetAt) {
+      if (!entry && buckets.size >= MAX_BUCKETS) {
+        // Evict expired entries first; if everything is live, drop the oldest.
+        for (const [k, e] of buckets) {
+          if (now > e.resetAt) buckets.delete(k);
+        }
+        if (buckets.size >= MAX_BUCKETS) {
+          const oldest = buckets.keys().next().value;
+          if (oldest !== undefined) buckets.delete(oldest);
+        }
+      }
       entry = { count: 0, resetAt: now + windowMs };
       buckets.set(key, entry);
     }

package/src/server/routes/beacons.ts

@@ -0,0 +1,112 @@
+import { Hono } from "hono";
+import type { BeaconRunner, BeaconStateAdapter, BeaconInstance } from "station-beacon";
+import { beaconLogKey } from "../subscriber.js";
+
+export interface BeaconDeps {
+  beaconRunner?: BeaconRunner;
+  beaconAdapter?: BeaconStateAdapter;
+  logBuffer?: import("../log-buffer.js").LogBuffer;
+  logStore?: import("../log-store.js").LogStore;
+}
+
+function serializeInstance(inst: BeaconInstance): Record<string, unknown> {
+  return {
+    ...inst,
+    startedAt: inst.startedAt?.toISOString?.() ?? inst.startedAt,
+    readyAt: inst.readyAt?.toISOString?.() ?? inst.readyAt,
+    lastHeartbeatAt: inst.lastHeartbeatAt?.toISOString?.() ?? inst.lastHeartbeatAt,
+    lastExitAt: inst.lastExitAt?.toISOString?.() ?? inst.lastExitAt,
+    nextRestartAt: inst.nextRestartAt?.toISOString?.() ?? inst.nextRestartAt,
+    createdAt: inst.createdAt?.toISOString?.() ?? inst.createdAt,
+    updatedAt: inst.updatedAt?.toISOString?.() ?? inst.updatedAt,
+  };
+}
+
+export function beaconRoutes(deps: BeaconDeps) {
+  const app = new Hono();
+
+  // GET /beacons — list registered beacons merged with their instance state
+  app.get("/beacons", async (c) => {
+    if (!deps.beaconRunner) return c.json({ data: [] });
+    const registered = deps.beaconRunner.listRegistered();
+    const instances = await deps.beaconRunner.listInstances();
+    const byName = new Map(instances.map((i) => [i.beaconName, i]));
+    const data = registered.map((r) => {
+      const inst = byName.get(r.name);
+      return { ...r, instance: inst ? serializeInstance(inst) : null };
+    });
+    return c.json({ data });
+  });
+
+  // GET /beacons/:name — registered metadata + current instance
+  app.get("/beacons/:name", async (c) => {
+    const name = c.req.param("name");
+    if (!deps.beaconRunner) {
+      return c.json({ error: "not_found", message: "No beacon runner configured." }, 404);
+    }
+    const meta = deps.beaconRunner.listRegistered().find((b) => b.name === name);
+    if (!meta) {
+      return c.json({ error: "not_found", message: `Beacon "${name}" not found.` }, 404);
+    }
+    const inst = await deps.beaconRunner.getInstance(name);
+    return c.json({ data: { ...meta, instance: inst ? serializeInstance(inst) : null } });
+  });
+
+  // GET /beacons/:name/events — lifecycle event log (if the adapter records one)
+  app.get("/beacons/:name/events", async (c) => {
+    const name = c.req.param("name");
+    // Clamp so a client can't request an unbounded (or NaN) event scan.
+    const raw = Number(c.req.query("limit") ?? "200");
+    const limit = Number.isFinite(raw) ? Math.min(Math.max(Math.trunc(raw), 1), 1000) : 200;
+    if (!deps.beaconAdapter?.listEvents) return c.json({ data: [] });
+    const events = await deps.beaconAdapter.listEvents(name, limit);
+    return c.json({
+      data: events.map((e) => ({ ...e, at: e.at?.toISOString?.() ?? e.at })),
+    });
+  });
+
+  // GET /beacons/:name/logs — captured stdout/stderr/log lines
+  app.get("/beacons/:name/logs", async (c) => {
+    const name = c.req.param("name");
+    const key = beaconLogKey(name);
+    const logs = deps.logStore
+      ? await deps.logStore.get(key)
+      : deps.logBuffer?.get(key) ?? [];
+    return c.json({ data: logs });
+  });
+
+  // POST /beacons/:name/{start,stop,restart} — operator controls
+  app.post("/beacons/:name/start", async (c) => {
+    const name = c.req.param("name");
+    if (!deps.beaconRunner) {
+      return c.json({ error: "read_only", message: "Station is in read-only mode." }, 403);
+    }
+    const body = await c.req.json().catch(() => ({}));
+    try {
+      await deps.beaconRunner.startBeacon(name, "config" in body ? { config: body.config } : undefined);
+      return c.json({ data: { started: true } });
+    } catch (err: unknown) {
+      return c.json({ error: "start_failed", message: err instanceof Error ? err.message : String(err) }, 400);
+    }
+  });
+
+  app.post("/beacons/:name/stop", async (c) => {
+    const name = c.req.param("name");
+    if (!deps.beaconRunner) {
+      return c.json({ error: "read_only", message: "Station is in read-only mode." }, 403);
+    }
+    await deps.beaconRunner.stopBeacon(name);
+    return c.json({ data: { stopped: true } });
+  });
+
+  app.post("/beacons/:name/restart", async (c) => {
+    const name = c.req.param("name");
+    if (!deps.beaconRunner) {
+      return c.json({ error: "read_only", message: "Station is in read-only mode." }, 403);
+    }
+    await deps.beaconRunner.restartBeacon(name);
+    return c.json({ data: { restarted: true } });
+  });
+
+  return app;
+}

package/src/server/routes/broadcasts.ts

@@ -77,10 +77,14 @@ export function broadcastRoutes(deps: BroadcastDeps) {
     if (!deps.broadcastAdapter) {
       return c.json({ data: [], meta: { total: 0 } });
     }
-    const runs = await deps.broadcastAdapter.listBroadcastRuns(name);
+    const limitRaw = parseInt(c.req.query("limit") ?? "100", 10);
+    const limit = Math.min(Number.isNaN(limitRaw) ? 100 : Math.max(limitRaw, 1), 500);
+    const offsetRaw = parseInt(c.req.query("offset") ?? "0", 10);
+    const offset = Number.isNaN(offsetRaw) ? 0 : Math.max(offsetRaw, 0);
+    const runs = await deps.broadcastAdapter.listBroadcastRuns(name, { limit, offset });
     return c.json({
       data: runs.map(serializeBroadcastRun),
-      meta: { total: runs.length },
+      meta: { count: runs.length, limit, offset },
     });
   });
 
@@ -123,7 +127,9 @@ export function broadcastRoutes(deps: BroadcastDeps) {
     const allLogs: Array<{ runId: string; signalName: string; level: string; message: string; timestamp: string; nodeName: string }> = [];
     for (const nr of nodes) {
       if (nr.signalRunId) {
-        const logs = deps.logStore?.get(nr.signalRunId) ?? deps.logBuffer?.get(nr.signalRunId) ?? [];
+        const logs = deps.logStore
+          ? await deps.logStore.get(nr.signalRunId)
+          : deps.logBuffer?.get(nr.signalRunId) ?? [];
         for (const log of logs) {
           allLogs.push({ ...log, nodeName: nr.nodeName });
         }

package/src/server/routes/runs.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import type { SignalRunner, SignalQueueAdapter } from "station-signal";
+import type { SignalRunner, SignalQueueAdapter, Run, RunStatus } from "station-signal";
 import type { LogBuffer } from "../log-buffer.js";
 import type { LogStore } from "../log-store.js";
 import type { StationSignalSubscriber } from "../subscriber.js";
@@ -18,82 +18,28 @@ export function runRoutes(deps: RunDeps) {
   app.get("/runs", async (c) => {
     const status = c.req.query("status");
     const signalName = c.req.query("signalName");
+    const limit = clampInt(c.req.query("limit"), 100, 1, 500);
+    const offset = clampInt(c.req.query("offset"), 0, 0, Number.MAX_SAFE_INTEGER);
+    const statuses = status ? ([status] as RunStatus[]) : undefined;
 
-    // Gather runs from adapter
-    let runs: any[] = [];
-
-    if (signalName) {
-      runs = await deps.signalAdapter.listRuns(signalName);
-    } else {
-      // Get all runs by combining due + running + listing by known signals
-      const due = await deps.signalAdapter.getRunsDue();
-      const running = await deps.signalAdapter.getRunsRunning();
-      const seen = new Set<string>();
-      for (const r of [...due, ...running]) {
-        if (!seen.has(r.id)) {
-          seen.add(r.id);
-          runs.push(r);
-        }
-      }
-
-      // Also get runs from known signals
-      if (deps.signalRunner) {
-        for (const { name } of deps.signalRunner.listRegistered()) {
-          const signalRuns = await deps.signalAdapter.listRuns(name);
-          for (const r of signalRuns) {
-            if (!seen.has(r.id)) {
-              seen.add(r.id);
-              runs.push(r);
-            }
-          }
-        }
-      }
-    }
-
-    if (status) {
-      runs = runs.filter((r) => r.status === status);
-    }
-
-    // Sort by createdAt descending
-    runs.sort((a, b) => {
-      const aTime = a.createdAt instanceof Date ? a.createdAt.getTime() : new Date(a.createdAt).getTime();
-      const bTime = b.createdAt instanceof Date ? b.createdAt.getTime() : new Date(b.createdAt).getTime();
-      return bTime - aTime;
-    });
+    // Push filtering, ordering, and limiting into the adapter instead of
+    // loading every signal's full history and sorting in memory.
+    const runs: Run[] = signalName
+      ? await deps.signalAdapter.listRuns(signalName, { limit, offset, statuses })
+      : await deps.signalAdapter.listAllRuns({ limit, offset, statuses });
 
     return c.json({
       data: runs.map(serializeRun),
-      meta: { total: runs.length },
+      meta: { count: runs.length, limit, offset },
     });
   });
 
   app.get("/runs/stats", async (c) => {
-    const due = await deps.signalAdapter.getRunsDue();
-    const running = await deps.signalAdapter.getRunsRunning();
-
-    // Aggregate from known signals
-    let allRuns: any[] = [...due, ...running];
-    const seen = new Set(allRuns.map((r) => r.id));
-
-    if (deps.signalRunner) {
-      for (const { name } of deps.signalRunner.listRegistered()) {
-        const signalRuns = await deps.signalAdapter.listRuns(name);
-        for (const r of signalRuns) {
-          if (!seen.has(r.id)) {
-            seen.add(r.id);
-            allRuns.push(r);
-          }
-        }
-      }
-    }
-
+    const counts = await deps.signalAdapter.countRunsByStatus();
     const stats = { pending: 0, running: 0, completed: 0, failed: 0, cancelled: 0 };
-    for (const r of allRuns) {
-      if (r.status in stats) {
-        stats[r.status as keyof typeof stats]++;
-      }
+    for (const key of Object.keys(stats) as RunStatus[]) {
+      stats[key as keyof typeof stats] = counts[key] ?? 0;
     }
-
     return c.json({ data: stats });
   });
 
@@ -120,7 +66,7 @@ export function runRoutes(deps: RunDeps) {
 
   app.get("/runs/:id/logs", async (c) => {
     const id = c.req.param("id");
-    const logs = deps.logStore?.get(id) ?? deps.logBuffer.get(id);
+    const logs = deps.logStore ? await deps.logStore.get(id) : deps.logBuffer.get(id);
     return c.json({ data: logs });
   });
 
@@ -213,6 +159,13 @@ export function runRoutes(deps: RunDeps) {
   return app;
 }
 
+/** Parse an integer query param, clamping to [min, max] with a fallback. */
+function clampInt(raw: string | undefined, fallback: number, min: number, max: number): number {
+  const n = parseInt(raw ?? "", 10);
+  if (Number.isNaN(n)) return fallback;
+  return Math.min(Math.max(n, min), max);
+}
+
 function serializeRun(run: any): Record<string, unknown> {
   return {
     ...run,

package/src/server/routes/signals.ts

@@ -43,17 +43,17 @@ export function signalRoutes(deps: SignalDeps) {
     }> = [];
 
     for (const sig of recurring) {
-      const runs = await deps.signalAdapter.listRuns(sig.name);
-      const pendingRun = runs.find((r) => r.status === "pending" && r.kind === "recurring");
-      const lastRun = runs
-        .filter((r) => r.status !== "pending")
-        .sort((a, b) => {
-          const aT = a.completedAt ?? a.startedAt ?? a.createdAt;
-          const bT = b.completedAt ?? b.startedAt ?? b.createdAt;
-          const aMs = aT instanceof Date ? aT.getTime() : new Date(aT).getTime();
-          const bMs = bT instanceof Date ? bT.getTime() : new Date(bT).getTime();
-          return bMs - aMs;
-        })[0];
+      // Two bounded queries instead of loading the signal's full history:
+      // the current pending run and the most recent non-pending run.
+      const [pendingRuns, lastRuns] = await Promise.all([
+        deps.signalAdapter.listRuns(sig.name, { limit: 1, statuses: ["pending"] }),
+        deps.signalAdapter.listRuns(sig.name, {
+          limit: 1,
+          statuses: ["running", "completed", "failed", "cancelled"],
+        }),
+      ]);
+      const pendingRun = pendingRuns.find((r) => r.kind === "recurring");
+      const lastRun = lastRuns[0];
 
       result.push({
         name: sig.name,
@@ -131,10 +131,14 @@ export function signalRoutes(deps: SignalDeps) {
     if (!deps.signalRunner) {
       return c.json({ data: [], meta: { total: 0 } });
     }
-    const runs = await deps.signalRunner.listRuns(name);
+    const limitRaw = parseInt(c.req.query("limit") ?? "100", 10);
+    const limit = Math.min(Number.isNaN(limitRaw) ? 100 : Math.max(limitRaw, 1), 500);
+    const offsetRaw = parseInt(c.req.query("offset") ?? "0", 10);
+    const offset = Number.isNaN(offsetRaw) ? 0 : Math.max(offsetRaw, 0);
+    const runs = await deps.signalRunner.listRuns(name, { limit, offset });
     return c.json({
       data: runs.map(serializeRun),
-      meta: { total: runs.length },
+      meta: { count: runs.length, limit, offset },
     });
   });
 

package/src/server/routes/v1/env.ts

@@ -0,0 +1,144 @@
+import { Hono } from "hono";
+import type { Context } from "hono";
+import {
+  EnvStore,
+  EnvValidationError,
+  toPublic,
+  type EnvTarget,
+  type EnvVarPublic,
+} from "station-env";
+
+export interface V1EnvDeps {
+  envStore?: EnvStore;
+}
+
+/**
+ * Parse the request body and return it only if it's a JSON object. Returns
+ * null for a parse error or a non-object body (e.g. `null`, a string, a
+ * number) so callers can respond 400 instead of throwing a 500 on
+ * `"key" in body`.
+ */
+async function readJsonObject(c: Context): Promise<Record<string, unknown> | null> {
+  const raw = await c.req.json().catch(() => undefined);
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  return raw as Record<string, unknown>;
+}
+
+/** Read-scope routes: list / get. Secret values are redacted. */
+export function v1EnvReadRoutes(deps: V1EnvDeps) {
+  const app = new Hono();
+
+  app.get("/env", async (c) => {
+    if (!deps.envStore) return c.json({ data: [] });
+    const list = await deps.envStore.listPublic();
+    return c.json({ data: list.map(serialize) });
+  });
+
+  app.get("/env/:id", async (c) => {
+    if (!deps.envStore) return c.json({ error: "unavailable" }, 503);
+    const v = await deps.envStore.getPublic(c.req.param("id"));
+    if (!v) return c.json({ error: "not_found" }, 404);
+    return c.json({ data: serialize(v) });
+  });
+
+  return app;
+}
+
+/** Admin-scope routes: create / update / delete. */
+export function v1EnvRoutes(deps: V1EnvDeps) {
+  const app = new Hono();
+
+  app.post("/env", async (c) => {
+    if (!deps.envStore) return c.json({ error: "unavailable" }, 503);
+    const body = await readJsonObject(c);
+    if (!body) return c.json({ error: "bad_request", message: "body must be a JSON object" }, 400);
+    const { key, value, secret, targets } = body as {
+      key?: unknown;
+      value?: unknown;
+      secret?: unknown;
+      targets?: unknown;
+    };
+    if (typeof key !== "string") {
+      return c.json({ error: "bad_request", message: "key is required" }, 400);
+    }
+    if (typeof value !== "string") {
+      return c.json({ error: "bad_request", message: "value is required" }, 400);
+    }
+    const apiKeyId = c.get("apiKeyId" as never) as string | undefined;
+    try {
+      const created = await deps.envStore.create({
+        key,
+        value,
+        secret: secret === true,
+        targets: normalizeTargets(targets),
+        createdBy: apiKeyId,
+      });
+      // Echo back the redacted view — a secret value is never returned, even
+      // to its creator, to keep the "write-only" contract uniform.
+      return c.json({ data: serialize(toPublic(created)) }, 201);
+    } catch (err) {
+      if (err instanceof EnvValidationError) {
+        return c.json({ error: "bad_request", message: err.message }, 400);
+      }
+      throw err;
+    }
+  });
+
+  app.patch("/env/:id", async (c) => {
+    if (!deps.envStore) return c.json({ error: "unavailable" }, 503);
+    const id = c.req.param("id");
+    const existing = await deps.envStore.get(id);
+    if (!existing) return c.json({ error: "not_found" }, 404);
+
+    const body = await readJsonObject(c);
+    if (!body) return c.json({ error: "bad_request", message: "body must be a JSON object" }, 400);
+    const patch: { value?: string; secret?: boolean; targets?: EnvTarget[] } = {};
+    if ("value" in body) {
+      if (typeof body.value !== "string") {
+        return c.json({ error: "bad_request", message: "value must be a string" }, 400);
+      }
+      patch.value = body.value;
+    }
+    if ("secret" in body) patch.secret = body.secret === true;
+    if ("targets" in body) patch.targets = normalizeTargets(body.targets);
+
+    try {
+      const updated = await deps.envStore.update(id, patch);
+      if (!updated) return c.json({ error: "not_found" }, 404);
+      return c.json({ data: serialize(toPublic(updated)) });
+    } catch (err) {
+      if (err instanceof EnvValidationError) {
+        return c.json({ error: "bad_request", message: err.message }, 400);
+      }
+      throw err;
+    }
+  });
+
+  app.delete("/env/:id", async (c) => {
+    if (!deps.envStore) return c.json({ error: "unavailable" }, 503);
+    const ok = await deps.envStore.delete(c.req.param("id"));
+    if (!ok) return c.json({ error: "not_found" }, 404);
+    return c.json({ data: { deleted: true } });
+  });
+
+  return app;
+}
+
+function normalizeTargets(raw: unknown): EnvTarget[] {
+  if (!Array.isArray(raw)) return [];
+  const out: EnvTarget[] = [];
+  for (const t of raw) {
+    if (t && typeof t === "object" && "kind" in t && "name" in t) {
+      out.push({ kind: (t as EnvTarget).kind, name: (t as EnvTarget).name });
+    }
+  }
+  return out;
+}
+
+function serialize(v: EnvVarPublic): Record<string, unknown> {
+  return {
+    ...v,
+    createdAt: v.createdAt.toISOString(),
+    updatedAt: v.updatedAt.toISOString(),
+  };
+}

package/src/server/routes/v1/events.ts

@@ -31,11 +31,11 @@ export function v1EventRoutes(deps: V1EventDeps) {
         signalFilter,
         broadcastFilter,
         eventFilter,
-        send(event: StationEvent) {
+        send(event: StationEvent, serializedData: string) {
           eventCounter++;
           stream.writeSSE({
             event: event.type,
-            data: JSON.stringify(event.data),
+            data: serializedData,
             id: `evt_${eventCounter}`,
           });
         },

package/src/server/routes/v1/runs.ts

@@ -1,5 +1,5 @@
 import { Hono } from "hono";
-import type { SignalRunner, SignalQueueAdapter, Run } from "station-signal";
+import type { SignalRunner, SignalQueueAdapter, Run, RunStatus } from "station-signal";
 import type { LogBuffer } from "../../log-buffer.js";
 import type { LogStore } from "../../log-store.js";
 
@@ -19,42 +19,18 @@ export function v1RunRoutes(deps: V1RunDeps) {
   app.get("/runs", async (c) => {
     const status = c.req.query("status");
     const signalName = c.req.query("signalName");
-    const limit = Math.min(parseInt(c.req.query("limit") ?? "50", 10) || 50, 200);
+    const limitRaw = parseInt(c.req.query("limit") ?? "50", 10);
+    const limit = Math.min(Number.isNaN(limitRaw) ? 50 : Math.max(limitRaw, 1), 200);
+    const offsetRaw = parseInt(c.req.query("offset") ?? "0", 10);
+    const offset = Number.isNaN(offsetRaw) ? 0 : Math.max(offsetRaw, 0);
+    const statuses = status ? ([status] as RunStatus[]) : undefined;
 
-    let runs: Run[] = [];
+    // Filtering/ordering/limiting happen in the adapter, not in memory.
+    const runs: Run[] = signalName
+      ? await deps.signalAdapter.listRuns(signalName, { limit, offset, statuses })
+      : await deps.signalAdapter.listAllRuns({ limit, offset, statuses });
 
-    if (signalName) {
-      runs = await deps.signalAdapter.listRuns(signalName);
-    } else if (deps.signalRunner) {
-      const seen = new Set<string>();
-      for (const { name } of deps.signalRunner.listRegistered()) {
-        const signalRuns = await deps.signalAdapter.listRuns(name);
-        for (const r of signalRuns) {
-          if (!seen.has(r.id)) {
-            seen.add(r.id);
-            runs.push(r);
-          }
-        }
-      }
-    }
-
-    if (status) {
-      runs = runs.filter((r) => r.status === status);
-    }
-
-    runs.sort((a, b) => {
-      const aTime = a.createdAt instanceof Date
-        ? a.createdAt.getTime()
-        : new Date(a.createdAt as unknown as string).getTime();
-      const bTime = b.createdAt instanceof Date
-        ? b.createdAt.getTime()
-        : new Date(b.createdAt as unknown as string).getTime();
-      return bTime - aTime;
-    });
-
-    runs = runs.slice(0, limit);
-
-    return c.json({ data: runs.map(serializeRun), meta: { total: runs.length } });
+    return c.json({ data: runs.map(serializeRun), meta: { count: runs.length, limit, offset } });
   });
 
   app.get("/runs/:id", async (c) => {
@@ -78,7 +54,7 @@ export function v1RunRoutes(deps: V1RunDeps) {
 
   app.get("/runs/:id/logs", async (c) => {
     const id = c.req.param("id");
-    const logs = deps.logStore?.get(id) ?? deps.logBuffer.get(id);
+    const logs = deps.logStore ? await deps.logStore.get(id) : deps.logBuffer.get(id);
     return c.json({ data: logs });
   });
 

package/src/server/sse.ts

@@ -2,7 +2,8 @@ import type { StationEvent } from "./ws.js";
 
 export interface SSEClient {
   id: string;
-  send(event: StationEvent): void;
+  /** `serializedData` is `JSON.stringify(event.data)`, computed once per broadcast. */
+  send(event: StationEvent, serializedData: string): void;
   close(): void;
   readonly signalFilter: Set<string> | null;
   readonly broadcastFilter: Set<string> | null;
@@ -25,9 +26,13 @@ export class SSEHub {
   }
 
   broadcast(event: StationEvent): void {
+    // Serialize once per event, not once per client — log-chunk events fan
+    // out to every connected dashboard.
+    let serialized: string | null = null;
     for (const client of this.clients.values()) {
       if (this.matchesFilter(client, event)) {
-        client.send(event);
+        serialized ??= JSON.stringify(event.data);
+        client.send(event, serialized);
       }
     }
   }