tmux-ide 2.9.0-beta.9 → 2.9.3

package/packages/daemon/src/terminal/attachments/pty-tmux-attachment-launcher.ts

@@ -1,3 +1,4 @@
+import { withBundledTmuxResources } from "../../lib/bundled-tmux.ts";
 import { accessSync, constants, realpathSync, statSync } from "node:fs";
 import { delimiter, isAbsolute, join } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -285,7 +286,10 @@ export class PtyTmuxAttachmentLauncher implements TmuxAttachmentClientTransport
       throw new TypeError("trusted cwd must be an absolute daemon-owned path");
     }
     this.#trustedCwd = options.trustedCwd;
-    this.#environment = terminalEnvironment(options.environment ?? process.env);
+    this.#environment = withBundledTmuxResources(
+      this.#tmuxExecutable,
+      terminalEnvironment(options.environment ?? process.env),
+    );
     if (options.proofRunner && options.proofCommandExecutor) {
       throw new TypeError("proof runner and proof command executor are mutually exclusive");
     }

package/packages/daemon/src/terminal/mirror/control-channel.ts

@@ -1,3 +1,4 @@
+import { withBundledTmuxResources } from "../../lib/bundled-tmux.ts";
 /**
  * The MirrorService's tmux control-mode channel (m43 card 1).
  *
@@ -20,13 +21,73 @@
  * chance to detach us — killing the reader first can wedge the server.
  */
 import { spawn, type ChildProcess } from "node:child_process";
+import { shellEscape } from "../../lib/shell.ts";
+import type { NativeTmuxServerIdentity } from "../../lib/tmux-server-generation-runner.ts";
+import {
+  NativeJournalIdentitySchemaZ,
+  type NativeJournalIdentity,
+  type NativeOperationIdentity,
+} from "@tmux-ide/contracts";
+import { nativeOperationWrapperArgs } from "../../lib/native-operation-command.ts";
+import { decodeNativeOperationReply } from "../../lib/native-operation-reply.ts";
 import { parseControlLine } from "../protocol/control.ts";
 
+const NATIVE_VIEWER_PRIMITIVES = new Set([
+  "send-keys",
+  "capture-pane",
+  "paste-buffer",
+  "send-prefix",
+  "set-option",
+  "display-message",
+]);
+
 export interface ControlReply {
   ok: boolean;
   lines: string[];
 }
 
