Skip to content

Latest commit

 

History

History
662 lines (554 loc) · 30.4 KB

c4.md

File metadata and controls

662 lines (554 loc) · 30.4 KB

C4 model

This is the layered architecture map for ElastOS. It uses the C4 model zoom levels, with small diagrams that each answer one question. The diagrams use standard Mermaid flowcharts and sequence diagrams so they render in GitHub and can be copied one at a time into Mermaid Live.

This file is a navigation projection, not release evidence. Stable constraints come from PRINCIPLES.md and ARCHITECTURE.md. Current implementation and proof posture and open work come from GitHub issues.

The interactive viewer is a navigable projection of this file, not a second model. Its source hash is checked by node scripts/system-map-check.mjs whenever either representation changes.

How to read the model

C4 zooms into one element at a time:

  1. Level 1: System context: people and other software systems around one ElastOS node.
  2. Level 2: Containers: the runnable applications, processes, capsule families, and data store inside that node.
  3. Level 3: Components: the main responsibilities inside a selected container. This map expands the Runtime host, Home, and collaboration.

Dynamic, trust-boundary, identity, deployment, and code-ownership views support those three levels. They are not additional zoom levels. The code-ownership view is a path map, not a C4 Level 4 claim.

Readiness labels

The diagrams mark an element candidate or target only when that distinction prevents a false current-product claim. They do not define a second readiness vocabulary. All implementation and product-proof status comes from GitHub issues; source presence or an unlabeled diagram element is not acceptance evidence.

Implementation evidence

The diagrams describe ownership. Adapter differences, deployment capabilities and verification results belong in the owning GitHub issue, with the exact source and target evidence for each claim.

Capsule membership is intentionally not repeated here. Use components.json for the component catalog and install profiles, and the code and product tree to locate implementations.

Level 1: System context

Question: Who uses an ElastOS node, and which external systems can it reach?

flowchart LR
  person["Person<br/>[Person]"]
  operator["Operator<br/>[Person]"]
  node["ElastOS node<br/>Home, Runtime, capsules, providers, state, and audit<br/>[Software System]"]
  publisher["Trusted publisher<br/>Signed releases<br/>[External Software System]"]
  peers["Peer ElastOS nodes<br/>[External Software Systems]"]
  web["Public web and edge services<br/>[External Software Systems]"]
  chains["Blockchain and DID networks<br/>[External Software Systems]"]
  content["Content and availability backends<br/>[External Software Systems]"]
  wallets["External wallet tools<br/>[External Software Systems]"]
  ai["AI inference backends<br/>[External Software Systems]"]

  person -->|"Authenticates to Home, launches Apps, approves effects"| node
  operator -->|"Installs, configures, inspects"| node
  publisher -->|"Signed manifests and artifacts"| node
  node -->|"Carrier: endpoint-authenticated transport for private services, peer messages, and content"| peers
  node -->|"Runtime-selected Net / Exit operations"| web
  node -->|"Typed chain, identity, and provenance operations"| chains
  node -->|"Publish, fetch, verify, replicate, repair"| content
  node -->|"Exact connector-owned proof or approval"| wallets
  node -->|"Provider-routed inference"| ai
Loading

The node is the only ElastOS software system at Level 1. Carrier is not another top-level system and elastos:// is not Carrier. The line to peer nodes is the off-box Carrier relationship; ordinary Apps never receive that transport authority.

Exit is a typed egress service. Carrier is peer transport. Runtime may reach a remote Exit over Carrier, but the two responsibilities do not collapse. The content and key paths carry encrypted objects, sealed key material, and bounded receipts. A live CEK remains inside reviewed key-release and decrypt custody; it never enters Runtime, Carrier, or an ordinary App.

Level 2: Containers

Question: What runs inside one ElastOS node, and which container owns each kind of responsibility?

