# cbournhonesque/lightyear architecture

> Architecture diagram of the GitHub repository cbournhonesque/lightyear, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-06-17). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/cbournhonesque/lightyear
- Repository: https://github.com/cbournhonesque/lightyear

## Overview

1. **What this repository is**
   - Lightyear is a Rust workspace for building **server-authoritative multiplayer games on Bevy**.
   - The repo is split into reusable crates rather than a single application, so the architecture is layered: low-level transport at the bottom, networking/session layers above that, then replication/input/sync features, then Bevy integrations and examples on top.

2. **Primary runtime model**
   - The core runtime is a **Bevy plugin-based ECS system**.
   - Games typically run as a **client**, **server**, or **shared** Bevy app, with plugins wiring network events into ECS resources, components, and systems.
   - Most subsystems are designed to operate on ticks/timelines so that simulation, inputs, replication, and prediction stay aligned.

3. **Transport and packet layer**
   - `crates/transport/transport` is the packet/channel engine: it handles **packet framing, compression, priorities, fragmentation, acknowledgements, and reliability modes**.
   - `crates/transport/messages` defines the **typed message API** that sits on top of packet transport.
   - `crates/transport/serde` provides the **serialization layer** used to encode messages and entity references.
   - This layer is the boundary between game/network semantics and raw bytes.

4. **Connection and session establishment**
   - `crates/connection` contains abstractions for **client/host/server identities, connection roles, targets, and shared networking state**.
   - Subcrates implement specific connection strategies:
     - `netcode` for authenticated secure client/server sessions
     - `raw_connection` for simpler direct connections
     - `steam` for SteamWorks-based networking
   - These crates define how peers authenticate, identify each other, and map logical peers onto transport endpoints.

5. **I/O backends and network plumbing**
   - `crates/io` contains the actual transport backends:
     - `udp` for native socket networking
     - `websocket` and `webtransport` for browser-compatible networking
     - `aeronet` and `crossbeam` for other runtime/link-style backends
     - `link` for local/test network conditioning and simulated link behavior
   - These backends are the lowest boundary before packets leave the process, and they are what make the stack transport-agnostic.

6. **Core time, sync, and simulation alignment**
   - `crates/core/core` provides shared primitives like **tick handling, time tracking, interpolation, prediction history, and timeline management**.
   - `crates/core/sync` handles **client/server time synchronization and ping estimation**, including timeline syncing and diagnostics.
   - `crates/core/frame_interpolation` is a small isolated crate for frame interpolation logic.
   - These crates make sure networked state changes are interpreted against the right simulation time.

7. **Replication and world state flow**
   - `crates/replication/replication` is the main **entity/component replication engine**.
   - It handles **authority, delta/state updates, checkpoints, send/receive paths, hierarchy handling, prespawning, visibility/interest management, and replication registry logic**.
   - Data flow here is typically: ECS state is inspected on the authoritative side → encoded into network messages → transmitted through transport → decoded and applied on remote worlds.
   - This is the central subsystem for world synchronization.

8. **Prediction and interpolation**
   - `crates/replication/prediction` implements **client-side prediction with rollback/correction**.
   - `crates/replication/interpolation` handles **snapshot interpolation** for non-controlled or remote entities.
   - Together they split remote-state handling into two paths:
     - predicted entities advance locally and reconcile later
     - interpolated entities lag behind slightly and smooth over packet cadence
   - These crates are key to the “responsive client / authoritative server” architecture shown in the README.

9. **Input networking**
   - `crates/inputs` contains the generic input pipeline, including buffering and network message types.
   - `inputs_native`, `input_bei`, and `inputs_leafwing` are adapter crates for different input sources, including **Bevy Enhanced Input** and **Leafwing Input Manager**.
   - Input flow is usually: local device input → buffered per tick on client → sent with redundancy → applied on the server for the matching tick.
   - This is a distinct path from world replication because player intent must be time-aligned, loss-tolerant, and often replayable.

10. **Deterministic replication mode**
   - `crates/deterministic/deterministic_replication` supports **input-only deterministic simulation**.
   - It includes checksums, late-join logic, and mode control to support lockstep-style or deterministic rollback-style networking.
   - This subsystem is separate from ordinary state replication because it assumes the simulation itself can be reproduced exactly from the same inputs.