+/** Optional proof transport; terminal results and attribution validity are separate. */
+export interface NativeViewerControlReply extends ControlReply {
+  readonly metadataStatus: "valid" | "invalid" | "unavailable";
+  readonly acknowledgement: NativeOperationIdentity | null;
+}
+export interface NativeViewerControlRequest {
+  readonly operationId: string;
+  readonly paneId: string;
+  readonly paneBirthId: string;
+  readonly commands: readonly (readonly string[])[];
+  readonly resultIndex: number;
+  readonly limits: ControlReplyLimits;
+  readonly onAcknowledgement?: (acknowledgement: NativeOperationIdentity) => void;
+}
+export interface NativeViewerControlOptions {
+  /** Supplied only after the owner proved strict transport AND pane guard capability. */
+  readonly serverEpoch: string;
+  readonly onIdentity: (identity: NativeJournalIdentity) => boolean;
+  readonly onRetired: () => void;
+}
+interface NativeWrapperReplyState {
+  readonly expected: NativeJournalIdentity & { readonly operationId: string };
+  readonly resultIndex: number;
+  readonly onReply: (reply: NativeViewerControlReply) => void;
+  readonly onAcknowledgement?: (acknowledgement: NativeOperationIdentity) => void;
+  acknowledgement: NativeOperationIdentity | null;
+  metadataStatus: NativeViewerControlReply["metadataStatus"];
+  settled: boolean;
+}
+
+/** Consumer exceptions cannot interrupt parsing or settlement of other FIFO requests. */
+function notifyNativeWrapper(
+  state: NativeWrapperReplyState,
+  reply: NativeViewerControlReply,
+): void {
+  try {
+    state.onReply(reply);
+  } catch {
+    // The request is already settled; keep draining the transport without replaying it.
+  }
+}
+
 export interface ControlReplyLimits {
   readonly maxBytes: number;
   readonly maxLines: number;
@@ -129,6 +190,11 @@ export interface MirrorChannelIo {
   /** Outstanding control replies before a new command is written. */
   readonly pendingCount?: number;
   start(): Promise<void>;
+  readonly nativeViewerIdentity?: NativeJournalIdentity | null;
+  commandNativeViewerInline?(
+    request: NativeViewerControlRequest,
+    onReply: (reply: NativeViewerControlReply) => void,
+  ): boolean;
   /** Reply-matched command; resolution order follows the wire FIFO but the
    *  continuation is a microtask — use ONLY where output ordering is moot
    *  (identity join, stamping, window listing). */
@@ -167,6 +233,7 @@ export interface MirrorChannelIo {
 }
 
 type ReplySink =
+  | { kind: "native-wrapper"; state: NativeWrapperReplyState; index: number; budget: ReplyBudget }
   | {
       kind: "bounded";
       limits: ControlReplyLimits;
@@ -188,6 +255,8 @@ type ReplySink =
         readonly resultIndex: number;
         readonly onReply: (reply: ControlReply) => void;
         readonly lines: string[];
+        readonly leadingErrorLines: string[];
+        leadingErrorBytes: number;
         settled: boolean;
         budget?: ReplyBudget;
       };
@@ -271,7 +340,15 @@ export class ControlChannelCore {
     onReply: (reply: ControlReply) => void,
     budget?: ReplyBudget,
   ): void {
-    const state = { resultIndex, onReply, lines: budget?.lines ?? [], settled: false, budget };
+    const state = {
+      resultIndex,
+      onReply,
+      lines: budget?.lines ?? [],
+      leadingErrorLines: [] as string[],
+      leadingErrorBytes: 0,
+      settled: false,
+      budget,
+    };
     for (let index = 0; index < replyCount; index += 1)
       this.pending.push({ kind: "command-list", state, index });
   }
@@ -297,9 +374,54 @@ export class ControlChannelCore {
     return true;
   }
 
+  /** Reserve wrapper acknowledgement plus fixed synchronous child replies as one group. */
+  pushNativeWrapper(
+    expected: NativeJournalIdentity & { readonly operationId: string },
+    request: NativeViewerControlRequest,
+    onReply: (reply: NativeViewerControlReply) => void,
+  ): boolean {
+    if (
+      this.failed ||
+      !Number.isSafeInteger(request.resultIndex) ||
+      request.resultIndex < 0 ||
+      request.resultIndex >= request.commands.length ||
+      request.commands.length > 64 ||
+      !Number.isSafeInteger(request.limits.maxBytes) ||
+      request.limits.maxBytes < 1 ||
+      request.limits.maxBytes > ATOMIC_CAPTURE_BYTE_HARD_CAP ||
+      !Number.isSafeInteger(request.limits.maxLines) ||
+      request.limits.maxLines < 1 ||
+      request.limits.maxLines > ATOMIC_CAPTURE_LINE_HARD_CAP
+    )
+      return false;
+    const state: NativeWrapperReplyState = {
+      expected: { ...expected },
+      resultIndex: request.resultIndex + 1,
+      onReply,
+      onAcknowledgement: request.onAcknowledgement,
+      acknowledgement: null,
+      metadataStatus: "unavailable",
+      settled: false,
+    };
+    for (let index = 0; index <= request.commands.length; index++) {
+      const limits =
+        index === state.resultIndex
+          ? { ...request.limits }
+          : { maxBytes: 1024, maxLines: index === 0 ? 1 : 8 };
+      this.pending.push({
+        kind: "native-wrapper",
+        state,
+        index,
+        budget: { limits, bytes: 0, overflowed: false, lines: [] },
+      });
+    }
+    return true;
+  }
+
   private currentBudget(): ReplyBudget | undefined {
     const head = this.currentReplyConsumesPending ? this.pending[0] : undefined;
     if (head?.kind === "bounded") return head;
+    if (head?.kind === "native-wrapper") return head.budget;
     if (head?.kind === "command-list" && head.index <= head.state.resultIndex)
       return head.state.budget;
     return undefined;
@@ -419,7 +541,15 @@ export class ControlChannelCore {
       if (sink.kind === "promise") sink.reject(new Error(reason));
       else if (sink.kind === "inline" || sink.kind === "bounded")
         sink.onReply({ ok: false, lines: [reason] });
-      else if (sink.kind === "command-list" && !sink.state.settled) {
+      else if (sink.kind === "native-wrapper" && !sink.state.settled) {
+        sink.state.settled = true;
+        notifyNativeWrapper(sink.state, {
+          ok: false,
+          lines: [],
+          metadataStatus: sink.state.metadataStatus,
+          acknowledgement: sink.state.acknowledgement,
+        });
+      } else if (sink.kind === "command-list" && !sink.state.settled) {
         sink.state.settled = true;
         sink.state.onReply({ ok: false, lines: [reason] });
       }
@@ -458,8 +588,19 @@ export class ControlChannelCore {
             } else budget.lines.push(event.line);
           }
         } else if (head?.kind === "promise" || head?.kind === "inline") head.lines.push(event.line);
-        else if (head?.kind === "command-list" && head.index === head.state.resultIndex)
-          head.state.lines.push(event.line);
+        else if (head?.kind === "command-list") {
+          if (head.index === head.state.resultIndex) head.state.lines.push(event.line);
+          else if (head.index === 0 && head.state.leadingErrorBytes <= 4096) {
+            // A whole command-list parse error occupies only the first slot,
+            // even when the selected result is later. Keep bounded diagnostics
+            // until its terminator proves whether it was an error.
+            head.state.leadingErrorBytes += event.line.length + 1;
+            if (head.state.leadingErrorBytes > 4096 || head.state.leadingErrorLines.length >= 8) {
+              head.state.leadingErrorBytes = 4097;
+              head.state.leadingErrorLines.length = 0;
+            } else head.state.leadingErrorLines.push(event.line);
+          }
+        }
         break;
       }
       case "end":
@@ -475,7 +616,44 @@ export class ControlChannelCore {
         this.awaitingGreeting = false;
         const sink = this.pending.shift();
         if (!sink) break; // unsolicited block (greeting after a race)
+        if (sink.kind === "native-wrapper") {
+          const state = sink.state;
+          if (sink.index === 0 && event.kind === "end") {
+            try {
+              if (sink.budget.overflowed || sink.budget.lines.length !== 1)
+                throw new Error("Invalid acknowledgement bound");
+              const { acknowledgement } = decodeNativeOperationReply(
+                sink.budget.lines[0]! + "\n",
+                state.expected,
+              );
+              if (acknowledgement.connectionId !== state.expected.connectionId)
+                throw new Error("Foreign connection acknowledgement");
+              state.onAcknowledgement?.(acknowledgement);
+              state.acknowledgement = acknowledgement;
+              state.metadataStatus = "valid";
+            } catch {
+              state.metadataStatus = "invalid";
+            }
+          }
+          if (event.kind === "error") {
+            // tmux aborts the remaining children in this parsed command group.
+            // Drop only this group's sinks; subsequent queued writes retain theirs.
+            while (this.pending[0]?.kind === "native-wrapper" && this.pending[0].state === state)
+              this.pending.shift();
+          }
+          if (!state.settled && (event.kind === "error" || sink.index === state.resultIndex)) {
+            state.settled = true;
+            notifyNativeWrapper(state, {
+              ok: event.kind === "end" && !sink.budget.overflowed,
+              lines: sink.index === 0 ? [] : sink.budget.lines,
+              metadataStatus: state.metadataStatus,
+              acknowledgement: state.acknowledgement,
+            });
+          }
+          break;
+        }
         if (sink.kind === "command-list") {
+          if (event.kind === "end") sink.state.leadingErrorLines.length = 0;
           if (event.kind === "end" && sink.index < sink.state.resultIndex && sink.state.budget) {
             sink.state.lines.length = 0;
             sink.state.budget.bytes = 0;
@@ -487,7 +665,13 @@ export class ControlChannelCore {
               this.pending.shift();
             if (!sink.state.settled) {
               sink.state.settled = true;
-              sink.state.onReply({ ok: false, lines: sink.state.lines });
+              sink.state.onReply({
+                ok: false,
+                lines:
+                  sink.state.budget || sink.state.resultIndex === 0
+                    ? sink.state.lines
+                    : sink.state.leadingErrorLines,
+              });
             }
           } else if (sink.index === sink.state.resultIndex && !sink.state.settled) {
             sink.state.settled = true;
@@ -722,8 +906,14 @@ export class ControlChannelCore {
 }
 
 export interface MirrorControlChannelOptions {
+  nativeViewer?: NativeViewerControlOptions;
+  nativeViewerReady?: {
+    get(): NativeViewerControlOptions | undefined;
+    subscribe(listener: () => void): () => void;
+  };
   /** Resolve through the owning daemon's generation fence before each spawn. */
   resolveSocketPath?: () => string;
+  nativeServerIdentity?: NativeTmuxServerIdentity;
   session: string;
   handlers: MirrorChannelHandlers;
   /** `tmux -L <name>` — isolated servers in tests; omit for the default. */
@@ -744,10 +934,23 @@ export interface MirrorControlChannelOptions {
 export function mirrorControlAttachArgs(
   options: Pick<
     MirrorControlChannelOptions,
-    "session" | "socketName" | "socketPath" | "configFile"
+    "session" | "socketName" | "socketPath" | "configFile" | "nativeServerIdentity"
   >,
   pauseAfterSeconds = DEFAULT_PAUSE_AFTER_SECONDS,
 ): string[] {
+  const attach = [
+    "attach",
+    "-t",
+    options.session,
+    "-f",
+    `ignore-size,pause-after=${pauseAfterSeconds},active-pane`,
+  ];
+  const expected = options.nativeServerIdentity;
+  if (
+    expected &&
+    (!/^[1-9][0-9]*$/u.test(expected.pid) || !/^[1-9][0-9]*$/u.test(expected.startTime))
+  )
+    throw new Error("Invalid expected native server identity");
   return [
     ...(options.socketPath
       ? ["-S", options.socketPath]
@@ -756,11 +959,15 @@ export function mirrorControlAttachArgs(
         : []),
     ...(options.configFile ? ["-f", options.configFile] : []),
     "-C",
-    "attach",
-    "-t",
-    options.session,
-    "-f",
-    `ignore-size,pause-after=${pauseAfterSeconds},active-pane`,
+    ...(expected
+      ? [
+          "if-shell",
+          "-F",
+          `#{&&:#{==:#{pid},${expected.pid}},#{==:#{start_time},${expected.startTime}}}`,
+          attach.map(shellEscape).join(" "),
+          "display-message -p 'tmux-server-generation-refused'",
+        ]
+      : attach),
   ];
 }
 
@@ -773,6 +980,11 @@ export class MirrorControlChannel implements MirrorChannelIo {
   private readonly core: ControlChannelCore;
   private readonly opts: MirrorControlChannelOptions;
   private exited = false;
+  private viewerIdentity: NativeJournalIdentity | null = null;
+  private viewerRetired = false;
+  private viewerPending = 0;
+  private verifiedAttach = false;
+  private guardedStart: { resolve: () => void; reject: (error: Error) => void } | null = null;
   private atomicCollectorTimer: ReturnType<typeof setTimeout> | null = null;
 
   constructor(opts: MirrorControlChannelOptions) {
@@ -780,6 +992,16 @@ export class MirrorControlChannel implements MirrorChannelIo {
     this.core = new ControlChannelCore(
       {
         ...opts.handlers,
+        onOutput: (...args) => {
+          if (!opts.nativeServerIdentity || this.verifiedAttach) opts.handlers.onOutput(...args);
+        },
+        onNotify: (name, rest) => {
+          if (opts.nativeServerIdentity && name === "session-changed") {
+            this.verifiedAttach = true;
+            this.guardedStart?.resolve();
+          }
+          if (!opts.nativeServerIdentity || this.verifiedAttach) opts.handlers.onNotify(name, rest);
+        },
         onExit: (reason) => this.noteExit(reason),
       },
       opts.nowMicros,
@@ -787,6 +1009,8 @@ export class MirrorControlChannel implements MirrorChannelIo {
   }
 
   start(): Promise<void> {
+    if (this.proc || this.exited)
+      return Promise.reject(new Error("Control channel cannot restart"));
     const pauseAfter = this.opts.pauseAfterSeconds ?? DEFAULT_PAUSE_AFTER_SECONDS;
     let args: string[];
     try {
@@ -802,7 +1026,7 @@ export class MirrorControlChannel implements MirrorChannelIo {
     }
     const proc = spawn(this.opts.executable ?? "tmux", args, {
       stdio: ["pipe", "pipe", "pipe"],
-      env: { ...process.env, TMUX: "" },
+      env: withBundledTmuxResources(this.opts.executable, { ...process.env, TMUX: "" }),
     });
     this.proc = proc;
     // A control client whose session is killed exits while we may still be
@@ -822,14 +1046,192 @@ export class MirrorControlChannel implements MirrorChannelIo {
     });
     // tmux opens with an unsolicited %begin/%end greeting block; a queued
     // resolver makes start() settle when the protocol is actually live.
-    return new Promise((resolve, reject) => {
-      this.core.push({ kind: "promise", resolve: () => resolve(), reject, lines: [] });
+    return new Promise<void>((resolve, reject) => {
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const settle = (error?: Error) => {
+        if (timer) clearTimeout(timer);
+        this.guardedStart = null;
+        if (error) reject(error);
+        else resolve();
+      };
+      if (this.opts.nativeServerIdentity) {
+        this.guardedStart = { resolve: () => settle(), reject: (error) => settle(error) };
+        timer = setTimeout(() => {
+          settle(new Error("Tmux generation-guarded attach timed out"));
+          void this.dispose();
+        }, 5_000);
+        timer.unref?.();
+      }
+      // The outer if-shell greeting precedes its attach branch. Only native
+      // session-changed proves that the guarded attach actually succeeded.
+      this.core.push({
+        kind: "promise",
+        resolve: () => {
+          if (!this.opts.nativeServerIdentity) settle();
+        },
+        reject: (error) => settle(error),
+        lines: [],
+      });
       proc.on("error", (err) => {
         this.core.fail(String(err));
         reject(err);
       });
+    }).then(() => this.initializeNativeViewer());
+  }
+
+  get nativeViewerIdentity(): NativeJournalIdentity | null {
+    return this.viewerIdentity ? { ...this.viewerIdentity } : null;
+  }
+  private viewerReadyUnsubscribe: (() => void) | null = null;
+  private viewerHandshakeStarted = false;
+  private viewerReadySubscribing = false;
+  private viewerConfig: NativeViewerControlOptions | undefined;
+  private unsubscribeNativeViewerReady(): void {
+    const unsubscribe = this.viewerReadyUnsubscribe;
+    this.viewerReadyUnsubscribe = null;
+    try {
+      unsubscribe?.();
+    } catch {
+      /* optional metadata only */
+    }
+  }
+  private retireNativeViewer(): void {
+    this.unsubscribeNativeViewerReady();
+    this.viewerIdentity = null;
+    if (this.viewerRetired) return;
+    this.viewerRetired = true;
+    try {
+      (this.viewerConfig ?? this.opts.nativeViewer)?.onRetired();
+    } catch {
+      /* optional metadata only */
+    }
+  }
+  private initializeNativeViewer(): Promise<void> {
+    if (this.exited || this.viewerRetired || this.viewerHandshakeStarted) return Promise.resolve();
+    let config: NativeViewerControlOptions | undefined;
+    try {
+      config = this.opts.nativeViewer ?? this.opts.nativeViewerReady?.get();
+    } catch {
+      this.retireNativeViewer();
+      return Promise.resolve();
+    }
+    if (!config) {
+      if (
+        !this.viewerReadyUnsubscribe &&
+        !this.viewerReadySubscribing &&
+        this.opts.nativeViewerReady
+      ) {
+        this.viewerReadySubscribing = true;
+        try {
+          const unsubscribe = this.opts.nativeViewerReady.subscribe(() => {
+            void this.initializeNativeViewer();
+          });
+          this.viewerReadyUnsubscribe = unsubscribe;
+          // A provider may synchronously notify or retire during subscription.
+          if (this.viewerHandshakeStarted || this.viewerRetired || this.exited)
+            this.unsubscribeNativeViewerReady();
+        } catch {
+          this.retireNativeViewer();
+        } finally {
+          this.viewerReadySubscribing = false;
+        }
+      }
+      return Promise.resolve();
+    }
+    this.viewerHandshakeStarted = true;
+    this.viewerConfig = config;
+    this.unsubscribeNativeViewerReady();
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (identity: NativeJournalIdentity | null) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        try {
+          if (
+            !identity ||
+            this.exited ||
+            this.viewerRetired ||
+            !config.onIdentity({ ...identity }) ||
+            this.exited ||
+            this.viewerRetired
+          )
+            this.retireNativeViewer();
+          else this.viewerIdentity = identity;
+        } catch {
+          this.retireNativeViewer();
+        }
+        resolve();
+      };
+      const timer = setTimeout(() => finish(null), 1000);
+      timer.unref?.();
+      this.commandBoundedInline("tmux-ide-events -i", { maxBytes: 1024, maxLines: 1 }, (reply) => {
+        try {
+          if (!reply.ok || reply.lines.length !== 1) return finish(null);
+          const identity = NativeJournalIdentitySchemaZ.parse(JSON.parse(reply.lines[0]!));
+          finish(identity.serverEpoch === config.serverEpoch ? identity : null);
+        } catch {
+          finish(null);
+        }
+      });
     });
   }
+  /** false means no write occurred. Once accepted, never fall back or replay on failure. */
+  commandNativeViewerInline(
+    request: NativeViewerControlRequest,
+    onReply: (reply: NativeViewerControlReply) => void,
+  ): boolean {
+    const identity = this.viewerIdentity,
+      proc = this.proc;
+    if (
+      !identity ||
+      this.viewerRetired ||
+      !proc?.stdin?.writable ||
+      this.viewerPending >= 64 ||
+      this.core.pendingCount + request.commands.length + 1 > 4096
+    )
+      return false;
+    let command: string;
+    try {
+      if (
+        request.commands.some(
+          (argv) =>
+            !NATIVE_VIEWER_PRIMITIVES.has(argv[0]!) ||
+            (argv[0] === "display-message" && argv.slice(1).some((arg) => /^-[^-]*I/.test(arg))),
+        )
+      )
+        return false;
+      command = nativeOperationWrapperArgs(
+        request.operationId,
+        request.commands,
+        identity.serverEpoch,
+        { paneId: request.paneId, paneBirthId: request.paneBirthId },
+      )
+        .map(shellEscape)
+        .join(" ");
+    } catch {
+      return false;
+    }
+    if (
+      !this.core.pushNativeWrapper(
+        { ...identity, operationId: request.operationId },
+        request,
+        (reply) => {
+          this.viewerPending--;
+          onReply(reply);
+        },
+      )
+    )
+      return false;
+    this.viewerPending++;
+    try {
+      proc.stdin.write(command + "\n");
+    } catch {
+      this.core.fail("Native viewer write failed");
+      this.retireNativeViewer();
+    }
+    return true;
+  }
 
   request(cmd: string): Promise<string[]> {
     const proc = this.proc;
@@ -949,6 +1351,7 @@ export class MirrorControlChannel implements MirrorChannelIo {
    * signals are a fallback, never the first move (wedged-server hazard).
    */
   async dispose(): Promise<void> {
+    this.retireNativeViewer();
     if (this.atomicCollectorTimer) clearTimeout(this.atomicCollectorTimer);
     this.atomicCollectorTimer = null;
     const proc = this.proc;
@@ -982,6 +1385,8 @@ export class MirrorControlChannel implements MirrorChannelIo {
   private noteExit(reason: string | null): void {
     if (this.exited) return;
     this.exited = true;
+    this.retireNativeViewer();
+    this.guardedStart?.reject(new Error(reason ?? "Control channel exited before guarded attach"));
     this.opts.handlers.onExit(reason);
   }
 }

package/packages/daemon/src/terminal/mirror/events.ts

@@ -1,3 +1,5 @@
+import type { WindowLinkTopology } from "@tmux-ide/contracts";
+import type { NativeGridCapture } from "./native-grid-capture.ts";
 /**
  * Public event contract of the daemon MirrorService (m43 card 1).
  *
@@ -44,6 +46,10 @@ export type MirrorPaneEvent =
   | {
       /** Screen + history bytes captured at ONE instant (`capture-pane -e -J`). */
       type: "seed";
+      /** Only requested by the canonical parser owner. */
+      native?: NativeGridCapture;
+      /** Mixed-format recovery: canonical owner waits for its own fresh seed. */
+      requiresNativeRecapture?: boolean;
       data: Uint8Array;
     }
   | {
@@ -126,6 +132,7 @@ export interface MirrorLayoutAuthoritySnapshot {
   readonly session: string;
   readonly runtimeSessionId: string;
   readonly topologyEpoch: number;
+  readonly windowLinks: WindowLinkTopology;
   readonly layouts: readonly MirrorLayoutEvent[];
 }
 

package/packages/daemon/src/terminal/mirror/layout-content-rows.ts

@@ -0,0 +1,13 @@
+/** Content height of one pane in a qualified visible or saved tmux layout. */
+export function layoutContentRows(
+  paneTop: number,
+  paneHeight: number,
+  windowRows: number,
+  border: "off" | "top" | "bottom",
+): number {
+  if (border === "off") return paneHeight;
+  // Only the pane touching the configured outer edge loses a content row.
+  // Interior separators are already represented by the layout geometry.
+  const touchesStatusEdge = border === "top" ? paneTop === 0 : paneTop + paneHeight === windowRows;
+  return paneHeight - (touchesStatusEdge ? 1 : 0);
+}