Runtime¶
Atlas product execution resolves immutable dataset releases and runs bounded queries through CLI and HTTP delivery surfaces. The CLI and server are separate composition roots. They reuse runtime configuration, policy, store ports, and domain semantics without moving release authority into a running process.
flowchart TB
Runtime["runtime foundation<br/>config + policy + store ports"] --> CLI["CLI composition root"]
Runtime --> Server["server composition root"]
Ingest["ingest capabilities"] --> CLI
Store["store publication"] --> CLI
Query["query capabilities"] --> CLI
API["API contracts"] --> Server
Query --> Server
Catalog["published catalog + immutable store"] --> Runtime
CLI --> Output["structured command result"]
Server --> HTTP["HTTP result + telemetry"]
Runtime Invariants¶
- The catalog selects a published dataset identity; a request cannot invent one.
- The serving store supplies immutable artifact state; caches do not become release authority.
- Domain and query crates own biological and query semantics; delivery adapters do not redefine them.
- Configuration is resolved before it controls runtime behavior and remains attributable in diagnostics.
- Security, overload, and concurrency boundaries may reject work before query execution.
- Successful output preserves enough release and request context to be interpreted against the owning contract.
Execution Ownership¶
| Boundary | Owner | Responsibility |
|---|---|---|
| command workflow | CLI crate | argument parsing, workflow selection, command output, and direct use-case composition |
| HTTP service | server crate | routing, middleware, request admission, dataset and response caches, and telemetry |
| shared process foundation | runtime crate | configuration, policy, security domains, store ports and adapters, and cluster semantics |
| biological meaning | model and core crates | dataset, feature, region, transcript, and shared contract identity |
| dataset construction | ingest crate | source validation, normalization, and candidate artifact generation |
| query meaning | query crate | planning and execution over verified artifact paths |
| publication | store crate | immutable payload and catalog transitions |
This map matters when behavior disagrees. A response-cache incident belongs to the server path; a query-ordering dispute belongs to the query contract; a store-port failure may cross server and runtime code without making the runtime crate the owner of HTTP behavior.
Runtime Admission Model¶
The running process makes three admissions before a scientific result can be returned. They fail independently and have different recovery owners.
flowchart LR
Start["process startup"] --> Process{"configuration and dependencies admissible?"}
Process -->|no| Stop["fail startup or remain unready"]
Process -->|yes| Traffic{"instance eligible for traffic?"}
Traffic -->|no| Drain["withhold readiness"]
Traffic -->|yes| Request{"principal, dataset, and work admissible?"}
Request -->|no| Reject["typed rejection + audit and telemetry"]
Request -->|yes| Execute["bounded query execution"]
| Admission | Establishes | Does not establish |
|---|---|---|
| process | server configuration is valid and selected adapters can be composed | catalog freshness, target capacity, or caller authority |
| traffic | the server meets the configured readiness contract for its catalog mode | every route is authorized or every query will succeed |
| request | the caller, dataset selection, and work estimate satisfy the applicable policy | biological correctness beyond the selected published artifact |
Treat these as state transitions, not synonyms for “healthy.” A live process may be intentionally unready. A ready process may correctly reject an unauthorized or excessive request. A successful request says nothing about an unexercised failure or capacity boundary.
Follow the Running System¶
| Question | Read |
|---|---|
| How do crates and control planes fit together? | System Overview |
| Where is behavior owned in source? | Source Layout and Ownership |
| How is the concrete runtime assembled? | Runtime Composition |
| What happens from startup to shutdown? | Runtime Process Model |
| How does an HTTP request cross boundaries? | Request Lifecycle |
| How does source data become a release? | Ingest Architecture and Artifact Lifecycle |
| How are queries planned and executed? | Query Architecture |
| Which storage boundary is authoritative? | Storage Architecture and Serving Store Model |
Architecture, Interface, and Operations¶
Runtime architecture explains ownership and execution flow. Exact flags, environment variables, HTTP paths, output shapes, and error codes belong to Interfaces. Compatibility guarantees belong to Contracts. Deployment profiles, observability, capacity, recovery, and release decisions belong to the Operations handbook.
The distinction matters during failure analysis. A runtime explanation can identify the rejecting boundary, but only its interface contract defines the consumer-visible result. Only captured operational evidence establishes what happened in a particular environment.