flowchart TB
  person["Person<br/>[Person]"]

  subgraph node["ElastOS node [Software System]"]
    home["Home front door<br/>Sign-in and shell lifecycle<br/>[Container: HTML / JavaScript]"]
    projections["Shell and App projections<br/>Product facts and intents<br/>[Container family: web projections]"]
    host["elastos host<br/>Authority, orchestration, routing, lifecycle, audit<br/>[Container: Rust / Tokio / Axum]"]
    executables["Executable capsule instances<br/>Bounded admitted code<br/>[Container family: Component or microVM]"]
    providers["Provider capsule processes<br/>Typed protocol and backend implementations<br/>[Container family: process or microVM]"]
    adapters["Host and engine adapters<br/>Browser, stream, VM, and edge helpers<br/>[Container family: native processes]"]
    data[("Runtime data home<br/>Principal roots, capsule state, receipts, audit<br/>[Data store]")]
  end

  backends["External backends<br/>Web, chain, content, wallets, AI<br/>[External Systems]"]
  peer["Peer ElastOS node<br/>[External System]"]

  person -->|"Uses"| home
  home -->|"Mounts one shell and launches Apps"| projections
  home -->|"Authenticates and requests exact launches"| host
  projections -->|"Narrow Runtime routes"| host
  host -->|"Admits, launches, supervises"| executables
  executables -->|"ElastOS Bus or narrow adapter"| host
  host -->|"Supervises and invokes typed operations"| providers
  host -->|"Controls through private contracts"| adapters
  host -->|"Owns and protects"| data
  providers -->|"Use Runtime-brokered hosted route or local protocol"| backends
  adapters -->|"Reach selected host or edge target"| backends
  host -->|"Carrier, only for an explicit peer route"| peer
Loading

"Container family" groups instances that share one architectural role. It does not claim they all use the same process or execution substrate. Provider capsules are containers beside the host, not components inside it. The built-in Carrier integration is expanded as a host component at Level 3.

Current web projections can reach Runtime through live host adapters such as POST /api/provider/:scheme/:op. That route is an implementation adapter, not the capsule ABI shown by the ElastOS Bus or narrow adapter relationship.

Level 3: Runtime host components

Question: How does the trusted host turn an intent into an authorized local operation, provider call, or explicit peer route?

flowchart LR
  callers["Home, projection, or executable<br/>[External containers]"]

  subgraph host["elastos host [Container]"]
    ingress["Gateway and Runtime ingress<br/>Route, origin, token, request shape<br/>[Component]"]
    identity["Identity and sessions<br/>Principal, proof, expiry, revocation<br/>[Component]"]
    authority["Launch and capability authority<br/>Caller, resource, action, constraints<br/>[Component]"]
    lifecycle["Capsule admission and lifecycle<br/>Artifact, instance, cleanup<br/>[Component]"]
    switchboard["Provider registry and route switchboard<br/>Typed namespace owner and placement<br/>[Component]"]
    local["Local dispatcher<br/>In-process, stdio, IPC, or vsock<br/>[Component]"]
    carrier["Carrier adapter<br/>Endpoint-authenticated peer transport and local admission buffer<br/>[Component]"]
    namespace["Namespace and storage resolver<br/>Principal roots, objects, CIDs, WebSpaces<br/>[Component]"]
    effects["Durable effects and audit<br/>Intent, denial, result, receipt, cleanup<br/>[Component]"]
  end

  provider["Local provider capsule<br/>[External container]"]
  peerIngress["Peer Runtime admission<br/>Transport source, service, operation policy<br/>[External component]"]
  peerProvider["Peer provider<br/>Typed operation semantics<br/>[External container]"]
  store[("Runtime data home<br/>[Data store]")]

  callers -->|"Exact typed request"| ingress
  ingress --> identity
  identity --> authority
  authority -->|"Launch / stop"| lifecycle
  authority -->|"Runtime-owned object operation"| namespace
  authority -->|"Provider-backed operation"| switchboard
  switchboard -->|"Same-node route"| local
  local -->|"Typed invocation"| provider
  switchboard -->|"Explicit peer route"| carrier
  carrier -->|"Typed envelope over endpoint-authenticated transport"| peerIngress
  peerIngress -->|"Admitted destination operation"| peerProvider
  lifecycle --> effects
  namespace --> effects
  switchboard --> effects
  effects --> store
  namespace --> store
