fix(web): repeindre les terminaux au retour-visible + flush ACK ciblé

Un terminal caché dans une grille de groupe (ou hors-écran) n'était pas repeint
au retour — `visibilitychange` ne couvre que l'onglet — d'où l'écran noir avec
curseur ; et son ACK ne progressait plus (callback xterm.write throttlé) → le
serveur mettait le PTY en pause → sortie « par à-coups ». Ajoute un
IntersectionObserver (repaint + flushAck ciblé au retour-visible) et expose
Attachment.flushAck (factorisé avec flushAcks).

packages/web/src/components/TerminalView.vue

@@ -38,6 +38,7 @@ const ended = ref(false);
 let term: Terminal | null = null;
 let attachment: Attachment | null = null;
 let resizeObserver: ResizeObserver | null = null;
+let intersectionObserver: IntersectionObserver | null = null;
 let onVisible: (() => void) | null = null;
 let disposed = false;
 
@@ -130,6 +131,20 @@ onMounted(async () => {
   activeTerm.onData((data) => attachment?.sendStdin(data));
   resizeObserver = new ResizeObserver(refit);
   resizeObserver.observe(container.value);
+  // Re-révélation RÉELLE du conteneur : cellule de grille démontée/remontée (maximize↔grille), scroll
+  // hors/dans le viewport, ou navigation SPA — autant de cas que `visibilitychange` (onglet only) ne
+  // couvre PAS. Au retour visible, on repeint (le rendu était gelé hors-écran) ET on flushe l'ACK pour
+  // sortir d'une éventuelle pause serveur (le callback de xterm.write était throttlé tant que caché).
+  intersectionObserver = new IntersectionObserver((entries) => {
+    for (const entry of entries) {
+      if (!entry.isIntersecting) continue;
+      // évite un fit() sur conteneur de taille 0 (remontage transitoire) → déforme le TUI
+      if (entry.intersectionRect.width === 0 || entry.intersectionRect.height === 0) continue;
+      refit();
+      attachment?.flushAck();
+    }
+  });
+  intersectionObserver.observe(container.value);
   // au retour en avant-plan, forcer un repaint (le renderer WebGL peut avoir « gelé » l'écran pendant
   // que l'onglet était caché) ; le ws-client flushe en parallèle les ACK pour relancer le flux.
   onVisible = (): void => {
@@ -142,6 +157,7 @@ onMounted(async () => {
 onBeforeUnmount(() => {
   disposed = true;
   resizeObserver?.disconnect();
+  intersectionObserver?.disconnect();
   if (onVisible) document.removeEventListener('visibilitychange', onVisible);
   attachment?.detach();
   term?.dispose();

packages/web/src/lib/ws-client.ts

@@ -100,6 +100,12 @@ export class Attachment {
     this.pending = null;
     this.client.releaseAttachment(this);
   }
+
+  /** Flush ACK ciblé : relance immédiatement le flux si le serveur avait mis ce PTY en pause
+   *  (ex. retour-visible de la cellule, dont le rendu était gelé hors-écran). N'ACK que du traité. */
+  flushAck(): void {
+    this.client.flushAck(this);
+  }
 }
 
 export class WsClient {
@@ -357,15 +363,25 @@ export class WsClient {
   /** ACK immédiat du reliquat traité pour tous les terminaux ouverts — au retour en avant-plan,
    *  pour rattraper sans attendre le débounce un serveur éventuellement en pause. */
   private flushAcks(): void {
-    for (const att of this.attachments) {
-      if (att.closed || att.channel < 0) continue;
-      if (att.processedBytes > att.lastAckBytes) {
-        att.lastAckBytes = att.processedBytes;
-        this.sendControl({ type: 'ack', channel: att.channel, bytes: att.processedBytes });
-      }
+    for (const att of this.attachments) this.flushAttachmentAck(att);
+  }
+
+  /** ACK immédiat du reliquat traité d'UN attachment — n'ACK que du réellement traité (invariant
+   *  préservé). Factorisé : utilisé par flushAcks() et par le flush ciblé flushAck(). */
+  private flushAttachmentAck(att: Attachment): void {
+    if (att.closed || att.channel < 0) return;
+    if (att.processedBytes > att.lastAckBytes) {
+      att.lastAckBytes = att.processedBytes;
+      this.sendControl({ type: 'ack', channel: att.channel, bytes: att.processedBytes });
     }
   }
 
+  /** Flush ACK ciblé d'un seul attachment : relance un PTY mis en pause par le serveur quand la
+   *  cellule était cachée (cf. Attachment.flushAck, appelé au retour-visible). */
+  flushAck(att: Attachment): void {
+    this.flushAttachmentAck(att);
+  }
+
   private handleServerMessage(msg: ServerMessage): void {
     switch (msg.type) {
       case 'hello_ok': {