11. **Integration layer for game physics and ECS ecosystems**
   - `crates/integration/avian` and related crates provide **Avian physics integration** and lag compensation helpers.
   - This is where network sync meets gameplay systems like rigid bodies, collision queries, and predicted/interpolated physics objects.
   - The integrations act as adaptation layers between Lightyear’s network model and specific Bevy ecosystem crates.

12. **Platform and browser support**
   - `crates/platform/web` contains browser-oriented support, including a **background worker** utility.
   - Combined with `websocket` and `webtransport`, this is what enables the same networking architecture to run in wasm/browser environments as well as native ones.

13. **Tooling, observability, and developer support**
   - `crates/tools/metrics` and `crates/tools/tools` provide diagnostics, debug UI, schema/component inspection, and tracing support.
   - The repo also uses `tracing` and `metrics` as first-class observability hooks across the networking stack.
   - This tooling is not the data path itself, but it matters architecturally because it exposes transport, replication, and sync behavior at runtime.

14. **Examples, tests, docs, and validation**
   - `examples/` and `demos/` are the main architectural usage references: each example composes a client, server, shared protocol, and renderer around specific Lightyear features.
   - `crates/tests` is a dedicated integration-test workspace covering client/server, host-server, multi-server, timeline sync, prediction, input, and replication scenarios.
   - `book/` is the conceptual documentation for the architecture, while `benches/` measures compile-time and runtime performance of transport, replication, and compression paths.

15. **How the major data flows connect**
   - The most important diagram boundary is:
     - **Bevy gameplay systems and ECS state**
     - through **input/replication/prediction/sync plugins**
     - into **message serialization and packet channels**
     - across **connection + IO backends**
     - to the **remote client/server world**
   - The architecture is intentionally modular so that a project can use only the transport layer, only replication, or the full authoritative client/server stack.

