Write down what the count lag and the symbol count measure

The third probe run puts numbers on both. TxBufLen lags by 100 to 150 ms, about
one character at 45.45 baud: twenty-one characters pushed at 2496 ms read 0 at
2497, 2547 and 2597, then 26 at 2647. It moves once per symbol transmitted, so
readings 50 ms apart repeat.

It read 26 for 21 characters because it counts Baudot symbols, and the message
carried two digits: a shift to figures and a shift back each time, plus one at
the start. That is the case the cap was needed for and I had not seen. A contest
exchange is mostly digits, so the engine always has more to transmit than the
clock thinks, and the clock alone would run ahead of it on every QSO.

Slack of three characters covers both, so nothing changes in the pump. The
count reaching 0 does not cut the end of a message off either: it emptied 350 ms
before the last character was decoded back and the engine held the transmitter
up for another 900 ms.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01RtspmWmS7f8kUvcyaHpRWZ

src/Nonemm.Digital/TypeAhead.cs

@@ -21,12 +21,12 @@ namespace Nonemm.Digital;
 ///
 /// The pump is paced by the clock at the baud rate, and the engine's own count
 /// of what it has left is a check on it rather than the pace. MMTTY answers
-/// `TxBufLen` with the number of characters it still has to transmit, but the
-/// answer is behind what the engine is really doing: the probe read 0 fifty
-/// milliseconds after twenty-one characters had been pushed and were already
-/// going out, and read a right-looking 12 a second after a push. A pump that
-/// believed a stale 0 would hand over the whole message in half a second and
-/// put all of it beyond reach, so the count is used two ways only:
+/// `TxBufLen` with the number of Baudot symbols it still has to transmit, which
+/// is more than the characters handed to it: a digit costs a shift to figures
+/// and a shift back, so `599 001` is seven characters and eleven symbols. The
+/// answer also lags the engine by about a character time. A pump that believed
+/// a fresh 0 would hand over a whole message in half a second and put all of it
+/// beyond reach, so the count is used two ways only:
 ///
 /// - as a cap. The engine holding more than `Lead + Slack` characters stops the
 ///   pump until it comes down, whatever the clock thinks.
@@ -59,9 +59,9 @@ public sealed class TypeAhead : IDisposable
     /// stands while the operator is not typing into the pane.
     public const int NoCursor = int.MaxValue;
 
-    /// How many characters the engine's count may be behind what it is really
-    /// doing. The count is what stops the pump when the engine falls behind the
-    /// clock, so it has to allow for the lag rather than fight it.
+    /// How much the engine may hold above `Lead` before the pump stops feeding.
+    /// It covers the count's lag, measured at 100 to 150 ms, and the shift
+    /// symbols the engine has to transmit that the clock does not know about.
     public const int Slack = 3;
 
     /// How often the engine is asked how much it has left.