docs: comprehensive documentation audit -- 14 fixes across 13 files

Findings and fixes:
- SECURITY.md: version table said 4.5.x current, updated to 5.2.x with
  accurate support matrix including Go price formula bug note
- CHANGELOG.md: missing [5.1.1] release entry (link ref existed but no
  section) -- added entry documenting tdbe 0.2.0 crates.io publish fix
- Go streaming docs: 4 files still showed PriceToF64() on pre-decoded
  float64 fields (would produce wrong results since v5.2). Updated
  streaming.md, streaming/index.md, streaming/reconnection.md examples
  to use pre-decoded fields directly
- options.md: wildcard docs said right must be "C" or "P" -- added
  "both" as valid value (from normalize_right)
- Go/C++ SDK READMEs: Config section listed mixed-language syntax
  (Config.stage()/StageConfig()/Config::stage()) -- each now shows
  only its own language
- Go/C++ SDK READMEs: GreeksTick type missing Vera field (present in
  code since v4.5.0) -- added
- C++ README: Greeks standalone struct missing vera field -- added
- docs/architecture.md, jvm-deviations.md, reverse-engineering.md,
  api-reference.md: macro name define_endpoint! renamed to
  parsed_endpoint! (actual current macro name)
- streaming/latency.md: replaced ASCII diagram with Mermaid sequence
  diagram and latency breakdown flowchart. Added network physics
  section with fiber optic speed-of-light calculations for 8 locations.
  Added dev server warning (historical replay timestamps are from the
  past, not valid for latency measurement)
- streaming/index.md: replaced ASCII architecture diagram with Mermaid
- option/index.md: "At-Time OHLC" link text corrected to "At-Time
  Quote" (file contains option_at_time_quote, not OHLC)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: userFRM

CHANGELOG.md

