tmux-ide 2.7.0 → 2.8.0

package/packages/daemon/src/tui/mirror/perf-tap.ts

@@ -103,9 +103,10 @@ export function tapInputTick(): void {
 // ── size re-pin tap (M22.8) ─────────────────────────────────────────────────
 // Every canvas-area change (terminal resize, sidebar drag) funnels through the
 // mirror's `resize()` — the ONE re-pin chokepoint. This tap records each re-pin
-// so a live drag/resize burst can be asserted to collapse to the expected count
-// (the 200ms size poll coalesces a burst to one re-pin per settled size). Gated
-// behind TMUX_IDE_ZZ_PERF, appending `cols rows` lines to /tmp/zz-repin.log.
+// so a live drag/resize burst can be asserted against the expected count (since
+// M23.5 the renderer dims signal re-pins per actual size change — no more 200ms
+// poll). Gated behind TMUX_IDE_ZZ_PERF, appending `cols rows` lines to
+// /tmp/zz-repin.log.
 
 const REPIN_LOG = "/tmp/zz-repin.log";
 
@@ -119,6 +120,31 @@ export function tapRepin(cols: number, rows: number): void {
   }
 }
 
+// ── resize tap (M23.5) ──────────────────────────────────────────────────────
+// The event-driven geometry pipeline's flight recorder: one timestamped line
+// per hop — %layout-change received (`notify`), geometry applied into the
+// mirrors (`geometry-applied`), a canvas re-pin (`repin`), a per-pane term
+// resize (`pane-resize`), and per-%output mirror dims (`output`) — so a resize
+// battery can assert "geometry applied <5ms after the notify" and "no %output
+// parsed into stale dims" straight from the log. Own env gate
+// (TMUX_IDE_ZZ_RESIZE_TAP): the per-output line is too chatty for the general
+// TMUX_IDE_ZZ_PERF sessions.
+
+const RESIZE_LOG = "/tmp/zz-resize-tap.log";
+
+/** Append one `<t> <event> <detail>` line. No-op unless TMUX_IDE_ZZ_RESIZE_TAP. */
+export function tapResize(event: string, detail = ""): void {
+  if (!process.env.TMUX_IDE_ZZ_RESIZE_TAP) return;
+  try {
+    appendFileSync(
+      RESIZE_LOG,
+      `${performance.now().toFixed(2)} ${event}${detail ? ` ${detail}` : ""}\n`,
+    );
+  } catch {
+    /* perf tap only */
+  }
+}
+
 // ── pure reporting helpers (used by scripts/perf-mirror.mjs) ────────────────
 
 /** A percentile of an ASCENDING-sorted array, linearly interpolated. Empty → 0. */

package/packages/daemon/src/tui/mirror/selection.ts

@@ -11,15 +11,21 @@
  * cell is selected if it falls between the anchor and head in row-major order.
  */
 
-/** A cell in surface-local coordinates: mirror = snapshot row + pane column;
- *  editor = buffer line + buffer column. */
+/** A cell in surface-local coordinates. Mirror (M25.6): ABSOLUTE xterm buffer
+ *  line (0 = oldest scrollback line) + pane column — anchored to CONTENT, so
+ *  the selection survives scrolling mid-drag and can span many screens. Editor:
+ *  buffer line + buffer column (already absolute by nature). A visible pane row
+ *  `r` at scroll offset `off` maps to absolute line `baseY + r` where
+ *  `baseY = scrollbackDepth − off` (the search path's existing arithmetic —
+ *  see PaneMirror.bufferLines). */
 export interface Cell {
   row: number;
   col: number;
 }
 
 /** An active selection on one surface. `anchor` is where the drag began, `head`
- *  the current/last pointer cell; either may precede the other. */
+ *  the current/last pointer cell; either may precede the other. Mirror cells
+ *  are in ABSOLUTE buffer coordinates (see {@link Cell}). */
 export type Selection =
   | { surface: "mirror"; paneId: string; anchor: Cell; head: Cell }
   | { surface: "editor"; anchor: Cell; head: Cell };
@@ -78,6 +84,68 @@ export function extractSelection(
   return out.join("\n");
 }
 