Loading

The switchboard owns the fork. A capsule asks for a typed resource and does not choose a host path, backend, peer, "local," or "Carrier." Local dispatch and an off-box Carrier route are alternatives. They are not mandatory consecutive hops.

Source-side authorization does not transfer authority to the peer. The receiving Runtime separately admits the transport source, target service, operation, and any application signature, delegation, freshness, or replay contract required by that provider. Carrier endpoint authentication is one input to that decision, not application authorship or capability policy.

The collaboration candidate also uses Carrier's authenticated admission path for a same-endpoint route. Direct messages and Profile updates loop back through the local registry without opening a network connection. Direct delivery keeps the same signed envelope and signed acceptance receipt as the remote contract. This is an implementation detail inside the Runtime boundary, not a capsule-to-Carrier contract. It is separate from a shared-room local_only buffer, which reports that no remote peer received the item.

Level 3: Home components

Question: What does Home own before an intent reaches Runtime?

flowchart LR
  person["Person<br/>[Person]"]

  subgraph home["Home front door [Container]"]
    authui["Authentication UI<br/>Home-origin passkey ceremonies<br/>[Component]"]
    shellmgr["Shell manager<br/>Mounts one active shell<br/>[Component]"]
    children["Child registry<br/>Source window, target, generation, token<br/>[Component]"]
    launch["Launch bridge<br/>Exact shell and App intent<br/>[Component]"]
    edges["Closed edge adapters<br/>Clipboard and wallet connector schemas<br/>[Component]"]
  end

  frames["Shell and App projections<br/>Opaque sandboxed frames<br/>[External containers]"]
  runtime["elastos host<br/>Launch and effect authority<br/>[External container]"]

  person --> authui
  authui -->|"Passkey ceremony result"| runtime
  authui --> shellmgr
  shellmgr -->|"Creates and retires"| frames
  frames -->|"Typed host intent"| children
  children --> launch
  launch -->|"Launch request"| runtime
  frames -->|"Allowlisted device-edge request"| edges
  edges -->|"Validated exact effect"| runtime
Loading

Home can present facts, collect human intent, and perform narrowly allowlisted device-edge work. It cannot mint its own capabilities, turn a role label into authority, or pass ambient Home access to a child frame.

Level 3: Collaboration candidate

Question: How do People, Inbox, and Chat share one Runtime-owned Profile and delivery authority without seeing Carrier topology?

flowchart LR
  people["People projection<br/>Profile, discovery, contacts<br/>[External container]"]
  inbox["Inbox projection<br/>Contact approval<br/>[External container]"]
  chat["Chat projection<br/>Direct and configured conversation UI<br/>[External container]"]

  subgraph host["elastos host [Container]"]
    routes["Collaboration product routes<br/>Typed People, Inbox, Chat ports<br/>[Component · candidate]"]
    profile["ProfileAuthority<br/>Protected key and signed Profile head<br/>[Component · candidate]"]
    discovery["Discovery and presence service<br/>Bounded signed advertisements<br/>[Component · candidate]"]
    contacts["Contact and direct-message stores<br/>Approval, relationship, delivery state<br/>[Component · candidate]"]
    conversation["Configured conversation core<br/>Signed messages, receipts, durable outbox<br/>[Component · candidate]"]
    delivery["Collaboration delivery workers<br/>Bounded retry and settlement<br/>[Component · candidate]"]
    carrier["Carrier integration<br/>Gossip and provider invocation<br/>[Component]"]
  end

  roots[("Protected principal roots and collaboration state<br/>[Data store]")]
  peer["Peer Runtime collaboration service<br/>[External system]"]

  people --> routes
  inbox --> routes
  chat --> routes
  routes --> profile
  routes --> discovery
  routes --> contacts
  routes --> conversation
  profile --> roots
  discovery --> roots
  contacts --> roots
  conversation --> roots
  profile -->|"Signed Profile updates"| delivery
  discovery -->|"Signed advertisements and presence"| carrier
  contacts --> delivery
  conversation --> delivery
  delivery -->|"Opaque signed envelopes"| carrier
  carrier -->|"Off-box only when a peer is selected"| peer
