tmux-ide 2.9.4 → 2.9.5

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

@@ -7,15 +7,15 @@ import type { NativeGridCapture } from "./native-grid-capture.ts";
  * addresses (`%N`, `@N`, `$N`) never cross this boundary. Pane content arrives
  * as a typed event stream a renderer can apply verbatim to a VT emulator:
  *
- *   reset → seed → [held deltas] → cursor → live deltas…
+ *   reset → seed → cursor → [held deltas] → live deltas…
  *
  * The seed batch is emitted ATOMICALLY (one synchronous callback sequence) so
  * a consumer can apply it as a single paint: `reset` replaces emulator state
  * (tmux is a painter, not a stream — never composite two captures), `seed`
- * carries one capture from one instant, any deltas the server emitted between
- * the capture and cursor probes replay next (they are strictly-after-capture
- * bytes the capture cannot contain), and `cursor` lands the emulator cursor on
- * tmux's truth. Everything after is a live delta.
+ * carries one capture from one instant, and `cursor` installs that capture's
+ * cursor and mode metadata. Strictly post-capture output then replays once;
+ * installing older cursor/mode metadata after those bytes would overwrite their
+ * effects. Everything after the held tail is a live delta.
  */
 
 /** Modes observed at the native capture seam; omitted fields stay unknown. */
