[kahrendt]

A message's receive time is when its last byte arrived at the transport. Every inbound message now gets the completion stamp, which the transports pass to end_inbound_message() / end_inbound_fragment(); begin_inbound_message() no longer takes a stamp, and the ESP httpd handler-entry stamp is gone.

Measured on an ESP32 httpd connection: the completion stamp is ~140 us later than the old handler-entry stamp for a server/time reply (a fixed ~70 us offset shift, which GPS ground-truth runs show moves the observed bias in the right direction) and 1 to 5 ms later for an audio chunk, with rare stalls of tens of ms under load. Under ring pressure the httpd stamp also includes any wait for ring space.

• No ring header change.
• Host (IXWebSocket) delivers whole messages, so both stamps are the same there.

Testing: host ASan + TSan, esp32s3 build. New table test covers each route (ring, fallback, multi-frame into either). Not run on hardware.

Implements Sendspin/spec#298

[Copilot]

Copilot review overview

🟡 Changes recommended

Fragmented messages at or below the cutoff incorrectly retain the first-fragment timestamp instead of the final-fragment completion time.

Review effort: Balanced
Findings: 1

Open (1)

• Use final fragment timestamp for fragmented messages · New

What changed in this PR

Updates inbound receive timestamps so large messages use completion time while preserving first-sight timestamps for single-segment messages.

Changes:

• Pass completion timestamps through host and ESP transports.
• Apply size-aware timestamps to ring and fallback routes.
• Add boundary and routing coverage.

File	Description
src/​connection.h	Extends inbound completion APIs and defines the segment cutoff.
src/​connection.cpp	Applies completion timestamps to large inbound messages.
src/​esp/​client_connection.cpp	Passes ESP client event timestamps.
src/​esp/​server_connection.cpp	Captures ESP server payload completion time.
src/​host/​client_connection.cpp	Passes host client receive time.
src/​host/​server_connection.cpp	Passes host server receive time.
tests/​loopback_connection.h	Exposes the cutoff to tests.
tests/​test_noise_transport.cpp	Adds boundary and route coverage.
tests/​test_client_lifecycle.cpp	Updates the completion API call.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[Copilot]

Copilot review overview

🔵 Needs a closer look

The size heuristic cannot guarantee single-segment arrival and can retain a pre-completion timestamp contrary to the referenced specification.

Review effort: Balanced
Findings: None

Resolved since last review (1)

• Use final fragment timestamp for fragmented messages

Previously missed (2)

In code that hasn't changed since last review

Always publish completion timestamp after final byte arrival

src/​connection.h:904

A payload being small enough to fit one TCP segment does not guarantee that it arrived in one segment: the sender can write the WebSocket header and payload separately, TCP can emit smaller segments, and a transport can deliver multiple chunks. In those cases this heuristic preserves a timestamp from before the last byte arrived, contradicting spec PR 298's requirement that the receive time be the final byte's arrival. Please always publish the completion timestamp in the connection layer; transports that receive a whole message atomically can pass the same value for the start and completion times (as the host paths already do).

Explain rationale for inspecting private timestamp state

tests/​test_noise_transport.cpp:2704

This test reads the ring header and pending-message internals without explaining why no caller-visible outcome can distinguish the timestamp path. docs/conventions.md:246-249 requires that rationale whenever tests inspect private state. Please either assert through an observable consumer outcome or document why doing so cannot isolate this transport timestamp behavior.

[Copilot]

🟢 Approval recommended

The transport paths are consistently updated and the new tests cover ring, fallback, and fragmented-message timestamp propagation.

0 open findings

🧠 Review effort: Balanced