Loading

The Profile DID represents the person or contact in collaboration. The Device DID identifies a delivery endpoint. The collaboration-network signer configures bootstrap and a bounded default-conversation grant; it is not person, contact, or message authority. Product projections receive typed facts and outcomes, never tickets, topics, raw sockets, or endpoint credentials.

Level 3: Agent Host target

Question: Where would an agent harness live without creating a second authority system?

Every element in this view is target unless the surrounding Runtime or provider already exists independently.

flowchart LR
  person["Person<br/>Starts, resumes, cancels, approves<br/>[Person]"]
  home["Home or Inbox<br/>Session and approval presentation<br/>[External container]"]

  subgraph agent["Agent Host capsule instance [Target container]"]
    session["Task-session supervisor<br/>Resume, cancel, lifecycle<br/>[Component]"]
    context["Context and memory builder<br/>Principal-owned task state<br/>[Component]"]
    modelclient["Model client<br/>Typed inference requests<br/>[Component]"]
    planner["Planner and tool interpreter<br/>Proposals, never grants<br/>[Component]"]
    proposer["Effect proposer<br/>Exact typed Runtime operations<br/>[Component]"]
    journal["Task journal<br/>Conversation, progress, result references<br/>[Component]"]
  end

  runtime["Runtime authority<br/>Agent principal, proof, session, capsule, grants, lifecycle, audit<br/>[External container]"]
  model["Model provider<br/>Inference semantics; Runtime brokers hosted HTTPS<br/>[External container]"]
  effects["Effect providers<br/>Content, messaging, Browser, wallet, chain, storage<br/>[External containers]"]
  roots[("Agent principal roots<br/>UsersAI task and memory state<br/>[Data store]")]

  person --> home
  home -->|"Start / resume / cancel / approval intent"| runtime
  runtime -->|"Launches bounded instance"| session
  session --> context
  context --> modelclient
  modelclient -->|"Inference request through Runtime"| runtime
  runtime --> model
  model -->|"Model output or tool proposal"| runtime
  runtime --> modelclient
  modelclient --> planner
  planner --> proposer
  proposer -->|"Proposed effect"| runtime
  runtime -->|"Only after capability or approval"| effects
  effects -->|"Audited bounded result"| runtime
  runtime --> proposer
  session --> journal
  context --> roots
  journal --> roots
Loading

The model, planner, and harness cannot authorize their own effects. Interactive approval and a future mandate both resolve to Runtime capabilities. Hosted credentials remain in Runtime's private route; provider protocols stay behind their contracts. The complete Agent Host, public agent identity, private persona and model configuration, durable approval recovery, and mandate path are not shipped claims; the human and agent architecture owns the session and authority contract. The model provider contract owns selection, streaming, cancellation, and terminal inference behavior.

Supporting view: trusted host code ownership

Question: Which Rust crates and code areas implement the Level 3 host responsibilities?

flowchart TB
  server["elastos-server<br/>Binary, gateway, orchestration, Carrier, collaboration, supervisors<br/>[Crate / code area]"]
  runtime["elastos-runtime<br/>Capabilities, sessions, capsules, invoke, provider registry, audit<br/>[Crate / code area]"]
  identity["elastos-identity<br/>Passkey and local identity support<br/>[Crate]"]
  auth["elastos-auth<br/>Proof-bound authorization contracts<br/>[Crate]"]
  namespace["elastos-namespace + elastos-storage<br/>Rooted names and persistence<br/>[Crates]"]
  compute["elastos-compute<br/>Execution-substrate abstraction<br/>[Crate]"]
  crosvm["elastos-crosvm<br/>Linux VM adapter<br/>[Crate]"]
  vz["elastos-vz<br/>macOS VM adapter workspace sibling<br/>[Crate]"]
  common["elastos-common + elastos-guest<br/>Shared contracts and guest Bus SDK<br/>[Crates]"]
  wallet["elastos-wallet-contract<br/>Wallet Bus schema<br/>[Crate]"]

  server -->|"Composes"| runtime
  server -->|"Uses"| identity
  server -->|"Uses"| namespace
  server -->|"Uses"| compute
  server -->|"Composes"| crosvm
  server -->|"Uses"| wallet
  runtime -->|"Uses"| auth
  runtime -->|"Uses"| namespace
  runtime -->|"Uses"| compute
  runtime -->|"Uses"| common
  compute -->|"Uses guest execution model"| common
  crosvm -->|"Implements execution adapter"| compute
  vz -->|"Implements execution adapter"| compute
