buninu-linux 0.15.58 → 0.17.60

package/initramfs/buninu/apps/jsgotty/client.mjs

@@ -4,6 +4,10 @@ import process from "node:process";
 import { Buffer } from "node:buffer";
 import WebSocket from "ws";
 import { encodeKittyGraphics, syntheticKittyCursorMotion } from "./client-kitty.mjs";
+import terminalModes from "./terminal-modes.js";
+
+const { TerminalModeTracker, modeTransition, validateSnapshot } = terminalModes;
+import { captureTerminalModes } from "./client-modes.mjs";
 
 const MSG_INPUT = "1";
 const MSG_PING = "2";
@@ -19,6 +23,7 @@ const MSG_SET_BUFFER_SIZE = "6";
 const MSG_KITTY_GRAPHICS = "7";
 const MSG_SET_ROLE = "a";
 const MSG_CONTROL_RESULT = "b";
+const MSG_RESTORE_MODES = "m";
 
 const DEFAULT_URL = "ws://127.0.0.1:8080/ws";
 
@@ -409,6 +414,40 @@ async function main() {
     return;
   }
   const args = buildArguments(options, initArguments);
+  const originalRawMode = !!process.stdin.isRaw;
+  const localModes = new TerminalModeTracker();
+  // A closed terminal surfaces as an async EIO/EPIPE, not a throw. Nobody is
+  // left to read anything, and the PTY keeps its modes, so just exit.
+  for (const stream of [process.stdin, process.stdout, process.stderr]) {
+    stream.on("error", (error) => {
+      if (error.code !== "EIO" && error.code !== "EPIPE") {
+        throw error;
+      }
+      process.exit(process.exitCode ?? 1);
+    });
+  }
+  const writeTerminal = (data) => {
+    process.stdout.write(data);
+    localModes.consume(Buffer.from(data));
+  };
+  const captured = await captureTerminalModes(process.stdin, process.stdout);
+  const originalModes = captured.state;
+  Object.assign(localModes, validateSnapshot(originalModes));
+  let bufferedInput = captured.buffered;
+  let probeFlushTimer, replayingProbe = false;
+  const terminalInput = chunk => {
+    if (replayingProbe) return Buffer.from(chunk);
+    const input = captured.probe.consume(chunk);
+    clearTimeout(probeFlushTimer);
+    // A lone Escape is user input too. Never hold it indefinitely while
+    // filtering a split or late response to our startup queries.
+    if (captured.probe.pending.length) probeFlushTimer = setTimeout(() => {
+      const pending = captured.probe.flush();
+      replayingProbe = true;
+      try { process.stdin.emit("data", pending); } finally { replayingProbe = false; }
+    }, 30);
+    return input;
+  };
   writeStatus(`[gotty] connecting to\n  ${wsUrl}`);
   const ws = new WebSocket(wsUrl, "webtty");
   let pingTimer = null;
@@ -432,7 +471,8 @@ async function main() {
     if (!writable || ws.readyState !== WebSocket.OPEN) {
       return;
     }
-    ws.send(MSG_INPUT + Buffer.from(chunk).toString("base64"));
+    const input = terminalInput(chunk);
+    if (input.length) ws.send(MSG_INPUT + input.toString("base64"));
   };
 
   const handleResize = () => {
@@ -441,21 +481,52 @@ async function main() {
     }
   };
 
+  let exiting = false;
   const exitClient = (code = 0) => {
+    if (exiting) return;
+    exiting = true;
     cleanup();
     reportDisconnected();
     ws.close();
-    process.exit(code);
+    process.stdout.write("", () => process.exit(code));
   };
 
