hop2 0.11.3 → 0.11.5

package/hay/apps/server/package.json

@@ -20,8 +20,10 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "hay-shared": "*",
+    "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/headless": "^6.0.0",
     "express": "^4.21.2",
+    "hay-shared": "*",
     "node-pty-prebuilt-multiarch": "^0.10.1-pre.5",
     "ws": "^8.18.0"
   },

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

@@ -5,6 +5,8 @@ import type { IPty } from "node-pty-prebuilt-multiarch";
 import { clientMessageSchema, pickPresenceColor, safeParseClientMessage } from "hay-shared";
 import type { ClientMessage, PresenceClient, ServerMessage } from "hay-shared";
 import type { PtyFactory } from "./pty";
+import { createScreenGrid, loadScreenGridDeps, screenGridsAvailable } from "./screenGrid";
+import type { ScreenGrid } from "./screenGrid";
 
 export type SocketAdapter = {
   send: (data: string) => void;
@@ -26,7 +28,11 @@ export type ClientInfo = {
   cols: number;
   rows: number;
   // Optional per-connection cap for the join snapshot (clamped to the
-  // room-level bound). Monitors request ~64KB.
+  // room-level bound). 0 = no snapshot at all (live stream only — size-claim
+  // and kick-start sockets). Bounded requests (tiles ~64KB, web full screen
+  // ~384KB) are served a SERIALIZED grid — complete and a few KB — while
+  // larger requests are a deliberate ask for scrollback DEPTH and keep the
+  // raw-tail replay. Unset = raw tail at the room default (CLI reattach).
   replayBytes?: number;
   // False = skip the equal-size attach "wiggle" (the −1/+1 column repaint
   // nudge). Wall tiles decline it: they arrive already showing the current
@@ -96,6 +102,21 @@ const boundSnapshotReplay = (buffer: string): string => {
   return tail;
 };
 
+// Serialized attach: connections asking for a bounded snapshot (web full
+// screen, wall tiles) get the room grid serialized — complete and a few KB —
+// instead of a raw tail. Larger requests are a deliberate ask for DEPTH
+// (deep-history reload, CLI full-scrollback reattach): raw tail reconstructs
+// far more scrollback than the grid retains, so those keep the old path.
+// Kill switch: HAY_SERIALIZED_ATTACH=0 reverts every attach to raw tails.
+const SERIALIZED_ATTACH_ENABLED = process.env.HAY_SERIALIZED_ATTACH !== "0";
+const SERIALIZED_MAX_REQUEST = 524_288;
+// Above this much retained raw history, the serialized snapshot is probably
+// shallower than what a deep replay could reconstruct — tell the client, so
+// its scroll-to-top full-history reload still knows to offer itself (it used
+// to infer cappedness from raw snapshot SIZE, which a few-KB serialized
+// snapshot never trips).
+const SERIALIZED_CAPPED_HINT_BYTES = 262_144;
+
 // Autofit-on-attach: a resize may claim the shared size when every OTHER
 // client has been input-idle at least this long. Someone actively typing keeps
 // the size they set; a viewer opening the session after everyone went idle
@@ -235,6 +256,11 @@ export class Room extends EventEmitter {
   // False until the first client attaches: that client is the one whose
   // 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.
+  private grid: ScreenGrid | null = null;
+  private gridHydrated = false;
 
   constructor(id: string, ptyFactory: PtyFactory, initialSize: { cols: number; rows: number }, options: RoomCreateOptions) {
     super();
@@ -354,45 +380,92 @@ export class Room extends EventEmitter {
       } satisfies ServerMessage)
     );
 
-    if (this.outputBytes > 0) {
+    const replayRequest = Number.isFinite(info.replayBytes) ? Math.floor(info.replayBytes as number) : null;
+    const snapshotFlags = () => ({
+      alternateScreen: this.alternateScreen,
+      cursorHidden: this.cursorHidden,
+      keyboardEnhanced: this.keyboardEnhanced,
+      mouseReporting: this.mouseReporting,
+      mouseSgr: this.mouseSgr
+    });
+    const sendRawSnapshot = () => {
       socket.send(JSON.stringify({
         type: "snapshot",
         data: boundSnapshotReplay(this.tailOutput(
-          Number.isFinite(info.replayBytes) && (info.replayBytes as number) > 0
-            ? Math.min(SNAPSHOT_REPLAY_BYTES, Math.floor(info.replayBytes as number))
+          replayRequest !== null && replayRequest > 0
+            ? Math.min(SNAPSHOT_REPLAY_BYTES, replayRequest)
             : SNAPSHOT_REPLAY_BYTES
         )),
-        alternateScreen: this.alternateScreen,
-        cursorHidden: this.cursorHidden,
-        keyboardEnhanced: this.keyboardEnhanced,
-        mouseReporting: this.mouseReporting,
-        mouseSgr: this.mouseSgr
+        ...snapshotFlags()
       } satisfies ServerMessage));
-    }
-
-    // The snapshot is a raw byte TAIL, and incremental TUIs (Claude Code/Ink)
-    // never re-emit rows that don't change — e.g. the input box's horizontal
-    // border lines — so the replay can be missing them. When this client's
-    // size differs from the PTY's, the attach resize triggers a full repaint
-    // anyway; when sizes are EQUAL nothing would repaint, so nudge: a one-
-    // column wiggle (tmux's redraw trick) makes full-screen apps repaint.
-    if (
-      info.nudge !== false &&
-      client.cols === this.activeCols &&
-      client.rows === this.activeRows &&
-      this.activeCols > 4 &&
-      !this.ended
-    ) {
-      const cols = this.activeCols;
-      const rows = this.activeRows;
-      try { this.pty.resize(cols - 1, rows); } catch { /* pty may be gone */ }
-      setTimeout(() => {
-        if (this.ended) return;
-        // Only bounce back if nobody claimed a different size meanwhile.
-        if (this.activeCols === cols && this.activeRows === rows) {
-          try { this.pty.resize(cols, rows); } catch { /* pty may be gone */ }
+    };
+    // A raw TAIL can be missing rows incremental TUIs (Claude Code/Ink) never
+    // re-emitted within the window. When this client's size differs from the
+    // PTY's, the attach resize triggers a full repaint anyway; when sizes are
+    // EQUAL nothing would repaint, so nudge: a one-column wiggle (tmux's
+    // redraw trick) makes full-screen apps repaint. Raw-path compensation
+    // only — a serialized attach is already complete.
+    const wiggle = () => {
+      if (
+        info.nudge !== false &&
+        client.cols === this.activeCols &&
+        client.rows === this.activeRows &&
+        this.activeCols > 4 &&
+        !this.ended
+      ) {
+        const cols = this.activeCols;
+        const rows = this.activeRows;
+        try { this.pty.resize(cols - 1, rows); } catch { /* pty may be gone */ }
+        setTimeout(() => {
+          if (this.ended) return;
+          // Only bounce back if nobody claimed a different size meanwhile.
+          if (this.activeCols === cols && this.activeRows === rows) {
+            try { this.pty.resize(cols, rows); } catch { /* pty may be gone */ }
+          }
+        }, 60);
+      }
+    };
+    // replay=0 is an explicit "live stream only" (size-claim and kick-start
+    // sockets): honor it — these connections used to fall through to the
+    // DEFAULT cap and silently pull the full 1.5MB tail they never read.
+    const wantsSnapshot = this.outputBytes > 0 && replayRequest !== 0;
+    const gridForAttach = wantsSnapshot && replayRequest !== null && replayRequest > 0
+      && replayRequest <= SERIALIZED_MAX_REQUEST
+      ? this.ensureGrid()
+      : null;
+    // Scrollback rides along in proportion to the ask: a tile's ~64KB request
+    // wants the screen (plus enough history for a casual scroll-up), while
+    // the web full screen's ~384KB request wants the grid's full depth.
+    const serializedScrollback = replayRequest !== null && replayRequest <= 131_072 ? 200 : undefined;
+    if (gridForAttach) {
+      gridForAttach.serialize((serialized) => {
+        if (this.ended || !this.clients.has(client.id) || !socket.isOpen()) return;
+        if (serialized === null) {
+          sendRawSnapshot();
+          wiggle();
+          return;
         }
-      }, 60);
+        // Serialization carries the SCREEN but not private modes — the raw
+        // tail incidentally carried the app's mode-enable sequences, and
+        // clients (each terminal's own mode state) depend on them to route
+        // wheel events to the app vs local scrollback and to gate selection.
+        // Re-assert them in-band so every client — including ones that never
+        // read the separate flags — ends up in the app's actual modes.
+        const modeSeq = (this.mouseReporting ? "\x1b[?1002h" + (this.mouseSgr ? "\x1b[?1006h" : "") : "")
+          + (this.cursorHidden ? "\x1b[?25l" : "");
+        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,
+          capped: this.outputBytes > SERIALIZED_CAPPED_HINT_BYTES,
+          ...snapshotFlags()
+        } satisfies ServerMessage));
+        // No wiggle: the serialized grid IS the current screen.
+      }, serializedScrollback);
+    } else {
+      if (wantsSnapshot) sendRawSnapshot();
+      if (replayRequest !== 0) wiggle();
     }
 
     // Send current cwd to the new client
@@ -802,6 +875,7 @@ export class Room extends EventEmitter {
       this.pty.resize(cols, rows);
       this.activeCols = cols;
       this.activeRows = rows;
+      this.grid?.resize(cols, rows);
       this.activeClientId = client.id;
       // Broadcast the new active size to other clients so they can adjust —
       // and CONFIRM to the winner: a claimant otherwise learns nothing on
@@ -947,6 +1021,33 @@ 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.
+  private static readonly GRID_HYDRATE_BYTES = 2_000_000;
+  private ensureGrid(): ScreenGrid | null {
+    if (!SERIALIZED_ATTACH_ENABLED || this.ended) return this.grid;
+    if (!this.grid && screenGridsAvailable()) {
+      this.grid = createScreenGrid(this.activeCols, this.activeRows);
+      if (this.grid && !this.gridHydrated) {
+        this.gridHydrated = true;
+        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) {
+            const nl = tail.indexOf("\n");
+            if (nl !== -1 && nl < 8192) tail = tail.slice(nl + 1);
+          }
+          this.grid.write(tail);
+        }
+      }
+    }
+    return this.grid;
+  }
+
   /** O(1) append; trims whole chunks from the head past MAX_BUFFER_SIZE. */
   private appendOutput(data: string) {
     if (!data) return;
@@ -964,6 +1065,9 @@ export class Room extends EventEmitter {
       this.outputChunks[0] = only;
       this.outputBytes = only.length;
     }
+    // Lazily-created grids hydrate from the ring at creation; here the grid
+    // (when it exists) just follows along with the delta.
+    this.grid?.write(data);
   }
 
   /**
@@ -989,6 +1093,8 @@ export class Room extends EventEmitter {
     if (this.ended) return;
     this.ended = true;
     this.stopCwdPolling();
+    this.grid?.dispose();
+    this.grid = null;
     if (this.cleanupTimer) {
       clearTimeout(this.cleanupTimer);
       this.cleanupTimer = null;
@@ -1101,6 +1207,9 @@ export class RoomManager {
 
   constructor(ptyFactory: PtyFactory) {
     this.ptyFactory = ptyFactory;
+    // Start loading the headless deps now so the first attach can serialize;
+    // rooms hydrate their grid from the ring when the load wins the race late.
+    if (SERIALIZED_ATTACH_ENABLED) void loadScreenGridDeps();
   }
 
   getRoom(roomId: string, initialSize: { cols: number; rows: number }, cwdOrOptions: string | RoomCreateOptions) {

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

@@ -0,0 +1,145 @@
+// Server-side screen state — the authoritative grid behind serialized attach.
+//
+// The attach snapshot used to be a raw byte TAIL of the output ring. For
+// incremental TUIs (Claude Code/Ink) a tail is structurally incomplete: rows
+// that haven't changed recently were emitted before the tail window began, so
+// a freshly attached client rendered holes until the app happened to repaint.
+// That is the whole "have to scroll before it renders correctly" bug — the
+// wheel event reaches the app through mouse reporting and provokes a redraw
+// that resends the pixels the snapshot never carried.
+//
+// Feeding the room's output through a headless terminal instead means every
+// attach can serialize the complete current screen — a few KB, always whole —
+// and the resize "wiggle" repaint trick becomes unnecessary on this path.
+//
+// Loaded lazily and failure-tolerant: when @xterm/headless is unavailable a
+// room silently falls back to the raw-tail snapshot (+ wiggle), so a broken
+// dependency degrades to the old behavior instead of breaking attach.
+
+type HeadlessTerminal = {
+  write(data: string, callback?: () => void): void;
+  resize(cols: number, rows: number): void;
+  loadAddon(addon: unknown): void;
+  dispose(): void;
+};
+
+type SerializeAddonLike = {
+  serialize(options?: { scrollback?: number }): string;
+};
+
+type GridDeps = {
+  Terminal: new (options: Record<string, unknown>) => HeadlessTerminal;
+  SerializeAddon: new () => SerializeAddonLike;
+};
+
+// Scrollback lines the grid retains (and serialized attaches can carry).
+// This bounds host memory per room — deeper history stays in the raw output
+// ring and reaches clients through the existing deep-history replay path.
+export const GRID_SCROLLBACK = (() => {
+  const env = Number(process.env.HAY_GRID_SCROLLBACK);
+  return Number.isFinite(env) && env >= 0 ? Math.floor(env) : 1000;
+})();
+
+let deps: GridDeps | null = null;
+let loading: Promise<boolean> | null = null;
+
+export const screenGridsAvailable = (): boolean => deps !== null;
+
+export const loadScreenGridDeps = (): Promise<boolean> => {
+  if (deps) return Promise.resolve(true);
+  if (loading) return loading;
+  loading = (async () => {
+    try {
+      // Some xterm builds touch browser globals at import time; shim the few
+      // they reach for (same trick the daemon uses for preview rendering).
+      const g = globalThis as Record<string, unknown>;
+      if (!g.window) g.window = g;
+      if (!g.self) g.self = g;
+      const [headless, serialize] = await Promise.all([
+        import("@xterm/headless"),
+        import("@xterm/addon-serialize")
+      ]);
+      // Both packages ship UMD/CJS: under Node's ESM interop the named
+      // exports may only exist on `default`, so check both shapes.
+      type HeadlessModule = { Terminal?: GridDeps["Terminal"]; default?: { Terminal?: GridDeps["Terminal"] } };
+      type SerializeModule = { SerializeAddon?: GridDeps["SerializeAddon"]; default?: { SerializeAddon?: GridDeps["SerializeAddon"] } };
+      const Terminal = (headless as HeadlessModule).Terminal ?? (headless as HeadlessModule).default?.Terminal;
+      const SerializeAddon = (serialize as SerializeModule).SerializeAddon
+        ?? (serialize as SerializeModule).default?.SerializeAddon;
+      if (typeof Terminal !== "function" || typeof SerializeAddon !== "function") {
+        console.log("[hay] serialized attach unavailable (xterm exports not found) — raw-tail snapshots");
+        return false;
+      }
+      deps = { Terminal, SerializeAddon };
+      return true;
+    } catch (error) {
+      console.log(`[hay] serialized attach unavailable (${(error as Error)?.message || "load failed"}) — raw-tail snapshots`);
+      return false;
+    }
+  })();
+  return loading;
+};
+
+export type ScreenGrid = {
+  write(data: string): void;
+  resize(cols: number, rows: number): void;
+  /**
+   * Serialize AFTER everything already written has been parsed (xterm's
+   * write path is asynchronous). Calls back with null on failure so the
+   * caller can fall back to the raw-tail snapshot. `scrollback` bounds how
+   * many history lines ride along (tiles need far fewer than a full screen).
+   */
+  serialize(callback: (data: string | null) => void, scrollback?: number): void;
+  dispose(): void;
+};
+
+export const createScreenGrid = (cols: number, rows: number): ScreenGrid | null => {
+  if (!deps) return null;
+  let term: HeadlessTerminal;
+  let addon: SerializeAddonLike;
+  try {
+    term = new deps.Terminal({
+      cols: Math.max(2, cols),
+      rows: Math.max(1, rows),
+      scrollback: GRID_SCROLLBACK,
+      allowProposedApi: true
+    });
+    addon = new deps.SerializeAddon();
+    term.loadAddon(addon);
+  } catch {
+    return null;
+  }
+  let disposed = false;
+  return {
+    write(data: string) {
+      if (disposed) return;
+      try { term.write(data); } catch { /* parser hiccup — next write continues */ }
+    },
+    resize(nextCols: number, nextRows: number) {
+      if (disposed) return;
+      try { term.resize(Math.max(2, nextCols), Math.max(1, nextRows)); } catch { /* keep old size */ }
+    },
+    serialize(callback: (data: string | null) => void, scrollback: number = GRID_SCROLLBACK) {
+      if (disposed) { callback(null); return; }
+      try {
+        // An empty write's callback fires once all queued data has parsed —
+        // the serialize then reflects every byte up to this attach.
+        term.write("", () => {
+          if (disposed) { callback(null); return; }
+          try {
+            callback(addon.serialize({ scrollback: Math.max(0, Math.min(scrollback, GRID_SCROLLBACK)) }));
+          } catch {
+            callback(null);
+          }
+        });
+      } catch {
+        callback(null);
+      }
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      try { term.dispose(); } catch { /* already gone */ }
+    }
+  };
+};

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

