tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/tui/mirror/session-mirror.ts

@@ -5,14 +5,24 @@
  * {@link ControlModeClient} attaches to the session, `refresh-client -C`
  * pins the virtual client size to our render area (so tmux computes pane
  * layout for OUR grid), and every pane of the active window gets a
- * {@link PaneMirror} fed by routed `%output` bytes. Layout notifications
- * (`%layout-change`, `%window-pane-changed`, …) trigger a re-sync that
- * diffs geometry and creates/resizes/disposes mirrors incrementally.
+ * {@link PaneMirror} fed by routed `%output` bytes.
+ *
+ * GEOMETRY IS EVENT-DRIVEN (M23.5). `%layout-change` arrives sub-ms after the
+ * server applies a layout and ALWAYS precedes the first new-size `%output`
+ * (measured on 3.7b: as little as 0.2ms ahead) — so the notification PAYLOAD
+ * itself (the visible-layout string, parsed by layout-parse.ts) resizes the
+ * PaneMirrors SYNCHRONOUSLY in the same event-loop turn. The old 40ms-debounced
+ * `list-panes` hop let new-size redraws parse into stale-sized xterms, which
+ * corrupted redraw-once apps (vim/less/shells) PERMANENTLY. A slow list-panes
+ * `sync` remains as the attach seed, the reconciler behind uncertain events,
+ * the flag source, and the ONLY owner of mirror disposal. `%window-pane-changed`
+ * drives the active pane; one `refresh-client -B` subscription pushes per-pane
+ * `mouse_any_flag` (~1s cadence, `%subscription-changed`).
  *
  * tmux remains the multiplexer, PTY owner, and source of layout truth —
  * this class owns nothing but mirrors and routing. The pure helpers
