# Synchro
An honest, low-latency **packet dispatch and measurement** layer for MirvkBuntu.
Synchro sends timestamped packets to destinations, matches replies, and reports
the **measured** latency distribution per destination — plus a metered HTTP/2
sending path and a dynamically loaded backend behind a `@synchro` annotation.
## What Synchro does *not* claim
Synchro deliberately makes **no delivery-time guarantee**, because none is
physically possible for arbitrary Internet destinations:
- **The speed of light is a hard floor.** Light in fiber travels ~200 km per
millisecond. A host 2,000 km away is therefore **≥10 ms away one-way** from
pure propagation, before any routing, queuing, or serialization. "Delivery to
any known IP within 0.01 s" is refuted by geography alone for most of the
planet.
- **The Internet is best-effort.** No software layer can *guarantee* a delivery
percentage to destinations it does not control. Congestion, loss, re-routing,
and unreachable hosts are real and unbounded.
So the "maximum accuracy we can honestly claim" is **not a fixed number** — it
is an **empirical, per-run, per-destination** figure that Synchro *measures* and
reports. That is the honest form of precision: what actually happened, to four
decimal places of a millisecond, with the loss rate stated alongside it.
## Measured example (loopback)
Running the built-in echo server and probing it over loopback (`lo`), where you
see the genuine floor of the local network stack:
```text
127.0.0.1:9873: p50=0.0558 p95=0.2865 p99=0.3331 jitter=0.0808 loss=0.00% (n=200)
Synchro SLA report (measured, not guaranteed)
threshold : 1.000 ms
evaluated at : p99
destinations : 1/1 meeting threshold (100.00%)
samples within thr. : 200/200 (100.00%)
```
Those numbers are produced by the code in this directory, not hand-written.
On a real WAN path the same command will report the real, larger latencies and
any real loss — which is exactly the point.
## Components
| Module | Purpose |
|--------|---------|
| `synchro/dispatcher.py` | `UdpDispatcher` — timestamped UDP send/ack RTT measurement (uses `time.monotonic_ns()`), plus a loopback echo server for self-contained runs. |
| `synchro/stats.py` | `LatencyStats` — streaming per-destination min / p50 / p95 / p99 / max, mean, jitter (stdev), and delivery/loss rates over a retained sample window. |
| `synchro/sla.py` | `SlaReporter` — the testable form of a latency target: the **observed** fraction of destinations (and of samples) that met a `