@@ -707,4 +707,108 @@ describe("Room", () => {
       expect(delta.data).toBe("fresh");
     });
   });
+
+  describe("serialized attach", () => {
+    const setup = async (roomId: string) => {
+      const { loadScreenGridDeps } = await import("../src/screenGrid");
+      expect(await loadScreenGridDeps()).toBe(true);
+      let ptyInstance: FakePty | null = null;
+      const factory: PtyFactory = () => {
+        ptyInstance = new FakePty() as unknown as FakePty;
+        return ptyInstance as any;
+      };
+      const manager = new RoomManager(factory);
+      const room = manager.getRoom(roomId, { cols: 80, rows: 24 }, "/tmp");
+      return { room, pty: () => ptyInstance! };
+    };
+
+    const waitForSnapshot = async (socket: FakeSocket) => {
+      await vi.waitFor(() => {
+        expect(findMessages(socket, "snapshot").length).toBeGreaterThan(0);
+      });
+      return findMessages(socket, "snapshot")[0] as any;
+    };
+
+    // THE recurring bug, reproduced: an incremental TUI (Claude Code/Ink)
+    // paints a row once and never re-emits it; once enough updates pass, the
+    // row leaves every bounded raw tail. A client attaching off such a tail
+    // rendered holes until the app happened to repaint — "have to scroll
+    // before it renders correctly". The serialized grid carries the row no
+    // matter how long ago it was painted.
+    it("carries rows the bounded raw tail lost, without the wiggle", async () => {
+      const { room, pty } = await setup("serial");
+      // The app enables mouse tracking (as Claude Code does at startup) —
+      // long outside any bounded tail, and never emitted by serialization.
+      pty().emit("\x1b[?1002h\x1b[?1006h");
+      pty().emit("\x1b[2J\x1b[1;1HROW1-STABLE-BORDER-MARKER");
+      // In-place repaints of one region, Ink-style: no scrolling, so the
+      // marker row stays ON SCREEN while leaving every bounded byte tail.
+      const update = "\x1b[20;1H\x1b[K" + "x".repeat(60);
+      for (let i = 0; i < 1200; i++) pty().emit(update); // ~84KB > the 64KB ask
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "tile", name: "Tile", colorIndex: 0, cols: 80, rows: 24, replayBytes: 65536 },
+        socket
+      );
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data).startsWith("\x1bc")).toBe(true);
+      expect(String(snapshot.data)).toContain("ROW1-STABLE-BORDER-MARKER");
+      // The raw tail this connection would have gotten cannot contain it.
+      expect(room.getPreviewSource(65536).output).not.toContain("ROW1-STABLE-BORDER-MARKER");
+      // Complete screen delivered — nothing needs the repaint nudge.
+      expect(pty().resizes.some((r: { cols: number }) => r.cols === 79)).toBe(false);
+      // ~82KB of raw history is well under the deep-history hint threshold.
+      expect(snapshot.capped).toBe(false);
+      // Private modes ride along in-band: the attaching terminal must know
+      // the app owns the wheel, or tiles scroll their local buffer instead.
+      expect(String(snapshot.data)).toContain("\x1b[?1002h");
+      expect(String(snapshot.data)).toContain("\x1b[?1006h");
+      expect(snapshot.mouseReporting).toBe(true);
+    });
+
+    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);
+      for (let i = 0; i < 80; i++) pty().emit(big); // ~330KB ring
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "web", name: "Web", colorIndex: 0, cols: 80, rows: 24, replayBytes: 393216 },
+        socket
+      );
+      const snapshot = await waitForSnapshot(socket);
+      expect(String(snapshot.data).startsWith("\x1bc")).toBe(true);
+      expect(snapshot.capped).toBe(true);
+    });
+
+    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");
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "claim", name: "Claim", colorIndex: 0, cols: 80, rows: 24, replayBytes: 0, nudge: false },
+        socket
+      );
+      // Give any (buggy) async snapshot path a chance to fire before asserting.
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      expect(findMessages(socket, "snapshot")).toHaveLength(0);
+      expect(pty().resizes.some((r: { cols: number }) => r.cols === 79)).toBe(false);
+    });
+
+    it("a deep-history request keeps the raw tail replay", async () => {
+      const { room, pty } = await setup("deep");
+      pty().emit("\x1b[2J\x1b[1;1Hdeep-history-anchor\r\n");
+      pty().emit("z".repeat(200_000));
+      const socket = new FakeSocket();
+      room.attachClient(
+        { id: "deep", name: "Deep", colorIndex: 0, cols: 80, rows: 24, replayBytes: 1_572_864 },
+        socket
+      );
+      // Raw path is synchronous.
+      const snapshot = findMessages(socket, "snapshot")[0] as any;
+      expect(snapshot).toBeTruthy();
+      expect(String(snapshot.data).startsWith("\x1bc")).toBe(false);
+      expect(String(snapshot.data).length).toBeGreaterThan(200_000);
+      expect(String(snapshot.data)).toContain("deep-history-anchor");
+    });
+  });
 });

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