@@ -33,6 +33,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - **Go `PriceToF64` formula** was `value / 10^pt` instead of `value * 10^(pt-10)`. All FPSS streaming prices would have been wrong. (#95)
 
+## [5.1.1] - 2026-04-03
+
+### Fixed
+
+- `tdbe` dependency bumped to 0.2.0 for crates.io publish (0.1.x was yanked). No code changes.
+
 ## [5.1.0] - 2026-04-03
 
 ### Breaking Changes

SECURITY.md

@@ -19,13 +19,17 @@ for critical issues.
 
 | Version | Supported          | Notes |
 | ------- | ------------------ | ----- |
-| 4.5.x   | :white_check_mark: | Current release (`tdbe` + `#[repr(C)]` FFI) |
-| 4.0-4.4 | :x:                | Upgrade to 4.5.x (timezone bug in 4.0-4.4, FFI improvements in 4.5) |
+| 5.2.x   | :white_check_mark: | Current release (f64 prices, `#[repr(C)]` FPSS events, contract ID fields) |
+| 5.0-5.1 | :x:                | Upgrade to 5.2.x (Go price formula bug fixed in 5.2) |
+| 4.5.x   | :x:                | Pre-builder-pattern API, missing f64 convenience methods |
+| 4.0-4.4 | :x:                | Timezone bug (ms_of_day shifted +1 hour Nov-Mar) |
 | 3.x     | :x:                | Pre-`tdbe` extraction, stale API |
 | < 3.0   | :x:                | Contract wire format bug, missing endpoints |
 
 > **Important:** Versions prior to 4.5.0 contain a timezone bug that shifts ms_of_day by +1 hour
-> for all historical data from November through March (EST period). All users should upgrade to 4.5.x.
+> for all historical data from November through March (EST period). Versions prior to 5.2.0
+> contain a Go SDK price formula bug where `PriceToF64` used the wrong formula. All users
+> should upgrade to 5.2.x.
 
 ## Security Design
 

docs-site/docs/historical/option/index.md

@@ -73,7 +73,7 @@ Historical time series data for a contract.
 Data at a specific time of day across a date range.
 
 - [At-Time Trade](./at-time/trade)
-- [At-Time OHLC](./at-time/ohlc)
+- [At-Time Quote](./at-time/ohlc)
 
 ## Streaming (Rust only)
 

docs-site/docs/options.md

@@ -142,7 +142,7 @@ print(df[["strike", "close", "volume"]].head(20))
 When you pass `"0"` for `expiration` or `strike`, the server returns data across all matching contracts. Each tick includes contract identification fields (`expiration`, `strike`, `right`, `strike_price_type`) so you can distinguish which contract each tick belongs to.
 
 ::: warning
-The `right` parameter does **not** support wildcards. You must specify `"C"` (call) or `"P"` (put). Only `expiration` and `strike` accept `"0"` as a wildcard.
+The `right` parameter does **not** accept `"0"` as a wildcard. Use `"C"` (call), `"P"` (put), or `"both"` (calls and puts). Only `expiration` and `strike` accept `"0"` as a wildcard.
 :::
 
 ::: code-group

docs-site/docs/streaming.md

@@ -11,7 +11,7 @@ Each SDK exposes FPSS differently:
 
 - **Rust** -- Fully synchronous callback model. Events dispatched through an LMAX Disruptor ring buffer. No Tokio on the streaming hot path.
 - **Python** -- Polling model with `next_event()`. Events returned as Python dicts with all fields.
-- **Go** -- Polling model with `NextEvent()`. Events returned as typed `*FpssEvent` structs. Use `PriceToF64()` for price decoding.
+- **Go** -- Polling model with `NextEvent()`. Events returned as typed `*FpssEvent` structs. Price fields are pre-decoded to `float64`; raw integers available as `*Raw` fields.
 - **C++** -- Polling model with `next_event()`. Events returned as `FpssEventPtr` (`unique_ptr<TdxFpssEvent>`, RAII). `#[repr(C)]` layout-compatible structs.
 
 ::: warning No JSON in FFI
@@ -237,16 +237,15 @@ for {
     switch event.Kind {
     case thetadatadx.FpssQuoteEvent:
         q := event.Quote
-        bid := thetadatadx.PriceToF64(q.Bid, q.PriceType)
-        ask := thetadatadx.PriceToF64(q.Ask, q.PriceType)
+        // Bid and Ask are pre-decoded to float64
         fmt.Printf("Quote: contract=%d bid=%.4f ask=%.4f rx=%dns\n",
-            q.ContractID, bid, ask, q.ReceivedAtNs)
+            q.ContractID, q.Bid, q.Ask, q.ReceivedAtNs)
 
     case thetadatadx.FpssTradeEvent:
         t := event.Trade
-        price := thetadatadx.PriceToF64(t.Price, t.PriceType)
+        // Price is pre-decoded to float64
         fmt.Printf("Trade: contract=%d price=%.4f size=%d\n",
-            t.ContractID, price, t.Size)
+            t.ContractID, t.Price, t.Size)
 
     case thetadatadx.FpssOpenInterestEvent:
         oi := event.OpenInterest
@@ -553,7 +552,7 @@ Undecoded fallback for corrupt or unrecognized frames. Fields: `code` (u8), `pay
 | `Shutdown` | `()` | Graceful shutdown |
 | `Close` | `()` | Free the FPSS handle |
 
-Helper: `PriceToF64(value int32, priceType int32) float64`
+Helper: `PriceToF64(value int32, priceType int32) float64` -- decode raw integer prices. Note: FPSS event price fields are pre-decoded to `float64` as of v5.2; this helper is for custom use cases or raw field decoding.
 
 ### C++ (`tdx::FpssClient`)
 

docs-site/docs/streaming/index.md

@@ -9,9 +9,11 @@ Real-time market data is delivered via ThetaData's FPSS (Feed Processing Streami
 
 ## Architecture
 
-```
-Exchange (NJ) --> ThetaData FPSS servers --> TLS/TCP --> Your application
-                  (4 production hosts)                   (Disruptor ring buffer)
+```mermaid
+graph LR
+    A["Exchange<br/>(NYSE/NASDAQ)"] --> B["ThetaData FPSS<br/>(4 NJ hosts)"]
+    B -->|"TLS/TCP"| C["SDK I/O Thread<br/>(FIT decode)"]
+    C -->|"Disruptor<br/>ring buffer"| D["Your Application<br/>(callback / poll)"]
 ```
 
 Events are decoded from the FIT wire format and delta-decompressed on an I/O thread, then dispatched through an LMAX Disruptor ring buffer to your callback (Rust) or polling queue (Python/Go/C++). Every data event carries a `received_at_ns` nanosecond timestamp captured at frame decode time.
@@ -22,7 +24,7 @@ Events are decoded from the FIT wire format and delta-decompressed on an I/O thr
 |-----|-------|------------|---------|
 | **Rust** | Synchronous callback | `&FpssEvent` enum | Disruptor ring buffer dispatch. No Tokio on the hot path. |
 | **Python** | Polling | `dict` | `next_event()` returns events as Python dicts with all fields. |
-| **Go** | Polling | `*FpssEvent` struct | `NextEvent()` returns typed Go structs. `PriceToF64()` for price decoding. |
+| **Go** | Polling | `*FpssEvent` struct | `NextEvent()` returns typed Go structs. Price fields pre-decoded to `float64`. |
 | **C++** | Polling | `FpssEventPtr` | `next_event()` returns `unique_ptr<TdxFpssEvent>` (RAII). `#[repr(C)]` layout. |
 
 ::: warning No JSON in FFI

docs-site/docs/streaming/latency.md

@@ -11,17 +11,41 @@ Combined with the exchange's `ms_of_day` timestamp on each tick, this gives you
 
 ## How it works
 
-```
-Exchange (NJ) ──── ThetaData FPSS server ──── TLS/TCP ──── Your application
-    |                                                              |
-    ms_of_day                                              received_at_ns
-    (exchange clock)                                       (your clock)
-    
-    latency = received_at_ns - exchange_timestamp_ns
+```mermaid
+sequenceDiagram
+    participant Exchange as Exchange (NYSE/NASDAQ)
+    participant FPSS as ThetaData FPSS (NJ)
+    participant SDK as ThetaDataDx SDK
+    participant App as User Application
+
+    Exchange->>FPSS: Market data feed
+    Note over FPSS: FIT encode + delta compress
+    FPSS->>SDK: TLS/TCP frame
+    Note over SDK: received_at_ns captured
+    SDK->>SDK: FIT decode + delta decompress
+    SDK->>App: Callback (FpssEvent)
+    Note over App: latency = received_at_ns - exchange_ns
 ```
 
 The exchange stamps each quote/trade with `ms_of_day` (milliseconds since midnight ET). Your application stamps `received_at_ns` (nanoseconds since UNIX epoch). The difference is your total latency: exchange -> ThetaData -> network -> TLS -> decode -> your callback.
 
+```mermaid
+graph LR
+    A["Exchange --> FPSS<br/>(~0ms)"] --> B["FPSS Processing<br/>(~0ms)"]
+    B --> C["Network Transit<br/>(physics: distance/c)"]
+    C --> D["SDK Decode<br/>(&lt; 1 us)"]
+    D --> E["User Callback"]
+
+    style C fill:#ff9999,color:#000
+    style D fill:#99ff99,color:#000
+```
+
+The network transit segment (red) dominates total latency. The SDK decode time (green) is sub-microsecond and negligible.
+
+::: danger Production only
+Latency can only be measured meaningfully on the **production** FPSS server (`DirectConfig::production()`, port 20000) **during live market hours** (9:30 AM - 4:00 PM ET). The dev server (port 20200) replays historical data from a past trading day at maximum speed -- the exchange timestamps are from the past, so `received_at_ns` minus the event's original timestamp produces values that are months or years, not real latency. The dev server is for functional testing only, not latency benchmarking.
+:::
+
 ## `tdbe::latency::latency_ns()`
 
 The `tdbe` crate provides a DST-aware helper that converts the exchange `ms_of_day` + `date` into epoch nanoseconds and computes the delta:
@@ -135,6 +159,33 @@ For the absolute lowest latency:
 
 3. **Use the Rust SDK directly** -- Python, Go, and C++ add an mpsc channel hop between the Disruptor and `next_event()`.
 
+## Network Physics: Minimum Achievable Latency
+
+ThetaData's FPSS servers are located in New Jersey (NJ datacenter). The speed of light in fiber optic cable is approximately 200,000 km/s (about 2/3 of the vacuum speed of light, due to the refractive index of glass). This sets an absolute physical floor on latency that no software optimization can overcome.
+
+The formula: `minimum_round_trip = distance_km / (300,000 * 0.67) * 2 * 1000` (in milliseconds).
+
+| Your Location | Distance to NJ | Minimum Round-Trip | Typical Observed |
+|---------------|---------------|-------------------|-----------------|
+| AWS us-east-1 (Virginia) | ~350 km | ~3.5 ms | 2-5 ms |
+| NJ/NYC datacenter | <50 km | <0.5 ms | <1 ms |
+| Chicago | ~1,200 km | ~12 ms | 10-15 ms |
+| Los Angeles | ~3,900 km | ~39 ms | 35-50 ms |
+| London | ~5,600 km | ~56 ms | 55-70 ms |
+| Frankfurt | ~6,200 km | ~62 ms | 60-80 ms |
+| Tokyo | ~10,800 km | ~108 ms | 105-130 ms |
+| Sydney | ~16,000 km | ~160 ms | 155-180 ms |
+
+If you are seeing 60-80ms latency from Europe, that is not a bug -- it is the speed of light in fiber. No SDK, no protocol change, no configuration tweak can make photons travel faster.
+
+The SDK's own overhead (`received_at_ns` capture, FIT decode, Disruptor dispatch, callback invocation) is sub-microsecond and entirely negligible compared to network physics.
+
+For latency-sensitive applications:
+
+1. **Colocate near NJ** -- AWS us-east-1 (N. Virginia) or any NJ/NYC-area datacenter gets sub-5ms
+2. **`FpssFlushMode::Immediate`** reduces software batching latency by up to 100ms, but cannot beat physics
+3. **Use the Rust SDK directly** -- eliminates the FFI channel hop present in Python/Go/C++ (adds <1ms)
+
 ## Latency Histogram Example (Rust)
 
 ```rust

docs-site/docs/streaming/reconnection.md

@@ -255,16 +255,15 @@ func main() {
         switch event.Kind {
         case thetadatadx.FpssQuoteEvent:
             q := event.Quote
-            bid := thetadatadx.PriceToF64(q.Bid, q.PriceType)
-            ask := thetadatadx.PriceToF64(q.Ask, q.PriceType)
+            // Bid and Ask are pre-decoded to float64
             fmt.Printf("[QUOTE] contract=%d bid=%.4f ask=%.4f rx=%dns\n",
-                q.ContractID, bid, ask, q.ReceivedAtNs)
+                q.ContractID, q.Bid, q.Ask, q.ReceivedAtNs)
 
         case thetadatadx.FpssTradeEvent:
             t := event.Trade
-            price := thetadatadx.PriceToF64(t.Price, t.PriceType)
+            // Price is pre-decoded to float64
             fmt.Printf("[TRADE] contract=%d price=%.4f size=%d\n",
-                t.ContractID, price, t.Size)
+                t.ContractID, t.Price, t.Size)
 
         case thetadatadx.FpssControlEvent:
             ctrl := event.Control

docs/api-reference.md

@@ -657,7 +657,7 @@ Nexus HTTP responses with status 401 (Unauthorized) or 404 (Not Found) are treat
 
 ### Endpoint Count
 
-ThetaDataDx exposes **61 typed methods** (plus 4 `_stream` variants) covering all 60 gRPC RPCs in `BetaThetaTerminal` plus 1 convenience range-query variant (`stock_history_ohlc_range`). Historical methods are provided via `Deref<Target = DirectClient>` (an internal implementation detail) and generated by the `define_endpoint!` macro in `direct.rs`.
+ThetaDataDx exposes **61 typed methods** (plus 4 `_stream` variants) covering all 60 gRPC RPCs in `BetaThetaTerminal` plus 1 convenience range-query variant (`stock_history_ohlc_range`). Historical methods are provided via `Deref<Target = DirectClient>` (an internal implementation detail) and generated by the `parsed_endpoint!` macro in `direct.rs`.
 
 ### FFI Coverage
 

docs/architecture.md

@@ -57,7 +57,7 @@ MDDS is a standard gRPC service over TLS, operating on port 443.
 
 - **Package**: `BetaEndpoints`
 - **Service**: `BetaThetaTerminal`
-- **Methods**: 60 RPCs, all server-streaming (returning `stream ResponseData`). thetadatadx wraps all 60 gRPC RPCs plus 1 convenience range-query variant = **61 methods** on `ThetaDataDx`, generated via a declarative `define_endpoint!` macro (internal implementation uses `DirectClient` via `Deref`).
+- **Methods**: 60 RPCs, all server-streaming (returning `stream ResponseData`). thetadatadx wraps all 60 gRPC RPCs plus 1 convenience range-query variant = **61 methods** on `ThetaDataDx`, generated via a declarative `parsed_endpoint!` macro (internal implementation uses `DirectClient` via `Deref`).
 - **Categories**: Stock, Option, Index, Interest Rate, Calendar - each with List, History, Snapshot, AtTime, and Greeks sub-categories
 
 ### Request Structure
@@ -513,7 +513,7 @@ graph TD
         end
 
         UNIFIED["unified.rs<br/><i>ThetaDataDx — unified entry point<br/>Deref to DirectClient</i>"]
-        DIRECT["direct.rs<br/><i>DirectClient (internal) — 61 endpoints<br/>via define_endpoint! macro</i>"]
+        DIRECT["direct.rs<br/><i>DirectClient (internal) — 61 endpoints<br/>via parsed_endpoint! macro</i>"]
         CONFIG["config.rs<br/><i>DirectConfig</i>"]
         DECODE["decode.rs<br/><i>zstd + DataTable parsing<br/>(includes generated parsers)</i>"]
         REGISTRY["registry.rs<br/><i>EndpointMeta, ENDPOINTS static</i>"]