Loading

This supporting view stops at crate granularity and does not claim to be a C4 Level 4 code diagram. The code and product tree locates the relevant modules; the crate manifests define the exact dependency graph.

Trust-boundary view

Question: Which boundary changes an untrusted intent into an admitted effect?

flowchart LR
  subgraph presentation["Presentation boundary"]
    human["Human action"]
    agent["Agent proposal<br/>[target host model]"]
    surface["Home, shell, App, or capsule adapter<br/>No ambient authority"]
  end

  subgraph trusted["Trusted Runtime boundary"]
    edge["Ingress validation<br/>Origin, route, shape, token"]
    gate["Identity, session, capability, grant"]
    route["Runtime operation or provider route"]
    audit["Durable effect and audit record"]
  end

  subgraph service["Typed service boundary"]
    provider["Provider<br/>Protocol semantics; Runtime owns hosted credentials"]
  end

  world["Host, peer, chain, content, wallet, web, or model backend"]

  human --> surface
  agent --> surface
  surface -->|"Intent only"| edge
  edge --> gate
  gate --> route
  route -->|"Admitted typed operation"| provider
  route --> audit
  provider -->|"Provider-owned protocol"| world
  provider -->|"Validated outcome"| audit
Loading

A model, harness, projection, approval card, discovery record, or provider can propose or carry an operation. Runtime remains the enforcement point. A provider owns protocol behavior only after Runtime admits the exact caller and operation.

Identity overlay

Question: Which identifiers name authority subjects, people, endpoints, software, and immutable bytes?

flowchart LR
  passkey["Passkey<br/>Human proof"] -->|"Accepted proof for"| session["Session<br/>Runtime-owned short-lived authority context"]
  principal["Principal<br/>Local Runtime authority subject"] -->|"Bound by Runtime into"| session

  profileauth["ProfileAuthority<br/>Protected signing authority"] -->|"Signs"| profile["Profile DID<br/>Person / contact identity"]
  profile -->|"Authorizes current delivery binding"| device["Device DID<br/>Runtime / Carrier endpoint"]
  network["PrivateNetwork revision<br/>Signed membership and service policy<br/>[target]"] -->|"Admits one enrolled endpoint"| device
  profile -.->|"May name an invited member"| network

  package["Capsule package identity<br/>Publisher and admitted manifest"] -->|"Binds immutable artifact"| artifact["Artifact CID or verified hash<br/>Exact package bytes"]
  object["Mutable object or collection"] -->|"Revision may be content-addressed as"| cid["CID<br/>Immutable revision bytes"]
  objectdid["Optional object DID<br/>[target, only if explicitly minted]"] -.->|"Signed head may select"| cid
Loading

These labels must not be collapsed:

  • a passkey is not a DID;
  • the human actor, local principal, signed Profile, and Device DID remain separate even when one person controls all four;
  • a principal is bound into a Runtime-owned session; it does not mint or own session authority;
  • a Profile DID is not a Device DID or Carrier peer;
  • a PrivateNetwork revision uses separate protected policy authority. It may name a Profile or Device DID but is not part of ProfileAuthority;
  • a CID names immutable bytes, not a person or a live mutable collection;
  • a CID does not need its own DID by default;
  • "every object has a DID" is not current architecture. An object DID is an optional target for a mutable object identity with a signed head;
  • no global @alias or Contacts-as-DNS authority is shown because this branch does not define or verify one.

Dynamic view: launch

Question: How does one launch cross the same authority path for a web projection, Component, or microVM?

