Struct Server 

pub struct Server { /* private fields */ }

Static-file dev server for one mesofact-static workload.

Implementations

impl Server

pub fn from_workload(workload: impl Into<PathBuf>) -> Result<Server, Error>

Construct a server for a workload directory. Fails if the directory is missing; tolerates a missing dist/html/.

pub fn from_bundle(bundle: impl Into<PathBuf>) -> Result<Server, Error>

Construct a server for a materialized W272 bundle directory (R599-F3; canonical @yah: block in the parent-camp W272 doc — this is the mesofact-subcamp implementation, so a prose pointer only).

A bundle’s app/ subtree is structurally a workload dir — the parent of dist/, which carries dist/html/<key>.html + dist/manifest.json — so bundle serving is Server::from_workload pointed at <bundle>/app, after validating the bundle’s own manifest.toml (identity + runtime).

v0 serves static only (clean-URLs + 404, no V8), which is the whole point: this path builds and runs with the crate compiled --no-default-features (no ssr), so it dogfoods on the current glibc fleet ahead of the musl-static V8 runtime (W272 §5). The isolate / JIT tiers that execute mesofact.routes.ts are R599-F6 follow-on.

A runtime = "self" bundle carries its own bins/<triple>/serve and is meant to be served by that binary, not the stock runtime — we still serve its prerendered static tree, but warn, since executing its custom runtime is out of scope here.

pub fn with_identity( self, service: impl Into<String>, component: impl Into<String>, ) -> Server

Stamp this server with its logical (service, component) identity, exposed at /__mesofact/info for the adopt identity-check (R602-B4).

pub fn with_route_headers(self, table: RouteHeaderTable) -> Server

Attach the domain manifest’s per-route response headers (R749-F3 / W334) — the sovereign path’s half of the Worker’s ROUTE_HEADERS binding, carrying the same JSON table.

The table is applied as the outermost layer of Server::router, so there is no response — asset, clean-URL, SPA shell, SSR proxy, or branded 404/410/500 — that can be returned without going through it. That is deliberate: an error page that drops COOP/COEP un-isolates the document and takes SharedArrayBuffer with it, and nothing on the server side would say so.

pub fn with_cache_policy(self, table: CachePolicyTable) -> Server

Enforce the built manifest’s cache_policy on every response (R749-T1).

The serve tier’s consumer for a field that previously had exactly one, in a subcommand this binary’s bundle path never runs. See crate::cache_headers for the derivation table and why this layer sits inside with_route_headers and outside the handlers.

pub fn workload(&self) -> &Path

pub fn pointer(&self) -> DistPointer

Clone of the shared pointer — hand to a mesofact_dev::Watcher so its rebuilds can flip the served snapshot.

pub fn dist_dir(&self) -> PathBuf

Current served path. Initial value is <workload>/dist/html/; a mesofact_dev::Watcher will swap this to <workload>/.mesofact-dev/gen-<N>/html/.

pub fn with_ssr(self, ssr: SsrChild) -> Server

Attach an SSR child. Requests whose path matches one of its prefixes are proxied to the bun subprocess; everything else falls through to the static handler. See [ssr::spawn] for the spawn contract.

Also marks the workload as SSR-expecting, which puts the isolate on the /readyz critical path: an SSR site with no live isolate can only 502, so it must not be in a Service’s endpoint set.

pub fn with_proxy(self, map: ProxyMap) -> Server

Install a same-origin reverse proxy. Requests whose path matches one of the map’s prefixes (/auth/*, /dev/*, /api/* …) are forwarded to the mapped backend port before static serving; everything else falls through to the SPA. A no-op when the map is empty. See crate::proxy and W207 Gap #1 (R513-F10).

pub fn with_instance_store(self, store: Arc<dyn ObjectStore>) -> Server

Attach the object store that backs instance-addressed (deferred) route resolution (W270 §9). In dev this is an S3Store pointed at the local dev-S3 surface (mesofact_dev::DevStore) — the same store the publisher flips pointers and writes render-root bytes into, so the local publish → view loop resolves a /<slug> the way the edge worker does against R2. Absent → deferred routes fall through to the 404 page.

pub fn with_config_json(self, bytes: Vec<u8>) -> Server

Serve bytes verbatim at /config.json (R513-F10, the F5 config seam). This is runtime config the camp emits at SPA-service spawn — NOT a build artifact, so it is injected by the server rather than dropped into the served dist/. Absent → /config.json falls through to the SPA (and the browser adapter uses its mock fallback), so an Option-A pipeline serving the same dist/ never inherits a stale env:ci config.

pub fn ssr_slot(&self) -> SsrSlot

Clone of the SSR slot — hand to the watcher’s post-build hook so it can swap in (or restart) the bun child on each successful rebuild. Reads via SsrSlot::current are lock-free for the request path.

pub fn health(&self) -> Arc<Health>

The probe handle behind /livez + /readyz. Hand to a supervisor that wants to drain this server on its own schedule.

pub fn without_standard_probes(self) -> Server

Skip mounting the standard probe routes on Server::router.

The Rust-level override seam: a service that wants its own /livez or /readyz — different wire format, an auth gate, a different set of invariants — mounts them itself instead of fighting axum’s overlapping-route panic. Server::health still works, so the drain half of the shutdown path is unaffected by opting out.

Extending rather than replacing is the cheaper move: install a ReadyCheck and keep the standard wire contract that every chart and dashboard already understands.

pub fn router(&self) -> Router

Build the axum Router. Exposed for tests + the future embedded paths (T3 reconciler).

pub async fn serve(self, port: u16) -> Result<(), Error>

Bind to 127.0.0.1:port and serve until Ctrl+C / SIGTERM. The dev loopback default; the mesofact serve container path uses Server::serve_on to bind a routable address instead.

pub async fn serve_on(self, addr: SocketAddr) -> Result<(), Error>

Bind an explicit addr and serve until Ctrl+C / SIGTERM. The SSR-host container (mesofact serve, R449-F3) binds 0.0.0.0:<port> so miniflare — running in a sibling container — can reach it over the pond docker bridge; loopback-only would be unreachable.

pub async fn serve_on_listener( self, listener: TcpListener, idle_ttl: Option<Duration>, ) -> Result<(), Error>

Serve on an already-bound listener, with an optional JIT idle-reap (R599-F6). Two properties beyond [serve_on]:

• Adopts the given socket. The listener may have been created by someone else — the on-demand (“serverless”) lifecycle has kamaji’s SocketCustodian bind + hold the listen socket and hand this process the fd (systemd LISTEN_FDS, since the mesofact binary is our own). Adopting the fd instead of binding fresh is what lets the socket (and its accept queue) outlive each forked runtime process, so no connection is dropped across a reap → re-fork (W272 §3).
• Self-reaps when idle. With idle_ttl set, a background watcher triggers graceful shutdown once no request has been in flight for that long. The runtime — not kamaji — owns idle detection, keeping the supervisor out of the data path (no-impressive-mesh); kamaji just re-forks on the next connection to the socket it still holds. None = keep-alive (today’s resident behavior).