@@ -72,8 +72,8 @@ export type MirrorPaneEvent =
     }
   | {
       /** Delivery state changed. `backpressure` mirrors tmux `%pause`;
-       *  `requested` is a subscriber's own freeze. A `resumed` flow event is
-       *  always followed by a fresh atomic seed batch. */
+       *  `requested` is a subscriber's own freeze. A `resumed` flow event follows
+       *  the fresh atomic seed batch and its held output. */
       type: "flow";
       state: "paused" | "resumed";
       reason: "backpressure" | "requested";

package/packages/daemon/src/terminal/mirror/mirror-service.ts

@@ -73,6 +73,10 @@ export interface MirrorServiceOptions {
   controlModeOwnershipRegistry?: ControlModeOwnershipRegistry;
   /** Emitted only after an event-triggered list-clients proof of a native client. */
   onNativeClientActivity?: (session: string) => void;
+  captureInputWrite?: (
+    session: string,
+    ...args: Parameters<NonNullable<SessionChannelOptions["captureInputWrite"]>>
+  ) => ReturnType<NonNullable<SessionChannelOptions["captureInputWrite"]>>;
   onInputWrite?: (
     session: string,
     action: InputAction,
@@ -496,6 +500,47 @@ export class MirrorService {
     return this.channels.get(session)?.channel.flowSnapshot() ?? null;
   }
 
+  // Cumulative scalar totals sampled after each retired channel finishes disposal.
+  // Keep evidence of residual listeners without retaining retired channel objects.
+  private readonly retiredListenerCounts = {
+    channels: 0,
+    failures: 0,
+    pane: 0,
+    layout: 0,
+    layoutAuthority: 0,
+  };
+
+  qualificationListeners() {
+    const active = { pane: 0, layout: 0, layoutAuthority: 0 };
+    for (const entry of this.channels.values()) {
+      const counts = entry.channel.qualificationListeners();
+      active.pane += counts.pane;
+      active.layout += counts.layout;
+      active.layoutAuthority += counts.layoutAuthority;
+    }
+    return Object.freeze({
+      active: Object.freeze(active),
+      retired: Object.freeze({ ...this.retiredListenerCounts }),
+      pendingDisposals: this.pendingDisposals.size,
+      sessionExit: this.sessionExitListeners.size,
+    });
+  }
+
+  private async disposeObservedChannel(channel: SessionChannel): Promise<void> {
+    try {
+      await channel.dispose();
+    } catch (error) {
+      this.retiredListenerCounts.failures += 1;
+      throw error;
+    } finally {
+      const counts = channel.qualificationListeners();
+      this.retiredListenerCounts.channels += 1;
+      this.retiredListenerCounts.pane += counts.pane;
+      this.retiredListenerCounts.layout += counts.layout;
+      this.retiredListenerCounts.layoutAuthority += counts.layoutAuthority;
+    }
+  }
+
   activeChannelCount(): number {
     return this.channels.size;
   }
@@ -512,7 +557,7 @@ export class MirrorService {
         this.updateWindowMembership(entry.channel, []);
         this.channelSessions.delete(entry.channel);
         try {
-          await entry.channel.dispose();
+          await this.disposeObservedChannel(entry.channel);
         } finally {
           entry.releaseAuthority();
         }
@@ -625,6 +670,8 @@ export class MirrorService {
             }
           },
           onNativeClientActivity: () => this.opts.onNativeClientActivity?.(session),
+          captureInputWrite: (action, semanticPaneId) =>
+            this.opts.captureInputWrite?.(session, action, semanticPaneId),
           onInputWrite: (action, startedAtMicros, endedAtMicros, pendingBeforeSend) =>
             this.opts.onInputWrite?.(
               session,
@@ -686,8 +733,7 @@ export class MirrorService {
     this.updateWindowMembership(entry.channel, []);
     this.channelSessions.delete(entry.channel);
     if (this.channels.get(session) === entry) this.channels.delete(session);
-    const disposal = entry.channel
-      .dispose()
+    const disposal = this.disposeObservedChannel(entry.channel)
       .catch(() => {})
       .finally(() => entry.releaseAuthority());
     this.drainingChannels.set(session, disposal);

package/packages/daemon/src/terminal/mirror/native-grid-projection.ts

@@ -1,3 +1,4 @@
+import { TERMINAL_REPLICA_EMPTY_CELL, TERMINAL_REPLICA_SPACE_CELL } from "@tmux-ide/core";
 import type {
   TerminalReplicaCell,
   TerminalReplicaColor,
@@ -23,13 +24,7 @@ export function nativeProjectedRowSource(row: TerminalReplicaRow) {
 }
 
 const defaultColor: TerminalReplicaColor = Object.freeze({ kind: "default" });
-const empty: TerminalReplicaCell = Object.freeze({
-  grapheme: "",
-  width: 1,
-  foreground: defaultColor,
-  background: defaultColor,
-  attributes: 0,
-});
+const empty = TERMINAL_REPLICA_EMPTY_CELL;
 const acsKeys = [..."+,-.0`abcdefghijklmnopqrstuvwxyz{|}~"];
 const acsValues = [..."→←↑↓▮◆▒␉␌␍␊°±␤␋┘┐┌└┼⎺⎻─⎼⎽├┤┴┬│≤≥π≠£·"];
 const acs = new Map(acsKeys.map((key, index) => [key, acsValues[index]!]));
@@ -45,7 +40,7 @@ function color(value: number): TerminalReplicaColor {
 
 function paint(cell: NativeGridCaptureCell): TerminalReplicaCell {
   const bits = cell.attributes;
-  return Object.freeze({
+  return {
     grapheme: bits & 0x80 ? (acs.get(cell.text) ?? cell.text) : cell.text,
     width: cell.width === 2 ? 2 : 1,
     foreground: color(cell.foreground),
@@ -58,7 +53,22 @@ function paint(cell: NativeGridCaptureCell): TerminalReplicaCell {
       (bits & 0x10 ? 32 : 0) |
       (bits & 0x20 ? 64 : 0) |
       (bits & 0x100 ? 128 : 0),
-  });
+  };
+}
+
+// Only normalized, internally constructed paint can reuse trusted core values.
+// Foreign native fields have already been read in the original paint order.
+function freezePaint(cell: TerminalReplicaCell): TerminalReplicaCell {
+  if (
+    cell.width === 1 &&
+    cell.attributes === 0 &&
+    cell.foreground === defaultColor &&
+    cell.background === defaultColor
+  ) {
+    if (cell.grapheme === "") return TERMINAL_REPLICA_EMPTY_CELL;
+    if (cell.grapheme === " ") return TERMINAL_REPLICA_SPACE_CELL;
+  }
+  return Object.freeze(cell);
 }
 
 /**
@@ -105,12 +115,12 @@ export function projectNativeGridRow(
       x + native.width > columns
     ) {
       const span = native.flags & 0x80 ? Math.max(1, Math.min(native.width, columns - x)) : 1;
-      const blank = Object.freeze({ ...styled, grapheme: "", width: 1 as const });
+      const blank = freezePaint({ ...styled, grapheme: "", width: 1 as const });
       for (let offset = 0; offset < span; offset++) cells[x + offset] = blank;
       x += span - 1;
       continue;
     }
-    cells[x] = styled;
+    cells[x] = freezePaint(styled);
     if (native.width === 2) {
       cells[++x] = Object.freeze({ ...styled, grapheme: "", width: 0 });
     }

package/packages/daemon/src/terminal/mirror/pane-feed.ts

@@ -1,13 +1,12 @@
 import type { NativeGridCapture } from "./native-grid-capture.ts";
 /**
  * PaneFeed — PURE per-subscriber delivery gate implementing the atomic
- * seed/reseed recipe (m43 flood spike, verified on tmux 3.7b).
+ * seed/reseed recipe. This gate assumes the caller supplies a valid capture
+ * seam; FIFO command replies alone do not prove that precondition.
  *
  * tmux is a painter, not a stream: history and the live screen are separate
  * authorities, and a capture may only be spliced onto a live stream at an
- * explicit seam. The seam works because the control channel is FIFO — the
- * `capture-pane` reply comes back at the exact point in the byte stream where
- * the capture was taken, so:
+ * explicit seam. For a VALID seam the caller must establish:
  *
  *   - every `%output` delta read BEFORE the capture reply was produced before
  *     the capture instant → its bytes are already IN the capture → DISCARD
@@ -15,6 +14,12 @@ import type { NativeGridCapture } from "./native-grid-capture.ts";
  *   - every delta read AFTER the capture reply is strictly-after-capture →
  *     it must be applied on top of the seed → no gap.
  *
+ * Known limitation: a sibling pane backlog can hold a capture reply while
+ * post-capture target output drains ahead of it. Ordinary capture reply order
+ * therefore does not establish this seam; that path can discard newer output.
+ * See docs/guides/tmux-boundary-model.md and TM02 for the real-wire reproducer.
+ * Native atomic snapshot/offset commit has a separate, stronger contract.
+ *
  * The cursor probe is a second command issued back-to-back with the capture.
  * Deltas that land between the two replies (normally none — both commands sit
  * in one command-queue batch) are HELD and replayed after the seed but BEFORE