Module dash 

The dashboard: resources, the dependency graph, metrics and logs, from the one program.

What it is, and what it is not

Aspire’s dashboard reads two things: an AppHost that declares the topology, and an OTLP feed that reports on it. Beck has no AppHost — [beck_core::graph] explains why — so this reads the compiled program for structure and crate::telemetry for behaviour. The consequence is worth naming: the resource list here cannot disagree with what beck build emits or with what is running, because all three are the same derivation of the same source.

It is not an observability product. It is one screen with four panes over data the process already has, and every number on it is either read off the graph (free) or off an atomic counter (one relaxed load). There is no collector, no database, no retention policy, and no sampling.

Everything is served from memory

The graph is built once at start and never rebuilt — the program does not change while the process runs. Metrics are atomics. Logs are a bounded ring. So every endpoint is O(size of the answer) and none of them touch the log store, which matters: a dashboard that queries the durable log on every refresh is a dashboard that makes the thing it monitors slower.

The page has no external anything — no CDN, no framework, no fonts — for the same reason the thin client does not: an operator’s dashboard should work on a cluster with no egress, and the network policy this very program derives forbids that egress.

The page is hand-written HTML, and should not stay that way

dash.html is a hand-written page served as a string. That is the same thing phase0/ was: the output the compiler ought to generate, written by hand because the compiler could not yet generate it. A dashboard is a view over state — a resource table, a graph, a metrics pane, a log tail — which is precisely the shape page: Signal[Html] = per_session(...) describes. It should be a Beck program, and then the compiler’s own diffing client would stream it, ui: would build it, and it would be the first proof that Beck is good enough to write Beck’s tools in.

What stands in the way is not the view: ui: could express this page today. It is that the dashboard’s state is not a durable fold over an event stream — it is a live read of atomic counters and a compile-time graph — and Beck has no way yet to say “a signal whose value comes from the host”. That is the missing construct, and it is a language question, not a dashboard one. Recorded in docs/19-phase-1-report.md §19.7.

Structs

Dashboard

The compiled facts the dashboard shows, computed once.

ResourceRow

One row of the resource table — an infrastructure object, flattened for display.