- * ({@link parsePaneGeometry}, {@link diffPanes}) carry the logic and are
- * unit-tested without tmux.
+ * ({@link parsePaneGeometry}, {@link geometryFromLeaves}, layout-parse.ts)
+ * carry the logic and are unit-tested without tmux.
  */
 import { appendFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
@@ -25,7 +35,16 @@ import {
   type CursorState,
 } from "./pane-mirror.ts";
 import type { CellArrays } from "./blit.ts";
-import { tapInputOutput, tapRepin } from "./perf-tap.ts";
+import { tapInputOutput, tapRepin, tapResize } from "./perf-tap.ts";
+import {
+  parseLayout,
+  parseLayoutChange,
+  parseWindowPaneChanged,
+  parseSessionWindowChanged,
+  parseMouseSubscription,
+  type LayoutLeaf,
+} from "./layout-parse.ts";
+import { effectiveWindowSize, type Size } from "./size-truth.ts";
 
 /** One pane's geometry inside the window, in cells (tmux coordinates). */
 export interface PaneGeometry {
@@ -45,7 +64,8 @@ export interface PaneGeometry {
 
 /** PURE — parse `list-panes -F "#{pane_id} #{pane_left} …"` reply lines. The
  *  trailing `window_zoomed_flag` field is optional (absent lines parse as not
- *  zoomed) so older format strings and fixtures stay valid. */
+ *  zoomed) so older format strings and fixtures stay valid; any further
+ *  trailing fields (sync appends `window_id`) are ignored here. */
 export function parsePaneGeometry(lines: string[]): PaneGeometry[] {
   const panes: PaneGeometry[] = [];
   for (const line of lines) {
@@ -78,28 +98,33 @@ export function parsePaneGeometry(lines: string[]): PaneGeometry[] {
   return panes;
 }
 
-/** PURE — what changed between two layouts, keyed by pane id. */
-export function diffPanes(
-  prev: PaneGeometry[],
-  next: PaneGeometry[],
-): { added: PaneGeometry[]; removed: string[]; resized: PaneGeometry[]; moved: PaneGeometry[] } {
+/** PURE — visible geometry from parsed layout leaves (M23.5). A layout string
+ *  carries rects only, so the flags it can't encode merge in from elsewhere:
+ *  `active` from the tracked active pane (falling back to the previous
+ *  geometry's flag while it is still unknown), `appMouse` from the
+ *  subscription-fed map (then the previous flag, then false for a brand-new
+ *  pane), `zoomed` from the notification's flags field. */
+export function geometryFromLeaves(
+  leaves: readonly LayoutLeaf[],
+  prev: readonly PaneGeometry[],
+  activePane: string,
+  appMouse: ReadonlyMap<string, boolean>,
+  zoomed: boolean,
+): PaneGeometry[] {
   const prevById = new Map(prev.map((p) => [p.id, p]));
-  const nextIds = new Set(next.map((p) => p.id));
-  const added: PaneGeometry[] = [];
-  const resized: PaneGeometry[] = [];
-  const moved: PaneGeometry[] = [];
-  for (const pane of next) {
-    const was = prevById.get(pane.id);
-    if (!was) {
-      added.push(pane);
-    } else if (was.width !== pane.width || was.height !== pane.height) {
-      resized.push(pane);
-    } else if (was.left !== pane.left || was.top !== pane.top) {
-      moved.push(pane);
-    }
-  }
-  const removed = prev.filter((p) => !nextIds.has(p.id)).map((p) => p.id);
-  return { added, removed, resized, moved };
+  return leaves.map((l) => {
+    const was = prevById.get(l.id);
+    return {
+      id: l.id,
+      left: l.left,
+      top: l.top,
+      width: l.width,
+      height: l.height,
+      active: activePane ? l.id === activePane : (was?.active ?? false),
+      appMouse: appMouse.get(l.id) ?? was?.appMouse ?? false,
+      zoomed,
+    };
+  });
 }
 
 /** A live pane: geometry + its mirror snapshot. */
@@ -123,14 +148,14 @@ export interface SessionMirrorOptions {
   onExit?: () => void;
 }
 
-/** Control-mode notifications (sans `%`) that mean "the layout changed". */
+/** Control-mode notifications (sans `%`) that still fall back to the slow
+ *  re-sync — structure changed but the notification body doesn't carry enough
+ *  to apply it directly (layout-change / window-pane-changed /
+ *  session-window-changed have their own push handlers now). */
 const STRUCTURAL_NOTIFICATIONS = new Set([
-  "layout-change",
   "window-add",
   "window-close",
   "window-renamed",
-  "window-pane-changed",
-  "session-window-changed",
   "unlinked-window-close",
 ]);
 
@@ -140,6 +165,30 @@ export class SessionMirror {
   private geometry: PaneGeometry[] = [];
   private focused = "";
   private syncQueued = false;
+  // ── Push-geometry state (M23.5) ─────────────────────────────────────────
+  /** The mirrored session's active window id (`@N`) — gates which
+   *  `%layout-change` events apply. Learned by sync, updated by
+   *  `%session-window-changed`. Empty until the first sync lands. */
+  private activeWindow = "";
+  /** tmux's active pane (`%N`) — from `%window-pane-changed` and sync. */
+  private activePane = "";
+  /** The active window is zoomed (flags `*Z` / `window_zoomed_flag`). */
+  private zoomedNow = false;
+  /** Last APPLIED visible-layout string — dedupes notification bursts (every
+   *  payload of a burst carries the final layout; the checksum differs iff the
+   *  layout does). Reset on window switch so the new window's first layout
+   *  always applies. */
+  private lastVisibleLayout = "";
+  /** The window's authoritative size: the latest layout root's WxH
+   *  (event-driven), seeded/reconciled by sync's pane bounding box. */
+  private winSize: Size | null = null;
+  /** Per-pane `mouse_any_flag`, pushed by the control-mode subscription and
+   *  reconciled by sync — the fix for the latent missed-toggle (a pane
+   *  flipping mouse mode between two syncs was never re-read). */
+  private readonly appMouseByPane = new Map<string, boolean>();
+  /** Mirrors created (at correct size) whose CONTENT seed (capture-pane
+   *  history + screen + cursor) hasn't run yet — sync drains this. */
+  private readonly unseeded = new Set<string>();
   /** Size policy (M22.8). "auto" (default): we pin our virtual client size via
    *  `refresh-client -C` and let tmux's `window-size latest` cooperate — a
    *  co-attached terminal may win, which we surface honestly rather than fight.
@@ -168,10 +217,14 @@ export class SessionMirror {
       attachTarget: opts.target,
       onOutput: (pane, data) => {
         tapInputOutput(pane); // t1: first echo back for a key we just forwarded
-        this.mirrors.get(pane)?.write(data);
+        const mirror = this.mirrors.get(pane);
+        if (process.env.TMUX_IDE_ZZ_RESIZE_TAP && mirror) {
+          tapResize("output", `${pane} ${mirror.cols}x${mirror.rows} ${data.length}b`);
+        }
+        mirror?.write(data);
         opts.onDirty?.();
       },
-      onNotify: (name) => {
+      onNotify: (name, rest) => {
         if (process.env.TMUX_IDE_MIRROR_DEBUG) {
           try {
             appendFileSync("/tmp/zz-notify.log", name + "\n");
@@ -179,12 +232,15 @@ export class SessionMirror {
             // debug tap only
           }
         }
-        // Any structural notification re-syncs the layout; the debounce keeps
-        // bursts (e.g. a resize storm) to one list-panes round-trip. NOTE:
-        // parseControlLine strips the leading `%` from notification names.
-        if (STRUCTURAL_NOTIFICATIONS.has(name)) {
-          this.queueSync();
-        }
+        // NOTE: parseControlLine strips the leading `%` from notification
+        // names. Geometry-bearing notifications apply DIRECTLY from their
+        // payload (the M23.5 push path — see each handler); everything else
+        // structural falls back to the debounced re-sync.
+        if (name === "layout-change") this.onLayoutChange(rest);
+        else if (name === "window-pane-changed") this.onWindowPaneChanged(rest);
+        else if (name === "subscription-changed") this.onSubscriptionChanged(rest);
+        else if (name === "session-window-changed") this.onSessionWindowChanged(rest);
+        else if (STRUCTURAL_NOTIFICATIONS.has(name)) this.queueSync();
       },
       onExit: () => opts.onExit?.(),
     });
@@ -193,9 +249,156 @@ export class SessionMirror {
   async start(): Promise<void> {
     await this.client.start();
     await this.client.command(`refresh-client -C ${this.opts.cols}x${this.opts.rows}`);
+    // ONE control-mode subscription (M23.5): tmux re-evaluates the format on
+    // its ~1s tick and pushes `%subscription-changed` per pane on change — the
+    // push source for appMouse. The argument is DOUBLE-QUOTED on the control
+    // channel (the measured working form; see layout-parse.ts for the reply
+    // shape). Best-effort: an old tmux without -B just degrades to sync-only.
+    await this.client.command(`refresh-client -B "mouse:%*:#{mouse_any_flag}"`).catch(() => {});
     await this.sync();
   }
 
+  /** The mirrored window's authoritative size (layout root WxH), or null
+   *  before the first layout/sync — the app's event-driven size truth. */
+  windowSize(): Size | null {
+    return this.winSize;
+  }
+
+  // ── The push-geometry handlers (M23.5) ─────────────────────────────────
+
+  /**
+   * `%layout-change` → parse the VISIBLE layout and resize mirrors NOW —
+   * synchronously, in the same event-loop turn, BEFORE the control client
+   * feeds any subsequent `%output` line (resize-first is safe: bytes emitted
+   * for the OLD size clamp into the new grid, exactly as a native terminal
+   * treats a process writing across a resize; the app repaints on its own
+   * SIGWINCH an instant later).
+   *
+   * AckWriter interaction: {@link PaneMirror.write} is ack-PACED, so `%output`
+   * bytes that arrived BEFORE this notification may still sit unparsed in the
+   * writer's queue while `term.resize()` applies immediately — those old-size
+   * bytes then parse into the new grid and clamp, which is the same
+   * native-terminal behavior as above. The invariant that matters is that the
+   * resize is ordered by the CONTROL-CLIENT READ ORDER (never held for
+   * content): everything the server sent for the new size parses at the new
+   * size.
+   */
+  private onLayoutChange(rest: string): void {
+    const ev = parseLayoutChange(rest);
+    if (!ev) return;
+    tapResize("notify", `${ev.windowId} ${ev.visible}`);
+    // Before the first sync the active window is unknown — reconcile slowly.
+    if (!this.activeWindow) {
+      this.queueSync();
+      return;
+    }
+    if (ev.windowId !== this.activeWindow) return; // a background window
+    if (ev.visible === this.lastVisibleLayout) return; // burst dedupe
+    const parsed = parseLayout(ev.visible);
+    if (!parsed) {
+      this.queueSync(); // never guess from a failed parse
+      return;
+    }
+    this.lastVisibleLayout = ev.visible;
+    this.zoomedNow = ev.zoomed;
+    this.winSize = { cols: parsed.width, rows: parsed.height };
+    this.applyLayout(parsed.leaves, ev.zoomed);
+    tapResize(
+      "geometry-applied",
+      `${parsed.width}x${parsed.height} panes=${parsed.leaves.length}${ev.zoomed ? " Z" : ""}`,
+    );
+  }
+
+  /** Create/resize mirrors for the visible leaves and swap the geometry — all
+   *  synchronous. Mirror DISPOSAL stays with sync: a pane missing from the
+   *  visible layout is hidden under zoom (keep it warm — unzoom is instant and
+   *  scrollback survives), or genuinely closed (the queued sync checks against
+   *  list-panes truth and disposes there). */
+  private applyLayout(leaves: readonly LayoutLeaf[], zoomed: boolean): void {
+    let needSync = false;
+    for (const leaf of leaves) {
+      const mirror = this.mirrors.get(leaf.id);
+      if (!mirror) {
+        // A brand-new pane (split) in the layout: create the mirror at the
+        // right size NOW so its very first %output parses into correct
+        // geometry; the content seed rides the queued slow sync.
+        const created = new PaneMirror(leaf.width, leaf.height);
+        // Dirty must re-arm when bytes have PARSED, not just when they were
+        // enqueued (onOutput) — with ack-paced writes an enqueue-time dirty can
+        // be consumed by the tick before the grid changed, dropping the frame.
+        created.onParsed = () => this.opts.onDirty?.();
+        this.mirrors.set(leaf.id, created);
+        this.unseeded.add(leaf.id);
+        needSync = true;
+      } else if (mirror.cols !== leaf.width || mirror.rows !== leaf.height) {
+        mirror.resize(leaf.width, leaf.height);
+        tapResize("pane-resize", `${leaf.id} ${leaf.width}x${leaf.height}`);
+      }
+    }
+    if (!zoomed) {
+      const visible = new Set(leaves.map((l) => l.id));
+      for (const id of this.mirrors.keys()) {
+        if (!visible.has(id)) {
+          needSync = true; // a pane closed — let sync dispose against truth
+          break;
+        }
+      }
+    }
+    this.geometry = geometryFromLeaves(
+      leaves,
+      this.geometry,
+      this.activePane,
+      this.appMouseByPane,
+      zoomed,
+    );
+    this.opts.onDirty?.();
+    if (needSync) this.queueSync();
+  }
+
+  /** `%window-pane-changed` — tmux's active pane moved (fires immediately,
+   *  ahead of any sync). Track it and re-flag the geometry in place. */
+  private onWindowPaneChanged(rest: string): void {
+    const ev = parseWindowPaneChanged(rest);
+    if (!ev || (this.activeWindow && ev.windowId !== this.activeWindow)) return;
+    this.activePane = ev.paneId;
+    // Converge the LOCAL focus to tmux truth too: a select-pane we issued
+    // echoes back as this notification, and an external change (menu verb,
+    // another client) should move our focus the same way.
+    if (this.geometry.some((g) => g.id === ev.paneId)) this.focused = ev.paneId;
+    let changed = false;
+    this.geometry = this.geometry.map((g) => {
+      if (g.active === (g.id === ev.paneId)) return g;
+      changed = true;
+      return { ...g, active: g.id === ev.paneId };
+    });
+    if (changed) this.opts.onDirty?.();
+  }
+
+  /** `%subscription-changed` for the `mouse` subscription — a pane's app
+   *  turned mouse reporting on/off (~1s cadence; see {@link start}). */
+  private onSubscriptionChanged(rest: string): void {
+    const ev = parseMouseSubscription(rest);
+    if (!ev || this.appMouseByPane.get(ev.paneId) === ev.on) return;
+    this.appMouseByPane.set(ev.paneId, ev.on);
+    let changed = false;
+    this.geometry = this.geometry.map((g) => {
+      if (g.id !== ev.paneId || g.appMouse === ev.on) return g;
+      changed = true;
+      return { ...g, appMouse: ev.on };
+    });
+    if (changed) this.opts.onDirty?.();
+  }
+
+  /** `%session-window-changed` — the mirrored session switched windows: a new
+   *  pane set, so the slow path reseeds everything. */
+  private onSessionWindowChanged(rest: string): void {
+    const ev = parseSessionWindowChanged(rest);
+    if (!ev) return;
+    this.activeWindow = ev.windowId;
+    this.lastVisibleLayout = "";
+    this.queueSync();
+  }
+
   /**
    * The current panes with fresh grid snapshots, render-ready.
    *
@@ -245,6 +448,30 @@ export class SessionMirror {
     return this.mirrors.get(id)?.visibleRowTexts(scrollOffset) ?? [];
   }
 
+  /** A pane's LIVE scrollback depth (M25.6) — read at event time by the drag
+   *  machine, ahead of the 8ms tick's LivePane snapshot. 0 for an unknown pane. */
+  scrollbackDepth(id: string): number {
+    return this.mirrors.get(id)?.scrollbackDepth() ?? 0;
+  }
+
+  /** A pane's monotonic trimmed-lines counter (M25.6) — see
+   *  {@link PaneMirror.lineTrim}. 0 for an unknown pane. */
+  lineTrim(id: string): number {
+    return this.mirrors.get(id)?.lineTrim() ?? 0;
+  }
+
+  /** Extract an ORDERED absolute-line range from a pane's buffer (M25.6) — the
+   *  selection release path. Empty for an unknown pane. See
+   *  {@link PaneMirror.extractAbsoluteText}. */
+  extractText(
+    id: string,
+    start: { row: number; col: number },
+    end: { row: number; col: number },
+    maxBytes: number,
+  ): string {
+    return this.mirrors.get(id)?.extractAbsoluteText(start, end, maxBytes) ?? "";
+  }
+
   /** A pane's live cursor state (position + DECTCEM/DECSCUSR), for the hardware
    *  cursor (M21.6). Null for an unknown pane. */
   cursorState(id: string): CursorState | null {
@@ -328,6 +555,7 @@ export class SessionMirror {
     this.opts.cols = cols;
     this.opts.rows = rows;
     tapRepin(cols, rows); // debug tap: assert one re-pin per settled size change
+    tapResize("repin", `${cols}x${rows}`);
     await this.client.command(`refresh-client -C ${cols}x${rows}`).catch(() => {});
     // Under the manual policy `refresh-client -C` no longer drives the window
     // size, so a terminal/sidebar resize after a reclaim must resize the window
@@ -386,6 +614,10 @@ export class SessionMirror {
     this.mirrors.clear();
   }
 
+  /** Queue the SLOW path (M23.5: reconciler, flag source, seed driver, sole
+   *  mirror disposer — geometry itself is pushed by {@link onLayoutChange}).
+   *  The 40ms debounce coalesces notification bursts to one round-trip; it no
+   *  longer gates any resize. */
   private queueSync(): void {
     if (this.syncQueued) return;
     this.syncQueued = true;
@@ -397,47 +629,96 @@ export class SessionMirror {
 
   private async sync(): Promise<void> {
     const lines = await this.client.command(
-      `list-panes -t ${this.opts.target} -F "#{pane_id} #{pane_left} #{pane_top} #{pane_width} #{pane_height} #{pane_active} #{mouse_any_flag} #{window_zoomed_flag}"`,
+      `list-panes -t ${this.opts.target} -F "#{pane_id} #{pane_left} #{pane_top} #{pane_width} #{pane_height} #{pane_active} #{mouse_any_flag} #{window_zoomed_flag} #{window_id}"`,
     );
-    const next = parsePaneGeometry(lines);
-    const { added, removed, resized } = diffPanes(this.geometry, next);
+    // `list-panes` on a session target lists the CURRENT window — every pane
+    // of it, including the ones zoom hides. The trailing window id is the
+    // active-window gate for %layout-change (parsePaneGeometry ignores it).
+    const all = parsePaneGeometry(lines);
+    const win = lines[0]?.trim().split(/\s+/)[8];
+    if (win?.startsWith("@")) this.activeWindow = win;
 
-    for (const id of removed) {
-      this.mirrors.get(id)?.dispose();
+    // Everything from here to the geometry swap is SYNCHRONOUS. The reply
+    // reflects server state at least as new as any notification already
+    // processed (control mode serializes both on one channel), and nothing
+    // interleaves before the swap — so a sync can never clobber a NEWER
+    // pushed layout with stale rects.
+    const listed = new Set(all.map((p) => p.id));
+    for (const [id, mirror] of this.mirrors) {
+      if (listed.has(id)) continue;
+      mirror.dispose();
       this.mirrors.delete(id);
+      this.unseeded.delete(id);
+      this.appMouseByPane.delete(id);
       if (this.focused === id) this.focused = "";
     }
-    for (const pane of added) {
-      const mirror = new PaneMirror(pane.width, pane.height);
-      // Dirty must re-arm when bytes have PARSED, not just when they were
-      // enqueued (onOutput) — with ack-paced writes an enqueue-time dirty can
-      // be consumed by the tick before the grid changed, dropping the frame.
-      mirror.onParsed = () => this.opts.onDirty?.();
-      this.mirrors.set(pane.id, mirror);
-      // Seed with history + current screen (-e keeps colors, -S reaches back
-      // into tmux's scrollback, 2000 lines. The old 300 cap guarded a SYNC seed
-      // write that blocked the event loop; with ack-paced writes (M21.5) the
-      // write just enqueues (~0.01ms) and xterm parses async — 2000 lines parse
-      // in ~8ms off the render loop (measured), so the deeper history is free.
-      // -J joins wrapped lines so re-wrapping stays sane.
-      const seed = await this.client
+    for (const pane of all) {
+      const mirror = this.mirrors.get(pane.id);
+      if (!mirror) {
+        const created = new PaneMirror(pane.width, pane.height);
+        // Dirty must re-arm when bytes have PARSED, not just when they were
+        // enqueued (onOutput) — with ack-paced writes an enqueue-time dirty can
+        // be consumed by the tick before the grid changed, dropping the frame.
+        created.onParsed = () => this.opts.onDirty?.();
+        this.mirrors.set(pane.id, created);
+        this.unseeded.add(pane.id);
+      } else if (mirror.cols !== pane.width || mirror.rows !== pane.height) {
+        mirror.resize(pane.width, pane.height);
+        tapResize("pane-resize", `${pane.id} ${pane.width}x${pane.height} sync`);
+      }
+      this.appMouseByPane.set(pane.id, pane.appMouse);
+    }
+    this.zoomedNow = all.some((p) => p.zoomed);
+    const active = all.find((p) => p.active);
+    if (active) this.activePane = active.id;
+    // Visible geometry: under zoom list-panes still reports the HIDDEN panes
+    // at their unzoomed rects (measured on 3.7b: they overlap the zoomed pane
+    // and would steal first-match hit-tests — D3). Only the active (= zoomed)
+    // pane is visible, and its listed rect is the full window.
+    this.geometry = this.zoomedNow ? all.filter((p) => p.active) : all;
+    this.winSize = effectiveWindowSize(all) ?? this.winSize;
+    this.opts.onStatus?.(`${this.geometry.length} panes`);
+    this.opts.onDirty?.();
+
+    // CONTENT seeds last — the awaits below can span chunks, so nothing after
+    // this point touches geometry. Seed with history + current screen (-e
+    // keeps colors, -S reaches back into tmux's scrollback, 2000 lines. The
+    // old 300 cap guarded a SYNC seed write that blocked the event loop; with
+    // ack-paced writes (M21.5) the write just enqueues (~0.01ms) and xterm
+    // parses async — 2000 lines parse in ~8ms off the render loop (measured),
+    // so the deeper history is free. -J joins wrapped lines so re-wrapping
+    // stays sane.)
+    for (const pane of all) {
+      if (!this.unseeded.has(pane.id)) continue;
+      this.unseeded.delete(pane.id);
+      const mirror = this.mirrors.get(pane.id);
+      if (!mirror) continue;
+      const seedReply = this.client
         .command(`capture-pane -p -e -J -S -2000 -t ${pane.id}`)
-        .catch(() => []);
+        .catch(() => [] as string[]);
+      // The pane's REAL cursor (D2): the seed replay leaves xterm's cursor
+      // wherever the last captured byte fell — and the trailing CRLF the seed
+      // used to append scrolled one extra row on a full viewport, drifting
+      // the whole grid up. Dropped now; instead read tmux's cursor and CUP it
+      // home (CUP is viewport-relative — the same coordinates
+      // #{cursor_x}/#{cursor_y} report). Issued back-to-back with the capture
+      // so both ride one round-trip.
+      const cursorReply = this.client
+        .command(`display-message -p -t ${pane.id} "#{cursor_x} #{cursor_y}"`)
+        .catch(() => [] as string[]);
+      const seed = await seedReply;
       // The control client reads replies as latin1 (one JS char per byte —
       // required for the protocol), so the seed is a byte string in disguise:
       // re-encode latin1 → bytes before feeding the VT parser, or every
       // multibyte glyph shatters into mojibake (…→â¦, ⇡→â¡ — user-reported,
       // "weird a's with a roof"). The live %output path already decodes bytes.
       if (seed.length > 0) {
-        mirror.write(Buffer.from(seed.join("\r\n") + "\r\n", "latin1"));
+        mirror.write(Buffer.from(seed.join("\r\n"), "latin1"));
+      }
+      const [cx, cy] = ((await cursorReply)[0] ?? "").trim().split(/\s+/).map(Number);
+      if (Number.isInteger(cx) && Number.isInteger(cy)) {
+        mirror.write(`\x1b[${cy! + 1};${cx! + 1}H`);
       }
     }
-    for (const pane of resized) {
-      this.mirrors.get(pane.id)?.resize(pane.width, pane.height);
-    }
-
-    this.geometry = next;
-    this.opts.onStatus?.(`${next.length} panes`);
-    this.opts.onDirty?.();
   }
 }