+// ── Absolute-space mapping (M25.6) ──────────────────────────────────────────
+// The selection model is anchored to ABSOLUTE buffer lines; the render works in
+// visible pane rows. These mappers are the one bridge: given the pane's current
+// baseY (scrollbackDepth − scrollOffset) and height, an absolute range resolves
+// to the visible rows it covers and the per-row column spans to highlight.
+
+/** A highlighted span on one VISIBLE pane row (row is viewport-relative). */
+export interface VisibleSpan {
+  row: number;
+  from: number;
+  to: number;
+}
+
+/** Visible pane rows [0,height) covered by an ORDERED absolute range at the
+ *  current view (`baseY` = scrollbackDepth − scrollOffset). Empty when the
+ *  whole range is scrolled off either edge. */
+export function visibleSelRows(start: Cell, end: Cell, baseY: number, height: number): number[] {
+  const lo = Math.max(0, start.row - baseY);
+  const hi = Math.min(height - 1, end.row - baseY);
+  const out: number[] = [];
+  for (let r = lo; r <= hi; r++) out.push(r);
+  return out;
+}
+
+/**
+ * Map an ORDERED absolute range to the visible per-row column spans at the
+ * current view. `rowLen(viewRow)` supplies each visible row's selectable cell
+ * count (grid width for the framebuffer swap; the row's char count for run
+ * tinting — wide glyphs collapse to one char there, so the two callers pass
+ * different lengths and each gets spans clamped to ITS space). Rows whose
+ * span is empty (zero-length row, or a first/last-row column interval that
+ * falls outside it) are omitted.
+ */
+export function visibleSelectionSpans(
+  start: Cell,
+  end: Cell,
+  baseY: number,
+  height: number,
+  rowLen: (viewRow: number) => number,
+): VisibleSpan[] {
+  const out: VisibleSpan[] = [];
+  for (const r of visibleSelRows(start, end, baseY, height)) {
+    const range = rowSelectionRange(baseY + r, rowLen(r), start, end);
+    if (range) out.push({ row: r, from: range.from, to: range.to });
+  }
+  return out;
+}
+
+/**
+ * Re-anchor an absolute cell after the buffer trimmed `trimDelta` lines off its
+ * top (the scrollback cap rotating mid-drag): every retained line's index
+ * dropped by the trim, so the cell follows its content down. A cell whose line
+ * was trimmed away clamps to the oldest retained line (row 0), col 0 — the
+ * selection top pins to the oldest text still in the buffer.
+ */
+export function trimAdjustCell(cell: Cell, trimDelta: number): Cell {
+  if (trimDelta <= 0) return cell;
+  const row = cell.row - trimDelta;
+  if (row < 0) return { row: 0, col: 0 };
+  return { row, col: cell.col };
+}
+
 /**
  * The inclusive [from,to] char interval of the word at `col` in `text`,
  * splitting on /\W/ (word chars are [A-Za-z0-9_]). A click on a non-word char
@@ -198,14 +266,60 @@ export function tintRunsBg<T extends { text: string; bg: number | null }>(
 // through (SGR encodes it as +4 on the button code; many terminals keep
 // shift+drag for native selection instead — then only select mode applies).
 
-/** PURE — whether a left press on a pane begins a LOCAL drag selection
- *  (vs. being forwarded to the pane's app as an SGR press). */
-export function pressStartsSelection(
+// ── Implicit drag-select default (M24.2) ─────────────────────────────────────
+// Every agent pane (claude/codex) is app-mouse, so "forwarding wins" meant a
+// user's whole fleet couldn't drag-select. The DEFAULT now follows the pane:
+// where our own detection says an agent runs there, a plain drag selects and
+// only a genuine click (press+release in one cell) is forwarded — deferred
+// until motion or release decides. Shift INVERTS the pane's default (so on an
+// agent pane shift+drag forwards; on a vim pane it selects, as in M22.9), the
+// right-click toggle overrides per pane for the session, and `app.dragSelect`
+// ("agents"|"always"|"never") sets the policy.
+
+/** Where a plain left drag on a pane goes by default. */
+export type PaneDragDefault = "select" | "forward";
+/** The `app.dragSelect` policy values (app-config). */
+export type DragSelectSetting = "agents" | "always" | "never";
+
+/** PURE — a pane's drag default. Precedence: the session's per-pane override
+ *  (the right-click toggle) > the config policy ("always"/"never") > the agent
+ *  join ("agents": a pane matching a fleet agent entry selects; every other
+ *  app-mouse pane forwards). */
+export function paneDragDefault(
+  agentEntry: { paneId: string } | undefined,
+  config: DragSelectSetting,
+  override: PaneDragDefault | null,
+): PaneDragDefault {
+  if (override !== null) return override;
+  if (config === "always") return "select";
+  if (config === "never") return "forward";
+  return agentEntry !== undefined ? "select" : "forward";
+}
+
+/** What a left press on a pane does: run the selection machine NOW, forward
+ *  the SGR press NOW, or DEFER (withhold the press until motion starts a
+ *  selection or a release-in-place forwards the owed click pair). */
+export type PressRouting = "select" | "forward" | "defer";
+
+/** PURE — route a left press. Plain panes and select mode keep the immediate
+ *  selection machine. Otherwise the pane's drag default decides, with shift
+ *  inverting it: a shift press that lands on "select" stays IMMEDIATE (the
+ *  M22.9 behavior — a shift-click was never forwarded), while an unshifted
+ *  "select" defers so the pane's app still gets genuine clicks. */
+export function routePanePress(
   appMouse: boolean,
   selectModeOn: boolean,
   shift: boolean,
-): boolean {
-  return !appMouse || selectModeOn || shift;
+  dragDefault: PaneDragDefault,
+): PressRouting {
+  if (!appMouse || selectModeOn) return "select";
+  const effective: PaneDragDefault = shift
+    ? dragDefault === "select"
+      ? "forward"
+      : "select"
+    : dragDefault;
+  if (effective === "forward") return "forward";
+  return shift ? "select" : "defer";
 }
 
 /** PURE — whether the wheel scrolls the LOCAL mirror scrollback (vs. being