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.
C4 zooms into one element at a time:
- Level 1: System context: people and other software systems around one ElastOS node.
- Level 2: Containers: the runnable applications, processes, capsule families, and data store inside that node.
- 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.
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.
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.
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
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.
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
"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.
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
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.
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
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.
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
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.
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
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.
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
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.
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
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.
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
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
@aliasor Contacts-as-DNS authority is shown because this branch does not define or verify one.
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
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.
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
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.
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
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.
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
Wallet Provider never calls Chain Provider directly. Runtime owns the durable transaction effect and coordinates both typed provider contracts.
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
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.
| 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 |