frame-host 0.2.1

Frame host server and embedding seam — boots an application's frame-core component tree with an embedded liminal bus, announces the host's real application events on the bus, and serves the built frame page
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

//! The full frame server: one binary, one config, one start command.
//!
//! `frame-host --config frame.toml` boots the entire stack in a single process:
//!
//! - the **embedded liminal component** ([`embedded`]) — liminal's TCP wire
//!   listener, browser WebSocket listener, and health endpoint, running
//!   in-process on liminal's own threads (no child process, no side-by-side
//!   server); the host owns its lifecycle but not its bytes;
//! - the **frame-core host authority** ([`runtime`]) — the host-owned
//!   capability table reached only through
//!   [`frame_core::capability::HostCapabilityFacade`], the component registry,
//!   and supervised lifecycle, around the class-(b) client-native graph view
//!   under the `frame:graph-view@v1` contract (D10);
//! - the **console HTTP server** ([`server`]) — the static browser bundle,
//!   `GET /frame/config.json`, `GET /frame/app/status.json` (the
//!   application-truth snapshot, [`truth`]), and the same-origin
//!   `/frame/bus/*` health proxy routes ([`bus_proxy`]).
//!
//! Per ruling D3 the browser is a bus PARTICIPANT: the served page connects
//! to the embedded bus directly over the WebSocket transport. This host
//! never proxies or terminates that feed; `/frame/config.json` is DERIVED at
//! runtime from the embedded component's real bound WebSocket address
//! (served as `busEndpoint`), so the page's endpoint and the server's
//! address can never drift.
//!
//! Console-first (D9): every component lifecycle transition and capability
//! denial is logged to stdout as it happens.
//!
//! ## The embedding seam
//!
//! frame-host is also a library: an embedding application supplies an
//! [`AppSpec`] (its component installs, stated runtime policy, readiness
//! proof, and fact announcements) and [`run_application`] boots the whole
//! stack around it — [`app`] is this binary's own composition riding the
//! same seam. The [`announcer`] publishes the host authority's real events
//! (lifecycle transitions, capability denials, application facts) on
//! `[frame].channel` over its OWN native participant connection: the page
//! server still carries zero feed bytes (D3) — the host is a node on the
//! bus, never a proxy in front of it.

pub mod announcer;
pub mod app;
pub mod application;
pub mod bus_proxy;
pub mod cli;
pub mod config;
pub mod doc_binding;
pub mod embedded;
pub mod error;
pub mod manifest;
pub mod runtime;
pub mod serve;
pub mod server;
pub mod spec;
pub mod syntax_theme;
pub mod truth;

pub use announcer::Announcer;
pub use app::run;
pub use application::{Application, run_application};
pub use cli::Cli;
pub use config::{DocumentSection, FrameConfig, FrameSection};
pub use error::HostError;
pub use spec::{AppError, AppSpec, ComponentInstall};
pub use syntax_theme::default_syntax_theme;
pub use truth::{AppTruth, AppTruthSnapshot};