Main entry points: [`examples`](https://github.com/cbournhonesque/lightyear/tree/main/examples) (Examples), [`crates/transport/transport`](https://github.com/cbournhonesque/lightyear/tree/main/crates/transport/transport) (Transport), [`crates/connection/connection`](https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/connection) (Connection), [`crates/inputs/inputs`](https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/inputs) (Inputs)

## Diagram (Mermaid)

```mermaid
flowchart TD

subgraph group_transport["Transport"]
  node_transport_transport["Transport<br/>packet/channel engine"]
  node_transport_messages["Messages<br/>typed message API"]
  node_transport_serde["Serde<br/>wire serialization"]
end

subgraph group_connection_io["Conn + I/O"]
  node_connection_core["Connection<br/>identity/session core"]
  node_connection_netcode["Netcode<br/>secure sessions"]
  node_connection_raw["Raw Conn<br/>direct sessions"]
  node_connection_steam["Steam"]
  node_io_udp["UDP<br/>native socket I/O"]
  node_io_websocket["WebSocket<br/>browser I/O"]
  node_io_webtransport["WebTransport<br/>browser I/O"]
  node_io_link["Link"]
end

subgraph group_core["Core time"]
  node_core_core["Core<br/>tick/time primitives"]
  node_core_sync["Sync"]
  node_core_frame_interp["Frame Interp<br/>frame smoothing"]
end

subgraph group_replication["Replication"]
  node_replication_replication["Replication<br/>entity sync engine"]
  node_replication_prediction["Prediction<br/>client rollback"]
  node_replication_interpolation["Interpolation<br/>snapshot smoothing"]
  node_deterministic_replication["Deterministic<br/>input-only sim"]
end

subgraph group_inputs["Inputs"]
  node_inputs_core["Inputs<br/>input pipeline"]
  node_inputs_native["Native<br/>input adapter"]
  node_inputs_bei["BEI<br/>input adapter"]
  node_inputs_leafwing["Leafwing<br/>input adapter"]
end

subgraph group_integration["Integration"]
  node_integration_avian["Avian<br/>physics integration"]
  node_platform_web["Web Platform<br/>web support"]
end

subgraph group_tools["Tools"]
  node_tools_metrics["Metrics<br/>observability"]
  node_tools_debug["Debug Tools<br/>inspection UI"]
end

subgraph group_apps["Apps"]
  node_examples_suite["Examples<br/>bevy demos"]
  node_demos_suite["Demos<br/>showcase apps"]
  node_tests_suite["Tests"]
  node_book_docs["Book<br/>architecture docs"]
end

node_transport_messages -->|"builds on"| node_transport_transport
node_transport_serde -->|"encodes"| node_transport_messages
node_connection_core -->|"uses"| node_transport_transport
node_connection_netcode -->|"extends"| node_connection_core
node_connection_raw -->|"extends"| node_connection_core
node_connection_steam -->|"extends"| node_connection_core
node_io_udp -->|"feeds bytes"| node_transport_transport
node_io_websocket -->|"feeds bytes"| node_transport_transport
node_io_webtransport -->|"feeds bytes"| node_transport_transport
node_io_link -->|"feeds bytes"| node_transport_transport
node_core_sync -->|"depends on"| node_core_core
node_replication_replication -->|"aligns to"| node_core_core
node_replication_prediction -->|"aligns to"| node_core_core
node_replication_interpolation -->|"aligns to"| node_core_core
node_deterministic_replication -->|"aligns to"| node_core_core
node_inputs_core -->|"aligns to"| node_core_core
node_inputs_native -->|"adapts"| node_inputs_core
node_inputs_bei -->|"adapts"| node_inputs_core
node_inputs_leafwing -->|"adapts"| node_inputs_core
node_integration_avian -->|"integrates with"| node_replication_prediction
node_integration_avian -->|"integrates with"| node_replication_interpolation
node_platform_web -->|"supports"| node_io_websocket
node_platform_web -->|"supports"| node_io_webtransport
node_tools_metrics -->|"observes"| node_core_sync
node_tools_debug -->|"inspects"| node_transport_transport
node_tools_debug -->|"inspects"| node_replication_replication
node_tools_debug -->|"inspects"| node_core_sync
node_examples_suite -->|"composes"| node_connection_core
node_examples_suite -->|"composes"| node_inputs_core
node_examples_suite -->|"composes"| node_replication_replication
node_examples_suite -->|"composes"| node_replication_prediction
node_examples_suite -->|"composes"| node_replication_interpolation
node_examples_suite -->|"composes"| node_integration_avian
node_demos_suite -->|"extends"| node_examples_suite
node_tests_suite -->|"verifies"| node_connection_core
node_tests_suite -->|"verifies"| node_core_sync
node_tests_suite -->|"verifies"| node_replication_replication
node_tests_suite -->|"verifies"| node_replication_prediction
node_tests_suite -->|"verifies"| node_inputs_core
node_book_docs -->|"documents"| node_transport_transport
node_book_docs -->|"documents"| node_connection_core
node_book_docs -->|"documents"| node_replication_replication
node_book_docs -->|"documents"| node_inputs_core
node_book_docs -->|"documents"| node_integration_avian

click node_transport_transport "https://github.com/cbournhonesque/lightyear/tree/main/crates/transport/transport"
click node_transport_messages "https://github.com/cbournhonesque/lightyear/tree/main/crates/transport/messages"
click node_transport_serde "https://github.com/cbournhonesque/lightyear/tree/main/crates/transport/serde"
click node_connection_core "https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/connection"
click node_connection_netcode "https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/netcode"
click node_connection_raw "https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/raw_connection"
click node_connection_steam "https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/steam"
click node_io_udp "https://github.com/cbournhonesque/lightyear/tree/main/crates/io/udp"
click node_io_websocket "https://github.com/cbournhonesque/lightyear/tree/main/crates/io/websocket"
click node_io_webtransport "https://github.com/cbournhonesque/lightyear/tree/main/crates/io/webtransport"
click node_io_link "https://github.com/cbournhonesque/lightyear/tree/main/crates/io/link"
click node_core_core "https://github.com/cbournhonesque/lightyear/tree/main/crates/core/core"
click node_core_sync "https://github.com/cbournhonesque/lightyear/tree/main/crates/core/sync"
click node_core_frame_interp "https://github.com/cbournhonesque/lightyear/tree/main/crates/core/frame_interpolation"
click node_replication_replication "https://github.com/cbournhonesque/lightyear/tree/main/crates/replication/replication"
click node_replication_prediction "https://github.com/cbournhonesque/lightyear/tree/main/crates/replication/prediction"
click node_replication_interpolation "https://github.com/cbournhonesque/lightyear/tree/main/crates/replication/interpolation"
click node_deterministic_replication "https://github.com/cbournhonesque/lightyear/tree/main/crates/deterministic/deterministic_replication"
click node_inputs_core "https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/inputs"
click node_inputs_native "https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/inputs_native"
click node_inputs_bei "https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/input_bei"
click node_inputs_leafwing "https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/inputs_leafwing"
click node_integration_avian "https://github.com/cbournhonesque/lightyear/tree/main/crates/integration/avian"
click node_platform_web "https://github.com/cbournhonesque/lightyear/tree/main/crates/platform/web"
click node_tools_metrics "https://github.com/cbournhonesque/lightyear/tree/main/crates/tools/metrics"
click node_tools_debug "https://github.com/cbournhonesque/lightyear/tree/main/crates/tools/tools"
click node_examples_suite "https://github.com/cbournhonesque/lightyear/tree/main/examples"
click node_demos_suite "https://github.com/cbournhonesque/lightyear/tree/main/demos"
click node_tests_suite "https://github.com/cbournhonesque/lightyear/tree/main/crates/tests"
click node_book_docs "https://github.com/cbournhonesque/lightyear/tree/main/book"

classDef toneNeutral fill:#f8fafc,stroke:#334155,stroke-width:1.5px,color:#0f172a
classDef toneBlue fill:#dbeafe,stroke:#2563eb,stroke-width:1.5px,color:#172554
classDef toneAmber fill:#fef3c7,stroke:#d97706,stroke-width:1.5px,color:#78350f
classDef toneMint fill:#dcfce7,stroke:#16a34a,stroke-width:1.5px,color:#14532d
classDef toneRose fill:#ffe4e6,stroke:#e11d48,stroke-width:1.5px,color:#881337
classDef toneIndigo fill:#e0e7ff,stroke:#4f46e5,stroke-width:1.5px,color:#312e81
classDef toneTeal fill:#ccfbf1,stroke:#0f766e,stroke-width:1.5px,color:#134e4a
class node_transport_transport,node_transport_messages,node_transport_serde,node_tools_metrics,node_tools_debug toneBlue
class node_connection_core,node_connection_netcode,node_connection_raw,node_connection_steam,node_io_udp,node_io_websocket,node_io_webtransport,node_io_link,node_examples_suite,node_demos_suite,node_tests_suite,node_book_docs toneAmber
class node_core_core,node_core_sync,node_core_frame_interp toneMint
class node_replication_replication,node_replication_prediction,node_replication_interpolation,node_deterministic_replication toneRose
class node_inputs_core,node_inputs_native,node_inputs_bei,node_inputs_leafwing toneIndigo
class node_integration_avian,node_platform_web toneTeal
```

## Components

### Transport

Packet framing, typed messages, and serialization boundary.

- [Transport](https://github.com/cbournhonesque/lightyear/tree/main/crates/transport/transport): packet/channel engine · Reliable/unreliable channels, packet building, fragmentation, compression, and acks. · `crates/transport/transport`
- [Messages](https://github.com/cbournhonesque/lightyear/tree/main/crates/transport/messages): typed message API · Typed send/receive abstractions built on top of packet transport. · `crates/transport/messages`
- [Serde](https://github.com/cbournhonesque/lightyear/tree/main/crates/transport/serde): wire serialization · Encoding and decoding for messages, entity references, and registry-backed formats. · `crates/transport/serde`

### Conn + I/O

Peer identity, session setup, and transport backends.

- [Connection](https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/connection): identity/session core · Roles, targets, identities, and shared networking state. · `crates/connection/connection`
- [Netcode](https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/netcode): secure sessions · Authenticated client/server connection flow with tokens, crypto, and replay protection. · `crates/connection/netcode`
- [Raw Conn](https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/raw_connection): direct sessions · Simpler direct connection strategy without secure netcode handshake. · `crates/connection/raw_connection`
- [Steam](https://github.com/cbournhonesque/lightyear/tree/main/crates/connection/steam): steam networking · SteamWorks-based client/server connection strategy. · `crates/connection/steam`
- [UDP](https://github.com/cbournhonesque/lightyear/tree/main/crates/io/udp): native socket I/O · Datagram backend for native networking. · `crates/io/udp`
- [WebSocket](https://github.com/cbournhonesque/lightyear/tree/main/crates/io/websocket): browser I/O · Web-compatible client/server transport backend. · `crates/io/websocket`
- [WebTransport](https://github.com/cbournhonesque/lightyear/tree/main/crates/io/webtransport): browser I/O · Modern browser-friendly transport backend. · `crates/io/webtransport`
- [Link](https://github.com/cbournhonesque/lightyear/tree/main/crates/io/link): simulated link · Local/test network conditioning and link-style transport behavior. · `crates/io/link`

### Core time

Shared tick, time, sync, and utility primitives.

- [Core](https://github.com/cbournhonesque/lightyear/tree/main/crates/core/core): tick/time primitives · Ticks, time tracking, timelines, interpolation history, and prediction support. · `crates/core/core`
- [Sync](https://github.com/cbournhonesque/lightyear/tree/main/crates/core/sync): time sync · Ping estimation, timeline synchronization, and diagnostics. · `crates/core/sync`
- [Frame Interp](https://github.com/cbournhonesque/lightyear/tree/main/crates/core/frame_interpolation): frame smoothing · Isolated frame interpolation helpers. · `crates/core/frame_interpolation`

### Replication

World-state replication, prediction, and interpolation.

- [Replication](https://github.com/cbournhonesque/lightyear/tree/main/crates/replication/replication): entity sync engine · Authority, delta/state updates, checkpoints, send/receive, hierarchy, visibility, and registry logic. · `crates/replication/replication`
- [Prediction](https://github.com/cbournhonesque/lightyear/tree/main/crates/replication/prediction): client rollback · Client-side prediction, rollback, correction, and predicted history. · `crates/replication/prediction`
- [Interpolation](https://github.com/cbournhonesque/lightyear/tree/main/crates/replication/interpolation): snapshot smoothing · Snapshot interpolation for remote or non-controlled entities. · `crates/replication/interpolation`
- [Deterministic](https://github.com/cbournhonesque/lightyear/tree/main/crates/deterministic/deterministic_replication): input-only sim · Deterministic replication mode with checksums, late join, and mode control. · `crates/deterministic/deterministic_replication`

### Inputs

Buffered input pipelines and source adapters.

- [Inputs](https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/inputs): input pipeline · Buffered input collection, tick alignment, and network message flow. · `crates/inputs/inputs`
- [Native](https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/inputs_native): input adapter · Native device input adapter. · `crates/inputs/inputs_native`
- [BEI](https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/input_bei): input adapter · Bevy Enhanced Input adapter. · `crates/inputs/input_bei`
- [Leafwing](https://github.com/cbournhonesque/lightyear/tree/main/crates/inputs/inputs_leafwing): input adapter · Leafwing Input Manager adapter. · `crates/inputs/inputs_leafwing`

### Integration

Physics and ECS ecosystem adapters.

- [Avian](https://github.com/cbournhonesque/lightyear/tree/main/crates/integration/avian): physics integration · Avian physics sync, correction, and lag compensation helpers. · `crates/integration/avian`
- [Web Platform](https://github.com/cbournhonesque/lightyear/tree/main/crates/platform/web): web support · Browser-oriented runtime support including background worker utilities. · `crates/platform/web`

### Tools

Observability and debug support.

- [Metrics](https://github.com/cbournhonesque/lightyear/tree/main/crates/tools/metrics): observability · Metrics plugin and registry support. · `crates/tools/metrics`
- [Debug Tools](https://github.com/cbournhonesque/lightyear/tree/main/crates/tools/tools): inspection UI · Debug UI, schema/component inspection, and tracing layers. · `crates/tools/tools`

### Apps

Examples, demos, tests, and documentation consumers.

- [Examples](https://github.com/cbournhonesque/lightyear/tree/main/examples): bevy demos · Client/server/shared example apps demonstrating Lightyear subsystems. · `examples`
- [Demos](https://github.com/cbournhonesque/lightyear/tree/main/demos): showcase apps · Larger showcase applications built from the same crates. · `demos`
- [Tests](https://github.com/cbournhonesque/lightyear/tree/main/crates/tests): integration tests · Scenario-driven client/server, host/server, timeline, input, prediction, and replication tests. · `crates/tests`
- [Book](https://github.com/cbournhonesque/lightyear/tree/main/book): architecture docs · Conceptual documentation for transport, connection, replication, inputs, and integration. · `book`

## Connections

- Messages → Transport: builds on · Typed messages are carried by packet/channel transport.
- Serde → Messages: encodes · Serialization feeds message and entity wire formats.
- Connection → Transport: uses · Connection state rides on top of packet transport.
- Netcode → Connection: extends · Secure handshake and session logic builds on shared connection roles.
- Raw Conn → Connection: extends · Direct session strategy builds on shared connection abstractions.
- Steam → Connection: extends · Steam networking maps into the shared connection model.
- UDP → Transport: feeds bytes · Native UDP backend is the process boundary for packets.
- WebSocket → Transport: feeds bytes · WebSocket backend carries packets in browser-compatible environments.
- WebTransport → Transport: feeds bytes · WebTransport backend carries packets in browser-compatible environments.
- Link → Transport: feeds bytes · Simulated link backend injects conditioning and local transport behavior.
- Sync → Core: depends on · Time sync uses the shared tick/timeline primitives.
- Replication → Core: aligns to · Replication is tick and timeline aware.
- Prediction → Core: aligns to · Prediction uses confirmed history, rollback, and timelines.
- Interpolation → Core: aligns to · Interpolation advances snapshots against shared time primitives.
- Deterministic → Core: aligns to · Deterministic mode uses tick-aligned simulation state.
- Inputs → Core: aligns to · Input buffering is organized per tick and timeline.
- Native → Inputs: adapts · Native input sources feed the generic input pipeline.
- BEI → Inputs: adapts · Bevy Enhanced Input feeds the generic input pipeline.
- Leafwing → Inputs: adapts · Leafwing Input Manager feeds the generic input pipeline.
- Avian → Prediction: integrates with · Physics correction and lag compensation connect to prediction.
- Avian → Interpolation: integrates with · Physics state can be smoothed through interpolation.
- Web Platform → WebSocket: supports · Web platform utilities support browser transport runtimes.
- Web Platform → WebTransport: supports · Web platform utilities support browser transport runtimes.
- Metrics → Sync: observes · Metrics capture sync and timing behavior.
- Debug Tools → Transport: inspects · Debug tooling exposes transport and packet state.
- Debug Tools → Replication: inspects · Debug tooling exposes replication state and metadata.
- Debug Tools → Sync: inspects · Debug tooling surfaces sync diagnostics.
- Examples → Connection: composes · Examples wire client/server/shared apps around connection setup.
- Examples → Inputs: composes · Examples demonstrate input buffering and adapters.
- Examples → Replication: composes · Examples demonstrate entity replication flows.
- Examples → Prediction: composes · Examples demonstrate prediction and correction flows.
- Examples → Interpolation: composes · Examples demonstrate interpolation of remote entities.
- Examples → Avian: composes · Examples show physics integration with networking.
- Demos → Examples: extends · Demos are higher-level showcase applications built from the same stack.
- Tests → Connection: verifies · Integration tests cover connection modes and topologies.
- Tests → Sync: verifies · Tests cover timeline and sync behavior.
- Tests → Replication: verifies · Tests cover replication, hierarchy, visibility, and authority.
- Tests → Prediction: verifies · Tests cover prediction, rollback, and correction.
- Tests → Inputs: verifies · Tests cover native and adapter input paths.
- Book → Transport: documents · Book explains the transport and serialization model.
- Book → Connection: documents · Book explains connection strategies and roles.
- Book → Replication: documents · Book explains replication protocol and state flow.
- Book → Inputs: documents · Book explains networked input handling.
- Book → Avian: documents · Book explains integration patterns and advanced systems.