sequenceDiagram
  actor Person
  participant Home
  participant Ingress as Runtime ingress
  participant Identity as Identity / session
  participant Authority as Launch authority
  participant Lifecycle as Capsule lifecycle
  participant Target as Projection or executable instance

  Person->>Home: Open an installed target
  Home->>Ingress: Exact launch intent
  Ingress->>Identity: Validate origin, proof, principal, and session
  Identity-->>Ingress: Bound identity context
  Ingress->>Authority: Check target, actors, resource, grant, expiry
  Authority->>Lifecycle: Admit exact package and create lifecycle
  alt Web projection
    Lifecycle-->>Home: Target-scoped route and launch token
    Home->>Target: Mount opaque sandboxed frame
  else Component or microVM
    Lifecycle->>Target: Start bounded admitted instance
    Lifecycle-->>Home: Return projection or session facts
  end
Loading

The substrate changes how the target runs, not who grants authority. Source presence of the Component path does not imply that the first-party UI Apps have migrated from web projections.

Dynamic view: typed effect and route choice

Question: Where is the local-versus-Carrier decision made?

sequenceDiagram
  participant Caller as Projection or capsule
  participant Runtime as Runtime authority
  participant Router as Provider switchboard
  participant Local as Local provider
  participant Carrier as Carrier adapter
  participant PeerAuth as Peer Runtime admission
  participant PeerProvider as Peer provider
  participant Audit as Effect and audit store

  Caller->>Runtime: Typed resource + operation + exact input
  Runtime->>Runtime: Bind principal, proof, session, capability
  alt Runtime-owned operation
    Runtime->>Runtime: Execute trusted core operation
  else Same-node provider route
    Runtime->>Router: Authorized provider request
    Router->>Local: Typed local invocation
    Local-->>Router: Validated result
    Router-->>Runtime: Result
  else Explicit off-box provider route
    Runtime->>Router: Authorized request + selected peer route
    Router->>Carrier: Typed provider envelope
    Carrier->>PeerAuth: Endpoint-authenticated transport
    PeerAuth->>PeerAuth: Admit source, service, operation, authority, freshness
    PeerAuth->>PeerProvider: Admitted typed invocation
    PeerProvider-->>PeerAuth: Validated result
    PeerAuth-->>Carrier: Typed result
    Carrier-->>Router: Result
    Router-->>Runtime: Result
  end
  Runtime->>Audit: Record intent, route, result, and obligations
  Runtime-->>Caller: Bounded result
Loading

There is no Caller → Carrier edge. The caller cannot select a host path, backend, peer, ticket, socket, or transport. Same-endpoint Carrier loopback, where a contract requires Carrier admission semantics, stays inside Router and Carrier and does not open an off-box connection. For a remote route, the destination Runtime performs its own admission; the source capability and authenticated Carrier connection do not silently authorize the destination provider.

Dynamic view: configured conversation send

Question: How does the collaboration candidate send one message without exposing Carrier details to Chat?

sequenceDiagram
  actor Person
  participant Chat as Chat projection
  participant Port as Runtime Chat product port
  participant Core as Durable conversation core
  participant Worker as Collaboration worker
  participant Carrier as Built-in Carrier integration
  participant Peer as Peer Runtime

  Person->>Chat: Send message
  Chat->>Port: Typed Chat request with scoped launch context
  Port->>Core: Prepare signed Profile-authenticated envelope
  Core-->>Port: Durable outgoing record
  Port-->>Chat: Prepared product projection
  Worker->>Core: Read bounded pending batch
  Core-->>Worker: Opaque signed transport frame
  Worker->>Carrier: Send on exact verified collaboration network
  alt No remote peer
    Carrier-->>Worker: Local-only buffered, no network connection
  else Remote peer available
    Carrier->>Peer: Iroh gossip transport
    Peer-->>Carrier: Signed acceptance receipt
    Carrier-->>Worker: Received opaque receipt
  end
  Worker->>Core: Verify, settle, or retain for bounded retry
Loading

This sequence is the configured shared-conversation path. Direct messages, contact changes, Profile updates, and discovery have different signed artifacts and stores, but share Runtime-owned validation, bounded delivery, and settlement principles.