@@ -1430,9 +1430,12 @@ const App = () => {
           remoteMouseSgrRef.current = message.mouseSgr === true;
           optimisticEchoRef.current.reset();
           userScrolledUpRef.current = false;
-          // A snapshot near the requested bound was almost certainly cut —
-          // that's when the "load full history" pill is worth offering.
-          snapshotWasCappedRef.current = typeof message.data === "string" && message.data.length >= 350000
+          // Deeper history exists than this snapshot carries: the server says
+          // so outright for serialized snapshots (which are a few KB no
+          // matter how deep the session is), and for raw tails a payload near
+          // the requested bound was almost certainly cut.
+          snapshotWasCappedRef.current = (message.capped === true
+            || (typeof message.data === "string" && message.data.length >= 350000))
             && !deepReplayRoomsRef.current.has(activeSessionRoomRef.current || "");
           // Reset IN the stream (RIS) rather than as a separate call. A bare
           // reset() paints an empty terminal immediately, while the snapshot
@@ -1448,7 +1451,13 @@ const App = () => {
           deepRestoreRef.current = null;
           if (termRef.current) {
             const t = termRef.current;
-            t.write(`\x1bc${message.data}`, () => {
+            // Re-assert remote modes in-band after the snapshot: serialized
+            // snapshots carry the screen but not private modes, and xterm's
+            // own mode state gates scroll ownership and selection behavior
+            // (the refs above cover synthesized reports, not xterm itself).
+            const modeSeq = (message.mouseReporting ? "\x1b[?1002h" + (message.mouseSgr ? "\x1b[?1006h" : "") : "")
+              + (message.cursorHidden ? "\x1b[?25l" : "");
+            t.write(`\x1bc${message.data}${modeSeq}`, () => {
               if (pendingRestore) {
                 // The user was reading at the top of the OLD buffer; that
                 // content now sits newLen - oldLen lines down. Land there,