hop2 0.11.9 → 0.11.10

package/hay/CHANGELOG.md

@@ -32,6 +32,9 @@
 
 ### Bug Fixes
 
+#### Web terminal
+- **Claude screens render completely on attach without a scroll**: Hop now starts its authoritative screen grid when a session enters alternate-screen or mouse-reporting TUI mode, before startup rows can fall out of a bounded replay tail. Full-screen attaches use that serialized screen, and direct snapshot paints re-arm one delayed repaint in case the browser misses the first WebGL frame.
+
 #### Session restore
 - **`hop restore` actually restores now (Claude conversations included), from the SessionStart-hook records**: restore built its candidate list from the workspace-scoped session store, which is only populated when a workspace is active — and no workspace is ever activated in normal use, so `restore` found nothing and silently restored zero sessions. It now sources candidates directly from the durable per-session records the SessionStart hook writes (`~/.hop2/claude-sessions/<name>.json` = `{ sessionId, cwd }`), which survive a crash/reboot and carry the exact conversation id. So after a restart, `hop restore` recreates each session in its directory and resumes its Claude conversation with `claude --resume <id>` — no manual capture step. Sessions already live are skipped (idempotent), and `hop restore` now starts the daemon itself if it isn't running, so post-reboot recovery is a single command. `--dry-run` previews the plan. Records are pruned when a session is deleted, so restore never resurrects a session you intentionally closed (and if an unwanted one does come back, deleting it once keeps it gone).
 - **`hopx_agent_turn` no longer runs non-UI input twice**: in `readable_raw` mode (and `auto` resolving to it — i.e. a plain shell or any non-alternate-screen agent), a synchronous turn pre-sent the input and *then* sent it again via the combined send+wait, so a command driven through `hopx_agent_turn` executed twice. The pre-send is now done only for the paths that need it (the `ui` branch and async turns, which return before the combined call); non-UI synchronous turns let the single send+wait do the send. UI and async turns are unchanged.

package/hay/apps/server/src/rooms.ts