Dynamic view: wallet transaction effect

Question: Which component coordinates prepare, sign, broadcast, and reconciliation?

sequenceDiagram
  participant App as Wallet, Inbox, Browser, or requesting App
  participant Runtime as Runtime transaction-effect coordinator
  participant Chain as Chain Provider
  participant Wallet as Wallet Provider
  participant Audit as Durable effect store

  App->>Runtime: Exact transaction intent
  Runtime->>Audit: Create durable effect before dispatch
  Runtime->>Chain: Prepare chain-specific transaction
  Chain-->>Runtime: Canonical prepared intent
  Runtime->>Wallet: Approve and sign exact prepared intent
  Wallet-->>Runtime: Signature / signed transaction
  Runtime->>Chain: Broadcast exact signed transaction
  Chain-->>Runtime: Validated outcome or uncertain status
  Runtime->>Wallet: Attach validated chain outcome
  Runtime->>Audit: Settle or retain reconciliation obligation
  Runtime-->>App: Bounded terminal or pending result
Loading

Wallet Provider never calls Chain Provider directly. Runtime owns the durable transaction effect and coordinates both typed provider contracts.

Deployment view: one node and one peer

Question: Where do the Level 2 containers run on a local installation?

flowchart LR
  subgraph client["Person device [Deployment node]"]
    browser["Browser or installed PWA<br/>[Execution environment]"]
    home["Home front door<br/>[Container instance]"]
    projections["Shell and App projections<br/>[Container instances]"]

    browser -->|"Loads"| home
    home -->|"Mounts"| projections
  end

  subgraph machine["ElastOS host machine [Deployment node]"]
    host["elastos process<br/>Gateway, Runtime, Carrier, collaboration<br/>[Container instance]"]
    providers["Provider processes<br/>Typed service implementations<br/>[Container instances]"]
    native["Native helpers and engine adapters<br/>Supervisor, stream, edge processes<br/>[Container instances]"]
    component["Optional Component instance<br/>Wasmtime Component Model<br/>[Execution environment]"]
    vm["Optional capsule or Browser VM<br/>crosvm/KVM or Apple VZ<br/>[Execution environment]"]
    data[("Stable Runtime data home<br/>Identity, principal roots, capsules, provider config, audit<br/>[Data store]")]
  end

  peer["Peer ElastOS host<br/>Runtime + Carrier endpoint<br/>[Deployment node]"]
  external["Selected external backend<br/>[Deployment node]"]

  home -->|"HTTPS / loopback Home adapter"| host
  projections -->|"Narrow Runtime routes"| host
  host -->|"Private typed IPC"| providers
  host -->|"Private control contracts"| native
  host -->|"Hostcalls / ElastOS Bus"| component
  host -->|"vsock or scoped host adapter"| vm
  host -->|"Owns"| data
  providers -->|"Provider-owned protocol"| external
  native -->|"Selected engine or edge path"| external
  host -->|"Carrier: authenticated off-box transport"| peer
Loading

Execution-environment presence is not support evidence. Platform readiness, installed artifact parity, Browser media/input behavior, and cleanup proof stay in GitHub issues and the target-specific verification documents.

This is a generic deployment view. Assign each target only the roles supported by its verified host capabilities. A gateway may consume a remote Browser engine without hosting a local Browser VM.

Traceability

View Canonical evidence and detail
System context and containers PRINCIPLES.md, ARCHITECTURE.md, components.json
Runtime host elastos-runtime, elastos-server, Carrier
Home Home shell host contract, capsules/home
Collaboration People and conversations, elastos-server/src/collaboration_*
Identity Glossary, Architecture: identity and object claims
Private network and remote services Private network, Carrier, Browser capsule
Agent and model lifecycle Human and agent architecture, Model provider
Protected content and dKMS Protected content, Carrier, Principle 15
Launch and effects Capsule model, Capsule interface contract, Consequence-aware effects, ElastOS Bus WIT
Wallet effect Wallet provider contract, gateway_transaction_effects.rs
Deployment Install guide, Browser capsule