+  // Restoring the viewed session also restores Kitty keyboard modes. Exit
+  // keys can therefore arrive as CSI u rather than legacy control bytes.
+  // Keep CSI packets across chunks; never treat a key-release as a press.
+  let viewerSequence = "";
   const handleViewerInput = (chunk) => {
-    for (const byte of Buffer.from(chunk)) {
-      if (byte === 0x03) {
-        exitClient(130);
+    for (const byte of terminalInput(chunk)) {
+      if (viewerSequence) {
+        viewerSequence += String.fromCharCode(byte);
+        if (viewerSequence === "\x1b[") continue;
+        if (viewerSequence.length === 2 && byte !== 0x5b) {
+          viewerSequence = "";
+          continue;
+        }
+        if (viewerSequence.length > 2 && byte >= 0x40 && byte <= 0x7e) {
+          const sequence = viewerSequence;
+          viewerSequence = "";
+          const kitty = /^\x1b\[(\d+)(?::[0-9:]*)?(?:;(\d+)(?::([123]))?)?(?:;[0-9:]+)?u$/.exec(sequence);
+          const modified = /^\x1b\[27;(\d+);(\d+)~$/.exec(sequence);
+          const key = kitty ? +kitty[1] : modified ? +modified[2] : 0;
+          const modifiers = (kitty ? +(kitty[2] || 1) : modified ? +modified[1] : 1) - 1;
+          // Ignore Caps/Num Lock, but require Ctrl without Alt/Shift/Super.
+          if ((modifiers & ~192) === 4 && (!kitty || kitty[3] !== "3")) {
+            if (key === 99) return exitClient(130);
+            if (key === 100 || key === 113) return exitClient(0);
+          }
+        } else if (viewerSequence.length > 128) {
+          viewerSequence = "";
+        }
+        continue;
       }
-      if (byte === 0x04 || byte === 0x11) {
-        exitClient(0);
+      if (byte === 0x1b) {
+        viewerSequence = "\x1b";
+        continue;
       }
+      if (byte === 0x03) return exitClient(130);
+      if (byte === 0x04 || byte === 0x11) return exitClient(0);
     }
   };
 
@@ -498,7 +569,8 @@ async function main() {
       return;
     }
 
-    const input = Buffer.from(chunk);
+    const input = terminalInput(chunk);
+    if (!input.length) return;
     fallbackProbe = normalizeEcho(input.toString("utf8"));
     ws.send(MSG_INPUT + input.toString("base64"));
     stopFallbackInput();
@@ -532,6 +604,10 @@ async function main() {
       setRawMode(true);
       rawEnabled = process.stdin.isTTY;
       sendResize(ws, options);
+      if (bufferedInput.length) {
+        ws.send(MSG_INPUT + bufferedInput.toString("base64"));
+        bufferedInput = Buffer.alloc(0);
+      }
       return;
     }
 
@@ -558,6 +634,7 @@ pid:
       return;
     }
     closed = true;
+    clearTimeout(probeFlushTimer);
     if (pingTimer) {
       clearInterval(pingTimer);
       pingTimer = null;
@@ -565,8 +642,13 @@ pid:
     setWritable(false);
     stopFallbackInput();
     stopViewerInput();
+    if (process.stdout.isTTY) {
+      try {
+        writeTerminal(modeTransition(localModes.snapshot(), originalModes, { normalizeMouse: true, kittyRestore: captured.probe.kittyRestore }));
+      } catch {}
+    }
     if (rawEnabled) {
-      setRawMode(false);
+      setRawMode(originalRawMode);
       rawEnabled = false;
     }
     process.stdin.pause();
@@ -611,7 +693,7 @@ pid:
             break;
           }
           pendingKittyCursorMotion = "";
-          process.stdout.write(output);
+          writeTerminal(output);
           if (fallbackProbe && accessRole === "") {
             fallbackOutputTail = normalizeEcho(
               `${fallbackOutputTail}${output.toString("utf8")}`
@@ -641,6 +723,14 @@ pid:
           if (encoded) process.stdout.write(encoded);
         } catch {}
         break;
+      case MSG_RESTORE_MODES:
+        // Only local terminal state; the PTY keeps its modes for the next resume.
+        if (process.stdout.isTTY) {
+          try {
+            writeTerminal(modeTransition(localModes.snapshot(), validateSnapshot(JSON.parse(payload)), { normalizeMouse: true, kittyRestore: captured.probe.kittyRestore }));
+          } catch {}
+        }
+        break;
       case MSG_SET_RECONNECT: {
         try {
           const reconnect = JSON.parse(payload);

package/initramfs/buninu/apps/jsgotty/clipboard-powershell.js

@@ -0,0 +1,18 @@
+"use strict";
+// Copied verbatim from jsmdcui/src/platform/clipboard.js (MIT).
+// Keep the function below unchanged; inject its existing command helpers.
+module.exports = function createPowerShellClipboard(shell, runSync, outputOrThrow) {
+function powershellClipboard(shell) {
+  return {
+    name: "powershell",
+    // Get-Clipboard -Raw appends \r\n to stdout; strip exactly one trailing line ending.
+    read: () => outputOrThrow(runSync([shell, "-NoProfile", "-Command", "Get-Clipboard -Raw"], {})).replace(/\r?\n$/, ""),
+    write: (text) => {
+      text=(text+'').replaceAll("'","''") ;
+      return runSync([shell, "-NoProfile", "-Command", `Set-Clipboard '${text}'`], { stdout: "ignore" }).ok ;
+    },
+  };
+}
+
+return powershellClipboard(shell);
+};

package/initramfs/buninu/apps/jsgotty/clipboard.js

@@ -0,0 +1,148 @@
+"use strict";
+const createPowerShellClipboard = require('./clipboard-powershell.js');
+// Self-contained so the worker remains valid after bundling/minification.
+function clipboardRuntime(createPowerShellClipboard) {
+  const {spawnSync} = require('node:child_process');
+  const fs = require('node:fs');
+  const path = require('node:path');
+  const MAX_OSC52 = 1024 * 1024;
+  function which(name) {
+    if (typeof Bun !== 'undefined') return Bun.which(name);
+    const names=process.platform==='win32' && !path.extname(name)
+      ? [name,...(process.env.PATHEXT || '.EXE;.CMD;.BAT').split(';').map(ext=>name+ext)] : [name];
+    for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+      for(const candidate of names) {
+        const file=path.join(dir,candidate);
+        try {fs.accessSync(file,fs.constants.X_OK);if(fs.statSync(file).isFile())return file;} catch {}
+      }
+    }
+    return null;
+  }
+  function runSync(command, options={}) {
+    try {
+      const r=spawnSync(command[0],command.slice(1),{
+        input:options.stdin, encoding:'utf8', timeout:options.timeout ?? 2000,
+        maxBuffer:MAX_OSC52, stdio:['pipe',options.stdout ?? 'pipe','pipe'],windowsHide:true,
+      });
+      return {ok:!r.error && r.status===0,stdout:r.stdout || '',stderr:r.stderr || String(r.error || '')};
+    } catch(error) {return {ok:false,stdout:'',stderr:String(error)};}
+  }
+  function outputOrThrow(result) {
+    if (!result.ok) throw new Error(result.stderr || result.stdout || 'clipboard command failed');
+    return result.stdout;
+  }
+  function createClipboard({find=which,run=runSync,platform=process.platform}={}) {
+    const internal=new Map();
+    function candidates(register,write,text) {
+      const result=[];
+      const command=(name,args)=>{const executable=find(name);if(executable)result.push(()=>run([executable,...args],write?{stdin:text,stdout:'ignore'}:{}));};
+      // Always first, including Windows and Android. Failure does not pin a backend.
+      command('xclip',['-selection',register,...(write?[]:['-o'])]);
+      if(register==='clipboard') {
+        command(write?'termux-clipboard-set':'termux-clipboard-get',[]);
+      }
+      if(register!=='secondary')command(write?'wl-copy':'wl-paste',[...(write?[]:['--no-newline']),...(register==='primary'?['--primary']:[])]);
+      command('xsel',[`--${register}`,write?'--input':'--output']);
+      if(register==='clipboard') {
+        if(platform==='darwin')command(write?'pbcopy':'pbpaste',[]);
+        if(platform==='win32')for(const name of ['pwsh.exe','powershell.exe','pwsh','powershell']){
+          const shell=find(name);if(!shell)continue;
+          const backend=createPowerShellClipboard(shell,run,outputOrThrow);
+          result.push(()=>write?{ok:backend.write(text)}:{ok:true,stdout:backend.read()});
+        }
+      }
+      return result;
+    }
+    return {
+      read(register='clipboard') {
+        if(/^cut[0-7]$/.test(register))return internal.get(register);
+        for(const attempt of candidates(register,false))try {
+          const r=attempt();if(r.ok){internal.set(register,r.stdout);return r.stdout;}
+        }catch{}
+        return internal.get(register);
+      },
+      write(text,register='clipboard') {
+        internal.set(register,text);
+        if(/^cut[0-7]$/.test(register))return;
+        for(const attempt of candidates(register,true,text))try {if(attempt().ok)return;}catch{}
+      },
+    };
+  }
+  function parseOSC52(data) {
+    if(typeof data!=='string'||data.length>MAX_OSC52)return null;
+    const i=data.indexOf(';');if(i<0)return null;
+    const selection=data.slice(0,i),payload=data.slice(i+1);
+    if(!/^[cpqs0-7]*$/.test(selection)||selection.length>16)return null;
+    const registers=[...new Set([...(selection || 's0')].map(c=>({c:'clipboard',p:'primary',q:'secondary',s:'clipboard'}[c]||`cut${c}`)))];
+    if(payload==='?')return {selection,registers,read:true};
+    // OSC 52 specifies clearing the selection for non-base64 data.
+    const valid=/^[A-Za-z0-9+/]*={0,2}$/.test(payload) && payload.replace(/=+$/,'').length % 4 !== 1;
+    return {selection,registers,read:false,text:valid?Buffer.from(payload,'base64').toString('utf8'):''};
+  }
+  function executeOSC52(clipboard,request) {
+    if(request.read) {
+      let text;
+      for(const register of request.registers){text=clipboard.read(register);if(text!==undefined)break;}
+      const data=Buffer.from(text ?? '', 'utf8');
+      if(data.length>MAX_OSC52)return null;
+      return `\x1b]52;${request.selection};${data.toString('base64')}\x1b\\`;
+    }
+    for(const register of request.registers)clipboard.write(request.text,register);
+    return null;
+  }
+  return {createClipboard,parseOSC52,executeOSC52,MAX_OSC52};
+}
+const {createClipboard,parseOSC52,executeOSC52,MAX_OSC52}=clipboardRuntime(createPowerShellClipboard);
+module.exports={createClipboard,parseOSC52,executeOSC52,MAX_OSC52};
+
+// Run the synchronous jsmdcui-compatible backends off the server event loop.
+// Inline the helpers so compiled single-file builds need no external worker file.
+class ClipboardHost {
+  constructor(){this.pending=new Map();this.nextId=0;this.worker=null;}
+  execute(request){
+    if(this.pending.size>=32)return Promise.reject(Error('clipboard queue full'));
+    if(!this.worker){
+      const {Worker}=require('node:worker_threads');
+      const source=`const {parentPort}=require('node:worker_threads');
+const runtime=(${clipboardRuntime.toString()})(${createPowerShellClipboard.toString()});
+const clipboard=runtime.createClipboard();parentPort.on('message',({id,request})=>{
+ try{parentPort.postMessage({id,result:runtime.executeOSC52(clipboard,request)});}
+ catch(error){parentPort.postMessage({id,error:String(error)});}
+});`;
+      const worker=this.worker=new Worker(source,{eval:true});
+      const failed=error=>{
+        if(this.worker!==worker)return;
+        this.worker=null;
+        for(const job of this.pending.values())job.reject(error);
+        this.pending.clear();worker.terminate();
+      };
+      worker.on('error',failed);
+      worker.on('exit',()=>failed(Error('clipboard worker exited')));
+      worker.on('message',({id,result,error})=>{
+        const job=this.pending.get(id);if(!job)return;
+        this.pending.delete(id);error?job.reject(Error(error)):job.resolve(result);
+        if(!this.pending.size)worker.unref();
+      });
+      worker.unref();
+    }
+    return new Promise((resolve,reject)=>{
+      const id=++this.nextId;this.pending.set(id,{resolve,reject});this.worker.ref();
+      this.worker.postMessage({id,request});
+    });
+  }
+  async close(){
+    const worker=this.worker;this.worker=null;
+    for(const job of this.pending.values())job.reject(Error('clipboard closed'));
+    this.pending.clear();if(worker)await worker.terminate();
+  }
+}
+// Authorization is checked both before host access and before returning data.
+function handleOSC52(session,ws,payload,host){
+  if(!session.isWriter(ws))return;
+  const request=parseOSC52(payload);if(!request)return;
+  host.execute(request).then(reply=>{
+    if(reply && !session.closed && session.isWriter(ws))session.backend.write(Buffer.from(reply));
+  }).catch(()=>{});
+}
+module.exports.ClipboardHost=ClipboardHost;
+module.exports.handleOSC52=handleOSC52;

package/initramfs/buninu/apps/jsgotty/gotty.js

@@ -12,7 +12,10 @@ const crypto = require("crypto");
 const zlib = require("zlib");
 const { constants: fsConstants } = require("fs");
 const WebSocket = require("ws");
+const { TerminalModeTracker } = require("./terminal-modes.js");
 const { WebSocketServer } = WebSocket;
+const { ClipboardHost, handleOSC52 } = require("./clipboard.js");
+const clipboardHost = new ClipboardHost();
 
 const MSG_INPUT = "1";
 const MSG_PING = "2";
@@ -34,6 +37,7 @@ const MSG_ZMODEM_MODE = "z";
 const MSG_ZMODEM_OUTPUT = "y";
 const MSG_ZMODEM_ACK = "Y";
 const MSG_KITTY_DEBUG = "K";
+const MSG_RESTORE_MODES = "m";
 const KITTY_TRACE = /^(1|true|yes|on)$/i.test(String(process.env.JSGOTTY_KITTY_DEBUG || ""));
 const WINDOWS_BRIDGE_TRACE = process.env.WINDOWS_BRIDGE_TRACE === "1";
 const WINDOWS_BRIDGE_PREFIX = Buffer.from("@@GOTTYCTL:", "ascii");
@@ -1680,6 +1684,7 @@ class PtySession {
     this.supportsWindowsBridge = process.platform === "win32";
     this.cursorTracker = new CursorStateTracker();
     this.cursorTracker.setDimensions(this.columns || 80);
+    this.modeTracker = new TerminalModeTracker();
     this.kittyParser = new KittyGraphicsParser();
     this.windowsBridgeParser = this.supportsWindowsBridge ? new WindowsBridgeParser("incoming") : null;
     this.outgoingWindowsBridgeParser = this.supportsWindowsBridge ? new WindowsBridgeParser("outgoing") : null;
@@ -1759,6 +1764,7 @@ class PtySession {
         if (!this.supportsWindowsBridge) {
           const cursorBefore = this.cursorTracker.snapshot();
           this.cursorTracker.consume(filteredChunk);
+          this.modeTracker.consume(filteredChunk);
           const cursorAfter = this.cursorTracker.snapshot();
           const controls = cursorControls(filteredChunk);
           if (controls.length > 0) {
@@ -1776,6 +1782,7 @@ class PtySession {
         if (bridged.plain.length > 0) {
           const cursorBefore = this.cursorTracker.snapshot();
           this.cursorTracker.consume(bridged.plain);
+          this.modeTracker.consume(bridged.plain);
           const cursorAfter = this.cursorTracker.snapshot();
           const controls = cursorControls(bridged.plain);
           if (controls.length > 0) {
@@ -1855,6 +1862,9 @@ class PtySession {
       this.writerWs = ws;
     }
     this.sendSessionMetadata(ws, remoteAddr);
+    // Queued ahead of live output; the client applies only modes that differ,
+    // which also clears modes a program turned off while the socket was down.
+    this.send(MSG_RESTORE_MODES, JSON.stringify(this.modeTracker.snapshot()), ws);
     this.startWebSocketHandlers(ws);
     this.notifyRoles();
     return true;
@@ -2442,6 +2452,9 @@ class PtySession {
     }
 
     switch (type) {
+      case "C":
+        handleOSC52(this, ws, payload, clipboardHost);
+        break;
       case MSG_INPUT:
         if (!this.isWriter(ws) || payload.length === 0) {
           return;

package/initramfs/buninu/apps/jsgotty/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "jsgotty",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "jsgotty",
-      "version": "1.2.0",
+      "version": "1.4.0",
       "dependencies": {
         "node-addon-api": "^7.1.1",
         "ws": "^8.18.3"

package/initramfs/buninu/apps/jsgotty/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jsgotty",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "Share your terminal as a web application: A JavaScript rewrite of GoTTY",
   "license": "MIT",
   "bin": {

package/initramfs/buninu/apps/jsgotty/static/css/index.css

@@ -10,4 +10,17 @@ html, body, #terminal {
   transition: unset;
   transition-duration: 0.1s;
   transition-timing-function: cubic-bezier(0.4, 0, 0.2, 1);
-}
+}
+
+/* Keep touch taps available to xterm even with a widened WebView viewport.
+   Include the viewport (a scroll container); preserve panning and pinch zoom. */
+#terminal, #terminal .xterm, #terminal .xterm-viewport, #terminal .xterm-screen {
+    touch-action: manipulation;
+}
+
+/* Chromium skips focused-editable auto-zoom when that element disallows
+   pinch zoom. Restrict only the hidden input, not the terminal canvas:
+   native paste/IME remain available and the visible terminal can still pinch. */
+#terminal .xterm-helper-textarea {
+    touch-action: none;
+}

package/initramfs/buninu/apps/jsgotty/static/js/gotty.js

@@ -12168,7 +12168,8 @@
           (t.msgSetWindowTitle = "3"),
           (t.msgSetPreferences = "4"),
           (t.msgSetReconnect = "5"),
-          (t.msgSetBufferSize = "6"));
+          (t.msgSetBufferSize = "6"),
+          (t.msgRestoreModes = "m"));
         t.WebTTY = class {
           term;
           connectionFactory;
@@ -12193,6 +12194,9 @@
             this.reconnectDeadline = 0;
             this.reconnectAttempts = 0;
             this.zmodemExpectedSeq = 0;
+            this.term.onClipboard?.(data => {
+              if (!this.disconnected) this.connection.send("C" + data);
+            });
           }
           open() {
             let e;
@@ -12330,6 +12334,9 @@
                       const e = JSON.parse(i);
                       this.term.setPreferences(e);
                       break;
+                    case t.msgRestoreModes:
+                      this.term.applySessionModes(JSON.parse(i));
+                      break;
                     case t.msgSetReconnect:
                       const r = JSON.parse(i);
                       "number" == typeof r
@@ -12540,12 +12547,30 @@
 	              })),
 	              (this.fitAddOn = new s.FitAddon()),
 	              (this.zmodemAddon = new a.ZModemAddon({
-	                toTerminal: (e) => this.term.write(e),
+	                toTerminal: (e) => this.writeTerminal(e),
 	                toServer: (e) => this.sendInput(e),
 	              })),
               (this.kittyKeyboard = new globalThis.GoTTYKittyKeyboard.KittyKeyboard(this.term, {
                 android: /Android/i.test(navigator.userAgent),
               })),
+              this.term.parser.registerOscHandler(52, data => {
+                if (!this.disconnected && data.length <= 1048576) this.clipboardHandler?.(data);
+                return true;
+              }),
+              this.term.parser.registerOscHandler(777, data => {
+                const match = /^jsgotty-modes;([a-f0-9]{32})$/.exec(data);
+                if (!match) {
+                  const restore = /^jsgotty-kitty-v1;(normal|alternate);(\d{1,2});(\d{1,2}(?:,\d{1,2})*)?$/.exec(data);
+                  if (!restore) return false;
+                  const flags = +restore[2], stack = restore[3] ? restore[3].split(',').map(Number) : [];
+                  if (flags > 31 || stack.length > 32 || stack.some(n => n > 31)) return true;
+                  this.kittyKeyboard.states[restore[1]] = {flags: flags & 11, stack: stack.map(n => n & 11)};
+                  return true;
+                }
+                this.term.input("\x1b]777;jsgotty-modes;" + match[1] + ";" +
+                  btoa(JSON.stringify({...this.sessionModes(), kittyRestore: 1})) + "\x07", false);
+                return true;
+              }),
               this.term.attachCustomKeyEventHandler((event) =>
                 this.kittyKeyboard.handle(event) && this.handleAndroidAltKey(event),
               ),
@@ -12676,8 +12701,73 @@
           getMessage() {
             return this.message;
           }
+          enqueueTerminal(task) {
+            this.terminalTasks ||= [];
+            this.terminalTasks.push(task);
+            if (this.terminalBusy) return;
+            this.terminalBusy = true;
+            const next = () => {
+              const task = this.terminalTasks.shift();
+              if (!task) { this.terminalBusy = false; return; }
+              task(next);
+            };
+            next();
+          }
+          writeTerminal(data) {
+            this.enqueueTerminal(done => this.term.write(data, done));
+          }
+          onClipboard(handler) {
+            this.clipboardHandler = handler;
+          }
+          sessionModes() {
+            const core = this.term._core;
+            return {dec: {...core.coreService.decPrivateModes},
+              mouse: core.coreMouseService.activeProtocol,
+              encoding: core.coreMouseService.activeEncoding,
+              cursorHidden: !!core.coreService.isCursorHidden,
+              alternate: this.term.buffer.active.type === "alternate",
+              kitty: JSON.parse(JSON.stringify(this.kittyKeyboard.states))};
+          }
+          applySessionModes(state) {
+            this.enqueueTerminal(done => this.term.write("", () => this.restoreSessionModes(state, done)));
+          }
+          restoreSessionModes(state, done) {
+            if (!state || !state.dec) { done(); return; }
+            const core = this.term._core;
+            const dec = core.coreService.decPrivateModes;
+            const mouse = core.coreMouseService;
+            // A socket-only reconnect keeps xterm's modes, so send only differences:
+            // DECOM homes the cursor and 1049 overwrites the saved cursor.
+            let sequence = "";
+            const alternate = this.term.buffer.active.type === "alternate";
+            if (!!state.alternate !== alternate) sequence += `\x1b[?1049${state.alternate ? "h" : "l"}`;
+            const flags = {1:"applicationCursorKeys", 6:"origin", 7:"wraparound", 45:"reverseWraparound",
+              66:"applicationKeypad", 1004:"sendFocus", 2004:"bracketedPasteMode"};
+            for (const [mode, name] of Object.entries(flags))
+              if (!!state.dec[name] !== !!dec[name]) sequence += `\x1b[?${mode}${state.dec[name] ? "h" : "l"}`;
+            if (!!state.cursorHidden !== !!core.coreService.isCursorHidden)
+              sequence += `\x1b[?25${state.cursorHidden ? "l" : "h"}`;
+            if (state.mouse !== mouse.activeProtocol) {
+              const modes = {X10:9, VT200:1000, DRAG:1002, ANY:1003};
+              sequence += modes[state.mouse] ? `\x1b[?${modes[state.mouse]}h` : "\x1b[?1000l";
+            }
+            if (state.encoding !== mouse.activeEncoding) {
+              const modes = {SGR:1006, SGR_PIXELS:1016};
+              sequence += modes[state.encoding] ? `\x1b[?${modes[state.encoding]}h` : "\x1b[?1006l";
+            }
+            const complete = () => {
+            // Assigned rather than replayed so the push stack never doubles; the server
+            // keeps every flag, so mask to the ones kitty-keyboard.js implements.
+            const supported = (s) => ({flags: s.flags & 11, stack: s.stack.map((f) => f & 11)});
+            if (state.kitty?.normal && state.kitty?.alternate)
+              this.kittyKeyboard.states = {normal: supported(state.kitty.normal), alternate: supported(state.kitty.alternate)};
+              done();
+            };
+            if (sequence) this.term.write(sequence, complete);
+            else complete();
+          }
           setDisconnected(e) {
-            if (e) this.kittyKeyboard.reset();
+            if (e) this.kittyKeyboard.clearHeld(false);
             this.disconnected = !!e;
           }
           setReconnectAction(e) {
@@ -12789,7 +12879,8 @@
             this.term.blur();
           }
           reset() {
-            this.kittyKeyboard.reset();
+            // Reconnecting the transport does not reset the running PTY's modes.
+            this.kittyKeyboard.clearHeld(false);
             (this.removeMessage(), this.term.clear());
           }
           close() {
@@ -15906,8 +15997,15 @@
                                 !1 === e._customWheelEventHandler(t)
                               )
                                 return !1;
-                              if (0 === e.viewport.getLinesScrolled(t))
-                                return !1;
+                              // Preserve both axes of diagonal wheel/touch gestures.
+                              // CoreMouseService already encodes wheel actions 2/3 as 66/67.
+                              if (t.deltaX) e.coreMouseService.triggerMouseEvent({
+                                col: i.col, row: i.row, x: i.x, y: i.y,
+                                button: 4, action: t.deltaX < 0 ? 2 : 3,
+                                ctrl: t.ctrlKey, alt: t.altKey, shift: t.shiftKey,
+                              });
+                              if (0 === e.viewport.getLinesScrolled(t, true))
+                                return !!t.deltaX;
                               ((s = t.deltaY < 0 ? 0 : 1), (r = 4));
                               break;
                             default:
@@ -16881,8 +16979,9 @@
                         }
                         return { bufferElements: s, cursorElement: i };
                       }
-                      getLinesScrolled(e) {
-                        if (0 === e.deltaY || e.shiftKey) return 0;
+                      getLinesScrolled(e, mouseReporting = false) {
+                        // Shift belongs to the remote application while mouse reporting is active.
+                        if (0 === e.deltaY || (e.shiftKey && !mouseReporting)) return 0;
                         let t = this._applyScrollModifier(e.deltaY, e);
                         return (
                           e.deltaMode === WheelEvent.DOM_DELTA_PIXEL