@@ -179,6 +179,7 @@ class ClientState {
   // Output broadcasts are withheld meanwhile (see broadcast) and delivered
   // as catch-up appended to the snapshot itself.
   awaitingSnapshot = false;
+  snapshotCatchUp: string[] = [];
   id: string;
   name: string;
   color: string;
@@ -261,10 +262,15 @@ export class Room extends EventEmitter {
   // connect created the room, so its hello carries created=true.
   private hasHadClient = false;
   // Authoritative screen state for serialized attach (see screenGrid.ts).
-  // Created lazily once the headless deps load; hydrated from the retained
-  // ring at creation so bytes that arrived earlier are never missing.
+  // Start it as soon as a TUI advertises alternate-screen or mouse mode, so
+  // rows painted once at startup cannot age out of a bounded replay tail.
+  // Plain shells stay lazy and pay no grid cost until somebody attaches.
   private grid: ScreenGrid | null = null;
   private gridHydrated = false;
+  private gridStartPending = false;
+  private gridUnavailable = false;
+  private gridPendingSeed: string[] | null = null;
+  private gridPendingSeedBytes = 0;
 
   constructor(id: string, ptyFactory: PtyFactory, initialSize: { cols: number; rows: number }, options: RoomCreateOptions) {
     super();
@@ -297,6 +303,7 @@ export class Room extends EventEmitter {
       this.lastActivityAt = now();
       this.appendOutput(data);
       this.updateTerminalState(data);
+      this.startTuiGrid();
       this.answerTerminalQueriesIfHeadless(data);
       this.broadcast({ type: "output", data });
       this.emit("pty_output", { roomId: this.id, data, timestamp: now() });
@@ -445,19 +452,20 @@ export class Room extends EventEmitter {
       // Everything already in the ring at THIS moment will be in the
       // serialized screen; everything after it will not (grid writes queue
       // behind the serialize marker). Mute output to this client until the
-      // snapshot goes out, then hand it the exact delta from this cursor.
+      // snapshot goes out, retaining the exact withheld chunks for catch-up.
       client.awaitingSnapshot = true;
-      const catchUpFrom = this.outputStart + this.outputBytes;
+      client.snapshotCatchUp = [];
       gridForAttach.serialize((serialized) => {
         if (this.ended || !this.clients.has(client.id) || !socket.isOpen()) {
           client.awaitingSnapshot = false;
+          client.snapshotCatchUp = [];
           return;
         }
         if (serialized === null) {
-          // Raw fallback reads the ring as it stands NOW — everything the
-          // mute withheld is inside it. Unmute first so nothing new slips
-          // into the erased-by-reset gap either (raw has no RIS).
+          // Raw fallback reads the ring as it stands NOW. Unmute first so
+          // nothing new slips into the handoff (raw has no in-band RIS).
           client.awaitingSnapshot = false;
+          client.snapshotCatchUp = [];
           sendRawSnapshot();
           wiggle();
           return;
@@ -473,16 +481,17 @@ export class Room extends EventEmitter {
         // Catch-up: output that arrived while the snapshot was being
         // serialized. Appended INSIDE the snapshot payload so snapshot and
         // delta land as one atomic parse — no frame between reset and delta.
-        const catchUp = this.getOutputSince(catchUpFrom);
+        const catchUp = client.snapshotCatchUp.join("");
         socket.send(JSON.stringify({
           type: "snapshot",
           // In-band RIS: every client applies the serialized screen onto a
           // clean slate, including ones that don't reset on their own.
-          data: "\x1bc" + serialized + modeSeq + (catchUp.reset ? "" : catchUp.data),
+          data: "\x1bc" + serialized + modeSeq + catchUp,
           capped: this.outputBytes > SERIALIZED_CAPPED_HINT_BYTES,
           ...snapshotFlags()
         } satisfies ServerMessage));
         client.awaitingSnapshot = false;
+        client.snapshotCatchUp = [];
         // No wiggle: the serialized grid IS the current screen.
       }, serializedScrollback);
     } else {
@@ -564,16 +573,23 @@ export class Room extends EventEmitter {
 
   private updateTerminalState(data: string) {
     const combined = this.controlSequenceTail + data;
+    const tailLength = this.controlSequenceTail.length;
+    const risIndex = combined.lastIndexOf("\x1bc");
+    // Only process a RIS that ends in this chunk; one entirely inside the
+    // carry tail was already applied on the preceding call. Modes before the
+    // last new RIS are reset, while later sequences in the same chunk win.
+    const hasNewRis = risIndex !== -1 && risIndex + 2 > tailLength;
+    const stateInput = hasNewRis ? combined.slice(risIndex + 2) : combined;
 
     // Parse CSI mode sequences (cursor visibility, alternate screen)
     const regex = /\x1b\[\?([0-9;]*)([hl])/g;
     let match: RegExpExecArray | null;
-    let nextAlternate = this.alternateScreen;
-    let nextCursorHidden = this.cursorHidden;
+    let nextAlternate = hasNewRis ? false : this.alternateScreen;
+    let nextCursorHidden = hasNewRis ? false : this.cursorHidden;
 
-    let nextMouseReporting = this.mouseReporting;
-    let nextMouseSgr = this.mouseSgr;
-    while ((match = regex.exec(combined)) !== null) {
+    let nextMouseReporting = hasNewRis ? false : this.mouseReporting;
+    let nextMouseSgr = hasNewRis ? false : this.mouseSgr;
+    while ((match = regex.exec(stateInput)) !== null) {
       const params = match[1].split(";").filter(Boolean);
       const mode = match[2];
       for (const param of params) {
@@ -593,10 +609,10 @@ export class Room extends EventEmitter {
 
     // Enhanced keyboard reporting: kitty keyboard protocol (CSI >flags u push /
     // CSI <n u pop / CSI =flags u set) and xterm modifyOtherKeys (CSI >4;n m).
-    let nextKeyboardEnhanced = this.keyboardEnhanced;
+    let nextKeyboardEnhanced = hasNewRis ? false : this.keyboardEnhanced;
     const kbdRegex = /\x1b\[([<>=])[0-9;:]*u|\x1b\[>([0-9;]*)m/g;
     let kbdMatch: RegExpExecArray | null;
-    while ((kbdMatch = kbdRegex.exec(combined)) !== null) {
+    while ((kbdMatch = kbdRegex.exec(stateInput)) !== null) {
       if (kbdMatch[1] !== undefined) {
         nextKeyboardEnhanced = kbdMatch[1] !== "<"; // push/set = on, pop = off
       } else {
@@ -954,7 +970,10 @@ export class Room extends EventEmitter {
       // serialize marker). That silent loss was 'the screen is stale until
       // the app repaints' on every attach that raced live output. The
       // withheld bytes are delivered as catch-up appended to the snapshot.
-      if (isOutput && client.awaitingSnapshot) continue;
+      if (isOutput && client.awaitingSnapshot) {
+        client.snapshotCatchUp.push((message as { data: string }).data);
+        continue;
+      }
       if (client.socket.isOpen()) {
         client.socket.send(payload);
       }
@@ -1052,13 +1071,38 @@ export class Room extends EventEmitter {
     }
   }
 
-  // Grids are LAZY: created on the first serialized attach, not on output,
-  // so a room nobody ever opens (agent fleets) pays no grid memory at all.
-  // Creation hydrates from a bounded ring tail — deep enough to contain any
-  // app's last full repaint plus every update since, which is all screen
-  // correctness needs; serialized scrollback is bounded anyway.
+  // Incremental TUIs paint some rows once and then update other regions for
+  // hours. Reconstructing their first grid from any bounded tail can therefore
+  // omit cells until the app happens to repaint (for example, on scroll).
+  // Begin tracking at TUI entry; dependency loading is shared and normally
+  // finishes first, but the callback covers a TUI that starts immediately.
+  private startTuiGrid() {
+    if (!SERIALIZED_ATTACH_ENABLED || this.grid || this.gridStartPending || this.gridUnavailable || this.ended) return;
+    if (!this.alternateScreen && !this.mouseReporting) return;
+    if (screenGridsAvailable()) {
+      this.gridUnavailable = this.ensureGrid() === null;
+      return;
+    }
+    this.gridStartPending = true;
+    this.gridPendingSeed = [this.tailOutput(MAX_BUFFER_SIZE)];
+    this.gridPendingSeedBytes = this.gridPendingSeed[0].length;
+    void loadScreenGridDeps().then((available) => {
+      this.gridStartPending = false;
+      this.gridUnavailable = !available;
+      const seed = this.gridPendingSeed?.join("") ?? "";
+      this.gridPendingSeed = null;
+      this.gridPendingSeedBytes = 0;
+      if (available && !this.ended) {
+        this.gridUnavailable = this.ensureGrid(seed) === null;
+      }
+    });
+  }
+
+  // Plain-shell grids remain lazy until the first serialized attach. Creation
+  // hydrates from a bounded ring tail; append-only shell output is safely
+  // reconstructible from that tail, unlike the incremental TUI path above.
   private static readonly GRID_HYDRATE_BYTES = 2_000_000;
-  private ensureGrid(): ScreenGrid | null {
+  private ensureGrid(seed?: string): ScreenGrid | null {
     if (!SERIALIZED_ATTACH_ENABLED || this.ended) return this.grid;
     if (!this.grid && screenGridsAvailable()) {
       this.grid = createScreenGrid(this.activeCols, this.activeRows);
@@ -1067,8 +1111,8 @@ export class Room extends EventEmitter {
         if (this.outputBytes > 0) {
           // Cut at a line boundary (same trick as boundSnapshotReplay) so a
           // slice landing mid-escape-sequence can't garble the parse head.
-          let tail = this.tailOutput(Room.GRID_HYDRATE_BYTES);
-          if (this.outputBytes > tail.length) {
+          let tail = seed ?? this.tailOutput(Room.GRID_HYDRATE_BYTES);
+          if (seed === undefined && this.outputBytes > tail.length) {
             const nl = tail.indexOf("\n");
             if (nl !== -1 && nl < 8192) tail = tail.slice(nl + 1);
           }
@@ -1082,6 +1126,20 @@ export class Room extends EventEmitter {
   /** O(1) append; trims whole chunks from the head past MAX_BUFFER_SIZE. */
   private appendOutput(data: string) {
     if (!data) return;
+    if (this.gridPendingSeed) {
+      this.gridPendingSeed.push(data);
+      this.gridPendingSeedBytes += data.length;
+      while (this.gridPendingSeed.length > 1
+          && this.gridPendingSeedBytes - this.gridPendingSeed[0].length >= MAX_BUFFER_SIZE) {
+        this.gridPendingSeedBytes -= this.gridPendingSeed[0].length;
+        this.gridPendingSeed.shift();
+      }
+      if (this.gridPendingSeed.length === 1 && this.gridPendingSeedBytes > MAX_BUFFER_SIZE) {
+        const tail = this.gridPendingSeed[0].slice(-MAX_BUFFER_SIZE);
+        this.gridPendingSeed[0] = tail;
+        this.gridPendingSeedBytes = tail.length;
+      }
+    }
     this.outputChunks.push(data);
     this.outputBytes += data.length;
     while (this.outputChunks.length > 1 && this.outputBytes - this.outputChunks[0].length >= MAX_BUFFER_SIZE) {

package/hay/apps/server/test/rooms.test.ts

@@ -766,6 +766,25 @@ describe("Room", () => {
       expect(snapshot.mouseReporting).toBe(true);
     });
 
+    it("tracks TUI rows before they age out of the grid hydration tail", async () => {
+      const { room, pty } = await setup("early-grid");
+      pty().emit("\x1b[?1002h\x1b[?1006h");
+      pty().emit("\x1b[2J\x1b[1;1HROW1-EARLY-GRID-MARKER");
+      // Repaint only row 20 for more than the lazy grid's 2MB hydration
+      // window. A grid first created at attach would have no row 1 to send.
+      const updateBatch = ("\x1b[20;1H\x1b[K" + "x".repeat(60)).repeat(64);
+      for (let i = 0; i < 500; i++) pty().emit(updateBatch);
+
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "late", name: "Late", colorIndex: 0, cols: 80, rows: 24, replayBytes: 65536 },
+        socket
+      );
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data)).toContain("ROW1-EARLY-GRID-MARKER");
+      expect(room.getPreviewSource(2_000_000).output).not.toContain("ROW1-EARLY-GRID-MARKER");
+    });
+
     it("flags a serialized snapshot as capped when deeper raw history exists", async () => {
       const { room, pty } = await setup("capped");
       const big = "\x1b[20;1H" + "y".repeat(4096);
@@ -810,6 +829,44 @@ describe("Room", () => {
       expect(after.some((m) => String(m.data).includes("LATE-MARKER-XYZ"))).toBe(false);
     });
 
+    it("retains catch-up larger than the incremental preview limit", async () => {
+      const { room, pty } = await setup("large-race");
+      pty().emit("\x1b[?1002h\x1b[2J\x1b[1;1Hbefore large catch-up");
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "large-racer", name: "Large Racer", colorIndex: 0, cols: 80, rows: 24, replayBytes: 65536 },
+        socket
+      );
+      // Larger than getOutputSince's 1MB default: cursor-based catch-up used
+      // to reset here and silently drop every withheld byte.
+      const late = "x".repeat(1_100_000) + "LARGE-CATCHUP-MARKER";
+      pty().emit(late);
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data)).toContain("LARGE-CATCHUP-MARKER");
+      const live = readMessages(socket).filter((m) => m.type === "output");
+      expect(live.some((m) => String(m.data).includes("LARGE-CATCHUP-MARKER"))).toBe(false);
+    });
+
+    it("clears tracked private modes when the app sends RIS", async () => {
+      const { room, pty } = await setup("ris-modes");
+      pty().emit("\x1b[?1049h\x1b[?1002h\x1b[?1006h\x1b[?25l\x1b[>1u");
+      // Split ESC c across chunks to cover the control-sequence carry path.
+      pty().emit("\x1b");
+      pty().emit("c\x1b[2J\x1b[1;1HAFTER-RIS");
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "after-ris", name: "After RIS", colorIndex: 0, cols: 80, rows: 24, replayBytes: 65536 },
+        socket
+      );
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data)).toContain("AFTER-RIS");
+      expect(snapshot.alternateScreen).toBe(false);
+      expect(snapshot.mouseReporting).toBe(false);
+      expect(snapshot.mouseSgr).toBe(false);
+      expect(snapshot.cursorHidden).toBe(false);
+      expect(snapshot.keyboardEnhanced).toBe(false);
+    });
+
     it("replay=0 means no snapshot at all — live stream only", async () => {
       const { room, pty } = await setup("claim");
       pty().emit("some prior output\r\n");

package/hay/apps/web/src/App.tsx

@@ -519,6 +519,12 @@ const App = () => {
   const shouldReconnectRef = useRef(true);
   const connectNonceRef = useRef(0);
   const userScrolledUpRef = useRef(false);
+  // Set by every write into the terminal; the render watchdog only spends a
+  // refresh when something actually changed since its last tick.
+  const outputSinceTickRef = useRef(true);
+  // Timestamp of the last bytes from the session — the ack signal that
+  // paces synthetic wheel steps (see scrollFlywheel appGlide).
+  const lastOutputAtRef = useRef(0);
   // Late-bound hooks for the voice controller (created before these exist).
   const handleUserInputRef = useRef<((data: string) => void) | null>(null);
   const pushNoticeRef = useRef<((m: string) => void) | null>(null);
@@ -928,8 +934,18 @@ const App = () => {
     return presence.find((client) => client.id === controllerId)?.name ?? "Someone";
   }, [presence, controllerId]);
 
+  // Local echo policy. Exclusive control keeps the old rule. In COLLAB mode
+  // (the default for every shared session) echo used to be flatly OFF — so
+  // each character waited a full round trip, tunnel RTT included, even when
+  // you were the only person typing, which is the overwhelmingly common
+  // case. Echo now stays on unless another client is ACTUALLY typing right
+  // now (presence carries the flag), and drops the instant one starts. A
+  // sub-second overlap before presence propagates is absorbed by the
+  // reconciler's guards (complex-chunk passthrough, two-strike clear).
+  const othersTyping = presence.some((c) => c.id !== clientId && c.typing);
   const optimisticActive =
-    LATENCY_COMP && status === "connected" && !collabMode && controllerId === clientId;
+    LATENCY_COMP && status === "connected" && !othersTyping
+    && (collabMode ? true : controllerId === clientId);
 
   useEffect(() => {
     if (optimisticPrevRef.current && !optimisticActive) {
@@ -1251,6 +1267,8 @@ const App = () => {
     if (!termRef.current) {
       return;
     }
+    outputSinceTickRef.current = true;
+    lastOutputAtRef.current = performance.now(); // same clock the flywheel compares
 
     // Filter focus reporting sequences that can leak as visible text
     const filtered = data.replace(/\x1b\[I/g, '').replace(/\x1b\[O/g, '');
@@ -1339,6 +1357,9 @@ const App = () => {
           // snapshot and must land where the snapshot would.
           t.scrollToBottom();
           t.refresh(0, t.rows - 1);
+          // This write bypasses writeToTerminal(). Re-arm the delayed render
+          // invariant after parsing, so a missed WebGL frame self-heals.
+          outputSinceTickRef.current = true;
         });
       })
       .catch(() => { /* fast paint is best-effort */ });
@@ -1504,6 +1525,10 @@ const App = () => {
                 userScrolledUpRef.current = false;
               }
               t.refresh(0, t.rows - 1);
+              // Snapshot writes bypass writeToTerminal(). Set this only after
+              // parsing so a slow snapshot cannot have its retry consumed
+              // before there is anything complete to repaint.
+              outputSinceTickRef.current = true;
               // The snapshot has fully landed: only from here on can a
               // viewport-top event mean a user gesture.
               lastViewportYRef.current = t.buffer.active.viewportY;
@@ -1699,7 +1724,8 @@ const App = () => {
         () => termRef.current,
         {
           linesPerNotch: 4, // mirrors scrollSensitivity above
-          lineHeightPx: () => Math.max(1, ((terminal as any)._core?._renderService?.dimensions?.css?.cell?.height) || fontSize * 1.3)
+          lineHeightPx: () => Math.max(1, ((terminal as any)._core?._renderService?.dimensions?.css?.cell?.height) || fontSize * 1.3),
+          lastOutputAt: () => lastOutputAtRef.current
         }
       );
     }
@@ -2565,6 +2591,12 @@ const App = () => {
       if (document.hidden || switcherOpenRef.current) return;
       const t = termRef.current;
       if (!t) return;
+      // Idle sessions get no tick: a full refresh every 1.4s on a screen
+      // nothing wrote to re-rasterizes identical rows forever (measurable
+      // on battery with several sessions open). Output sets the flag; one
+      // enforcement pass clears it.
+      if (!outputSinceTickRef.current) return;
+      outputSinceTickRef.current = false;
       try {
         const buf = t.buffer.active;
         if (!userScrolledUpRef.current && buf.viewportY < buf.baseY) t.scrollToBottom();

package/hay/apps/web/src/components/SessionSwitcher.tsx

@@ -346,6 +346,8 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
   const kbdEnhancedRef = useRef(false);
   // null = watching; "live"/"down" = connected state for the chrome.
   const [conn, setConn] = useState<"live" | "down" | null>(null);
+  // Last bytes from the session — paces the app-scroll coast (flywheel).
+  const lastOutputAtRef = useRef(0);
   // Hold-space voice, same controller as the full screen — the tile is where
   // typing mostly happens now, and dictation not existing here was most of
   // "voice doesn't always work".
@@ -653,6 +655,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
     box.addEventListener("pointercancel", endPan, true);
 
     const detachFlywheel = attachScrollFlywheel(box, () => termRef.current as never, {
+      lastOutputAt: () => lastOutputAtRef.current,
       linesPerNotch: 4,
       lineHeightPx: () => Math.max(1, ((term as never as { _core?: { _renderService?: { dimensions?: { css?: { cell?: { height?: number } } } } } })._core
         ?._renderService?.dimensions?.css?.cell?.height) || PREVIEW_BASE_FS * 1.3)
@@ -906,6 +909,7 @@ const LiveTile = ({ wsBase, room, userName, theme, live, claudeApp, claimSize, a
               ? m.keyboardEnhanced
               : scanKeyboardProtocol(String(m.data || ""), false);
           } else if (m.type === "output") {
+            lastOutputAtRef.current = performance.now();
             term.write(m.data);
             kbdEnhancedRef.current = scanKeyboardProtocol(String(m.data || ""), kbdEnhancedRef.current);
           } else if (m.type === "active_size") {

package/hay/apps/web/src/utils/scrollFlywheel.ts

@@ -59,6 +59,14 @@ export type FlywheelOptions = {
   linesPerNotch: number;
   /** Pixel height of one terminal row (for pixel-mode delta → lines). */
   lineHeightPx: () => number;
+  /**
+   * Timestamp of the last output received from the session, when the caller
+   * has one. Paces app-owned coasting: a tracking app repaints per wheel
+   * step and each step costs a network round trip — a fixed-rate coast
+   * outruns a distant app and queues repaints, which reads as scroll LAG.
+   * With this signal each synthetic step waits for evidence the app kept up.
+   */
+  lastOutputAt?: () => number;
 };
 
 /**
@@ -140,6 +148,7 @@ export const attachScrollFlywheel = (
     }
   };
 
+  let lastStepAt = 0;
   const appGlide = (t: number) => {
     appRaf = 0;
     const term = getTerm();
@@ -147,11 +156,21 @@ export const attachScrollFlywheel = (
     if (!term || terminalOwnsScrolling(term) || Math.abs(appVel) < 4) return stopApp();
     const dt = lastFrameAt ? Math.min(0.05, (t - lastFrameAt) / 1000) : 0.016;
     lastFrameAt = t;
-    appCarry += Math.abs(appVel) * dt;
-    let steps = Math.trunc(appCarry);
-    appCarry -= steps;
-    while (steps-- > 0) dispatchStep();
-    appVel *= Math.exp(-dt / 0.35);
+    // ACK pacing: after each synthetic step, wait for the app to answer
+    // (any output) before spending the next one — the coast then runs at
+    // the link's real rhythm instead of flooding a slow one. 300ms cap so
+    // an app that repaints invisibly (no bytes for us) can't stall the
+    // glide forever.
+    const ackAt = opts.lastOutputAt ? opts.lastOutputAt() : Infinity;
+    const waitingForAck = lastStepAt > 0 && ackAt < lastStepAt && performance.now() - lastStepAt < 300;
+    if (!waitingForAck) {
+      appCarry += Math.abs(appVel) * dt;
+      let steps = Math.trunc(appCarry);
+      appCarry -= steps;
+      if (steps > 0) lastStepAt = performance.now();
+      while (steps-- > 0) dispatchStep();
+      appVel *= Math.exp(-dt / 0.35);
+    }
     appRaf = requestAnimationFrame(appGlide);
   };