tabby-tmux 1.0.0

package/dist/index.js

@@ -0,0 +1,4226 @@
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("@angular/core"), require("@angular/common"), require("@angular/forms"), require("tabby-core"), require("tabby-settings"), require("tabby-terminal"), require("rxjs"));
+	else if(typeof define === 'function' && define.amd)
+		define(["@angular/core", "@angular/common", "@angular/forms", "tabby-core", "tabby-settings", "tabby-terminal", "rxjs"], factory);
+	else {
+		var a = typeof exports === 'object' ? factory(require("@angular/core"), require("@angular/common"), require("@angular/forms"), require("tabby-core"), require("tabby-settings"), require("tabby-terminal"), require("rxjs")) : factory(root["@angular/core"], root["@angular/common"], root["@angular/forms"], root["tabby-core"], root["tabby-settings"], root["tabby-terminal"], root["rxjs"]);
+		for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
+	}
+})(this, (__WEBPACK_EXTERNAL_MODULE__angular_core__, __WEBPACK_EXTERNAL_MODULE__angular_common__, __WEBPACK_EXTERNAL_MODULE__angular_forms__, __WEBPACK_EXTERNAL_MODULE_tabby_core__, __WEBPACK_EXTERNAL_MODULE_tabby_settings__, __WEBPACK_EXTERNAL_MODULE_tabby_terminal__, __WEBPACK_EXTERNAL_MODULE_rxjs__) => {
+return /******/ (() => { // webpackBootstrap
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!./node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./src/components/settings.component.scss"
+/*!***************************************************************************************************************************************************************************************************************************************************!*\
+  !*** ./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!./node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./src/components/settings.component.scss ***!
+  \***************************************************************************************************************************************************************************************************************************************************/
+(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/sourceMaps.js");
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/api.js */ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/api.js");
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
+// Imports
+
+
+var ___CSS_LOADER_EXPORT___ = _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
+// Module
+___CSS_LOADER_EXPORT___.push([module.id, `.tmux-settings-tab .tmux-table {
+  width: 100%;
+  display: table;
+  border-spacing: 0px 20px;
+}
+.tmux-settings-tab .tmux-table .row {
+  width: 100%;
+  display: table-row;
+}
+.tmux-settings-tab .tmux-table .row .header {
+  padding: 0;
+  width: 12em;
+  display: table-cell;
+}
+.tmux-settings-tab .tmux-table .row .form-control {
+  width: 100%;
+  display: table-cell;
+}`, "",{"version":3,"sources":["webpack://./src/components/settings.component.scss"],"names":[],"mappings":"AACE;EACE,WAAA;EACA,cAAA;EACA,wBAAA;AAAJ;AACI;EACE,WAAA;EACA,kBAAA;AACN;AAAM;EACE,UAAA;EACA,WAAA;EACA,mBAAA;AAER;AAAM;EACE,WAAA;EACA,mBAAA;AAER","sourcesContent":[".tmux-settings-tab {\n  .tmux-table {\n    width: 100%;\n    display: table;\n    border-spacing: 0px 20px;\n    .row {\n      width: 100%;\n      display: table-row;\n      .header {\n        padding: 0;\n        width: 12em;\n        display: table-cell;\n      }\n      .form-control {\n        width: 100%;\n        display: table-cell;\n      }\n    }\n  }\n}\n"],"sourceRoot":""}]);
+// Exports
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
+
+
+/***/ },
+
+/***/ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!./node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./src/components/tmuxPaneTab.component.scss"
+/*!******************************************************************************************************************************************************************************************************************************************************!*\
+  !*** ./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!./node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./src/components/tmuxPaneTab.component.scss ***!
+  \******************************************************************************************************************************************************************************************************************************************************/
+(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/sourceMaps.js */ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/sourceMaps.js");
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../../node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/api.js */ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/api.js");
+/* harmony import */ var _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
+// Imports
+
+
+var ___CSS_LOADER_EXPORT___ = _node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_pnpm_css_loader_7_1_2_webpack_5_104_1_node_modules_css_loader_dist_runtime_sourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
+// Module
+___CSS_LOADER_EXPORT___.push([module.id, `@charset "UTF-8";
+/*
+ * TmuxPaneTab — full CSS control over the terminal content area.
+ *
+ * BaseTerminalTabComponent applies a "spaciness" margin that shrinks the
+ * content box, which clips edge characters and makes size calculations
+ * harder.  tmux owns the cell grid, so we zero out every spacing property
+ * so the pane occupies 100 % of its allocated container — pixel-accurate
+ * and no rounding surprises.
+ *
+ * Uniform 4px padding on all sides gives consistent visual breathing room.
+ * The scrollbar is hidden to remove the asymmetric right-side gap and
+ * simplify size math; scrolling is handled by Tabby's local history buffer.
+ * Padding is subtracted in measureClientSize() so tmux grid calculations
+ * remain accurate.
+ */
+:host > .content {
+  margin: 0;
+  padding: 4px;
+  border: 0;
+  box-sizing: border-box;
+}
+
+/* Hide xterm scrollbar — tmux handles scrolling via Control Mode protocol */
+:host ::ng-deep .xterm {
+  overflow: hidden !important;
+}
+
+:host ::ng-deep .xterm-viewport {
+  overflow-y: hidden !important;
+}`, "",{"version":3,"sources":["webpack://./src/components/tmuxPaneTab.component.scss"],"names":[],"mappings":"AAAA,gBAAgB;AAAhB;;;;;;;;;;;;;;EAAA;AAeA;EACI,SAAA;EACA,YAAA;EACA,SAAA;EACA,sBAAA;AAEJ;;AACA,4EAAA;AACA;EACI,2BAAA;AAEJ;;AAAA;EACI,6BAAA;AAGJ","sourcesContent":["/*\n * TmuxPaneTab — full CSS control over the terminal content area.\n *\n * BaseTerminalTabComponent applies a \"spaciness\" margin that shrinks the\n * content box, which clips edge characters and makes size calculations\n * harder.  tmux owns the cell grid, so we zero out every spacing property\n * so the pane occupies 100 % of its allocated container — pixel-accurate\n * and no rounding surprises.\n *\n * Uniform 4px padding on all sides gives consistent visual breathing room.\n * The scrollbar is hidden to remove the asymmetric right-side gap and\n * simplify size math; scrolling is handled by Tabby's local history buffer.\n * Padding is subtracted in measureClientSize() so tmux grid calculations\n * remain accurate.\n */\n:host > .content {\n    margin: 0;\n    padding: 4px;\n    border: 0;\n    box-sizing: border-box;\n}\n\n/* Hide xterm scrollbar — tmux handles scrolling via Control Mode protocol */\n:host ::ng-deep .xterm {\n    overflow: hidden !important;\n}\n:host ::ng-deep .xterm-viewport {\n    overflow-y: hidden !important;\n}\n"],"sourceRoot":""}]);
+// Exports
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
+
+
+/***/ },
+
+/***/ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/api.js"
+/*!*********************************************************************************************************!*\
+  !*** ./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/api.js ***!
+  \*********************************************************************************************************/
+(module) {
+
+"use strict";
+
+
+/*
+  MIT License http://www.opensource.org/licenses/mit-license.php
+  Author Tobias Koppers @sokra
+*/
+module.exports = function (cssWithMappingToString) {
+  var list = [];
+
+  // return the list of modules as css string
+  list.toString = function toString() {
+    return this.map(function (item) {
+      var content = "";
+      var needLayer = typeof item[5] !== "undefined";
+      if (item[4]) {
+        content += "@supports (".concat(item[4], ") {");
+      }
+      if (item[2]) {
+        content += "@media ".concat(item[2], " {");
+      }
+      if (needLayer) {
+        content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
+      }
+      content += cssWithMappingToString(item);
+      if (needLayer) {
+        content += "}";
+      }
+      if (item[2]) {
+        content += "}";
+      }
+      if (item[4]) {
+        content += "}";
+      }
+      return content;
+    }).join("");
+  };
+
+  // import a list of modules into the list
+  list.i = function i(modules, media, dedupe, supports, layer) {
+    if (typeof modules === "string") {
+      modules = [[null, modules, undefined]];
+    }
+    var alreadyImportedModules = {};
+    if (dedupe) {
+      for (var k = 0; k < this.length; k++) {
+        var id = this[k][0];
+        if (id != null) {
+          alreadyImportedModules[id] = true;
+        }
+      }
+    }
+    for (var _k = 0; _k < modules.length; _k++) {
+      var item = [].concat(modules[_k]);
+      if (dedupe && alreadyImportedModules[item[0]]) {
+        continue;
+      }
+      if (typeof layer !== "undefined") {
+        if (typeof item[5] === "undefined") {
+          item[5] = layer;
+        } else {
+          item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
+          item[5] = layer;
+        }
+      }
+      if (media) {
+        if (!item[2]) {
+          item[2] = media;
+        } else {
+          item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
+          item[2] = media;
+        }
+      }
+      if (supports) {
+        if (!item[4]) {
+          item[4] = "".concat(supports);
+        } else {
+          item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
+          item[4] = supports;
+        }
+      }
+      list.push(item);
+    }
+  };
+  return list;
+};
+
+/***/ },
+
+/***/ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/sourceMaps.js"
+/*!****************************************************************************************************************!*\
+  !*** ./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/runtime/sourceMaps.js ***!
+  \****************************************************************************************************************/
+(module) {
+
+"use strict";
+
+
+module.exports = function (item) {
+  var content = item[1];
+  var cssMapping = item[3];
+  if (!cssMapping) {
+    return content;
+  }
+  if (typeof btoa === "function") {
+    var base64 = btoa(unescape(encodeURIComponent(JSON.stringify(cssMapping))));
+    var data = "sourceMappingURL=data:application/json;charset=utf-8;base64,".concat(base64);
+    var sourceMapping = "/*# ".concat(data, " */");
+    return [content].concat([sourceMapping]).join("\n");
+  }
+  return [content].join("\n");
+};
+
+/***/ },
+
+/***/ "./src/components/settings.component.scss"
+/*!************************************************!*\
+  !*** ./src/components/settings.component.scss ***!
+  \************************************************/
+(module, __unused_webpack_exports, __webpack_require__) {
+
+
+        var result = __webpack_require__(/*! !!../../node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!../../node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./settings.component.scss */ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!./node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./src/components/settings.component.scss");
+
+        if (result && result.__esModule) {
+            result = result.default;
+        }
+
+        if (typeof result === "string") {
+            module.exports = result;
+        } else {
+            module.exports = result.toString();
+        }
+    
+
+/***/ },
+
+/***/ "./src/components/settings.component.ts"
+/*!**********************************************!*\
+  !*** ./src/components/settings.component.ts ***!
+  \**********************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxSettingsTabComponent = void 0;
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const tabby_core_1 = __webpack_require__(/*! tabby-core */ "tabby-core");
+// eslint-disable-next-line new-cap
+let TmuxSettingsTabComponent = class TmuxSettingsTabComponent {
+    constructor(config) {
+        this.config = config;
+    }
+};
+TmuxSettingsTabComponent.ctorParameters = () => [
+    { type: tabby_core_1.ConfigService }
+];
+TmuxSettingsTabComponent = __decorate([
+    (0, core_1.Component)({
+        template: `
+        <h3>Tmux</h3>
+        <div class="tmux-settings-tab">
+            <div class="tmux-table">
+                <div class="row">
+                    <div class="header"><div class="title">Default session name:</div></div>
+                    <input class="form-control" type="text"
+                        [(ngModel)]="config.store.tmuxPlugin.defaultSessionName"
+                        (ngModelChange)="config.save()">
+                </div>
+                <div class="row">
+                    <div class="header"><div class="title">Command timeout (ms):</div></div>
+                    <input class="form-control" type="number"
+                        [(ngModel)]="config.store.tmuxPlugin.commandTimeoutMs"
+                        (ngModelChange)="config.save()">
+                </div>
+                <div class="row">
+                    <div class="header"><div class="title">Send-keys chunk size:</div></div>
+                    <input class="form-control" type="number"
+                        [(ngModel)]="config.store.tmuxPlugin.sendKeysChunkSize"
+                        (ngModelChange)="config.save()">
+                </div>
+                <div class="row">
+                    <div class="header"><div class="title">Resize debounce (ms):</div></div>
+                    <input class="form-control" type="number"
+                        [(ngModel)]="config.store.tmuxPlugin.resizeDebounceMs"
+                        (ngModelChange)="config.save()">
+                </div>
+                <div class="row">
+                    <div class="header"><div class="title">Debug logging:</div></div>
+                    <input type="checkbox"
+                        [(ngModel)]="config.store.tmuxPlugin.debugLogging"
+                        (ngModelChange)="config.save()">
+                </div>
+            </div>
+        </div>
+    `,
+        styles: [__webpack_require__(/*! ./settings.component.scss */ "./src/components/settings.component.scss")]
+    }),
+    __metadata("design:paramtypes", [tabby_core_1.ConfigService])
+], TmuxSettingsTabComponent);
+exports.TmuxSettingsTabComponent = TmuxSettingsTabComponent;
+
+
+/***/ },
+
+/***/ "./src/components/tmuxPaneTab.component.scss"
+/*!***************************************************!*\
+  !*** ./src/components/tmuxPaneTab.component.scss ***!
+  \***************************************************/
+(module, __unused_webpack_exports, __webpack_require__) {
+
+
+        var result = __webpack_require__(/*! !!../../node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!../../node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./tmuxPaneTab.component.scss */ "./node_modules/.pnpm/css-loader@7.1.2_webpack@5.104.1/node_modules/css-loader/dist/cjs.js!./node_modules/.pnpm/sass-loader@16.0.6_sass@1.97.2_webpack@5.104.1/node_modules/sass-loader/dist/cjs.js!./src/components/tmuxPaneTab.component.scss");
+
+        if (result && result.__esModule) {
+            result = result.default;
+        }
+
+        if (typeof result === "string") {
+            module.exports = result;
+        } else {
+            module.exports = result.toString();
+        }
+    
+
+/***/ },
+
+/***/ "./src/components/tmuxPaneTab.component.ts"
+/*!*************************************************!*\
+  !*** ./src/components/tmuxPaneTab.component.ts ***!
+  \*************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxPaneTabComponent = void 0;
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const rxjs_1 = __webpack_require__(/*! rxjs */ "rxjs");
+const tabby_terminal_1 = __webpack_require__(/*! tabby-terminal */ "tabby-terminal");
+const session_1 = __webpack_require__(/*! ../session */ "./src/session.ts");
+let TmuxPaneTabComponent = class TmuxPaneTabComponent extends tabby_terminal_1.BaseTerminalTabComponent {
+    constructor(injector) {
+        super(injector);
+        /**
+         * Whether this pane is the active (keyboard-focused) pane in the tmux session.
+         * Controls whether hotkey-triggered input (e.g. Ctrl+C, paste) is forwarded.
+         *
+         * All tmux pane tabs have `hasFocus = true` simultaneously (needed for
+         * xterm frontend initialization), but only one pane should process hotkeys.
+         * This flag is managed by TmuxSessionTabComponent.focus().
+         */
+        this._tmuxActive = true;
+        /**
+         * When true, input is broadcast to all panes in the tmux session
+         * ("Focus all tmux panes" / synchronize-panes mode).
+         * Toggled via the right-click context menu.
+         */
+        this._tmuxSyncInput = false;
+        /** Desired tmux grid size (chars). tmux is authoritative over the cell grid. */
+        this._tmuxCols = 0;
+        this._tmuxRows = 0;
+        /** Whether the xterm frontend has been attached and is ready. */
+        this._frontendReady = false;
+    }
+    ngOnInit() {
+        // Profile must be set BEFORE calling super.ngOnInit() because
+        // the parent class configures the terminal frontend using profile settings
+        this.profile = {
+            name: `Tmux Pane %${this.paneId}`,
+            type: 'tmux',
+            options: {},
+            // Required properties for BaseTerminalTabComponent
+            behaviorOnSessionEnd: 'close',
+            terminalColorScheme: null, // Use default
+        };
+        this.setTitle(`Pane %${this.paneId}`);
+        // Now call parent's ngOnInit to set up the frontend.
+        // NOTE: super.ngOnInit() schedules a setImmediate that checks
+        // this.hasFocus to decide whether to attach the xterm frontend.
+        // BaseTabComponent sets hasFocus=true on focused$.next().
+        // We emit focus synchronously right after super.ngOnInit() so that
+        // when setImmediate fires, hasFocus is already true.
+        super.ngOnInit();
+        // Mark this tab as focused so the setImmediate in super.ngOnInit
+        // will attach the frontend to the DOM element.
+        // This is safe because our overridden focus() doesn't blur siblings.
+        this.emitFocused();
+        // Initialize our session AFTER emitting focus, so that:
+        // 1. frontend.attach() runs via setImmediate (because hasFocus=true)
+        // 2. frontend.resize$ fires, which triggers releaseInitialDataBuffer()
+        // 3. Then session.start() populates the buffer and it gets released
+        //
+        // The key insight: setImmediate fires before our async session.start(),
+        // so the frontend is attached before history restore begins. This means
+        // history output goes directly to the terminal, not into a buffer that
+        // gets flushed in a bulk dump.
+        this.initializeSession();
+        // tmux owns the cell grid. Once the frontend is ready, neutralize
+        // xterm's automatic fit-to-container so the pane never overrides the
+        // tmux-dictated grid with its own (pixel-rounded) size — that mismatch
+        // is what causes off-by-one wrapping / cursor errors. The grid is set
+        // explicitly via setTmuxGrid() from the layout sync instead.
+        this.frontendReady$.pipe((0, rxjs_1.first)()).subscribe(() => {
+            this._frontendReady = true;
+            const frontend = this.frontend;
+            if (frontend) {
+                frontend.enableResizing = false;
+                // The frontend's resizeHandler (window resize + ResizeObserver)
+                // calls fitAddon.fit() unconditionally and ignores enableResizing.
+                // Replace fit() with a no-op so the grid stays exactly what tmux
+                // tells us. Keep a reference in case we ever need to restore it.
+                if (frontend.fitAddon && typeof frontend.fitAddon.fit === 'function') {
+                    frontend.fitAddon.fit = () => { };
+                }
+            }
+            // Apply any grid size that arrived before the frontend was ready.
+            if (this._tmuxCols > 0 && this._tmuxRows > 0) {
+                this.applyTmuxGrid();
+            }
+        });
+    }
+    /**
+     * Set the authoritative cell grid for this pane, as dictated by the tmux
+     * layout string. tmux decides each pane's exact character width/height, so
+     * we resize the xterm grid to match instead of letting xterm fit to pixels.
+     * This keeps wrapping aligned with tmux and removes the resize feedback loop.
+     */
+    setTmuxGrid(cols, rows) {
+        if (cols <= 0 || rows <= 0)
+            return;
+        if (cols === this._tmuxCols && rows === this._tmuxRows)
+            return;
+        this._tmuxCols = cols;
+        this._tmuxRows = rows;
+        if (this._frontendReady) {
+            this.applyTmuxGrid();
+        }
+    }
+    applyTmuxGrid() {
+        var _a;
+        const xterm = (_a = this.frontend) === null || _a === void 0 ? void 0 : _a.xterm;
+        if (!xterm)
+            return;
+        if (xterm.cols === this._tmuxCols && xterm.rows === this._tmuxRows)
+            return;
+        try {
+            xterm.resize(this._tmuxCols, this._tmuxRows);
+        }
+        catch (e) {
+            this.logger.warn(`Failed to resize pane %${this.paneId} grid`, e);
+        }
+        // xterm.resize() clears the alternate screen buffer.
+        // Re-apply saved alternate content if this pane was on it.
+        const session = this.session;
+        if ((session === null || session === void 0 ? void 0 : session.pendingAltRestore) && this.controller) {
+            this.controller.reapplyAltContent(session);
+        }
+    }
+    async initializeSession() {
+        if (!this.controller) {
+            throw new Error('Tmux controller not provided to pane tab');
+        }
+        // Create the pane session
+        const paneSession = new session_1.TmuxPaneSession(this.logger, this.controller, this.paneId);
+        // Set up the terminal session first so the frontend is wired.
+        // This binds session.output$ → this.write() and frontend → session.
+        this.setSession(paneSession, true);
+        // Start the session (restores history) non-blocking.
+        // History is written to the terminal via emitOutput → write().
+        paneSession.start();
+    }
+    /**
+     * Guard sendInput so that only the active pane forwards hotkey-triggered
+     * input (Ctrl+C, Home, End, etc.) to its tmux session.
+     *
+     * When _tmuxSyncInput is enabled ("Focus all tmux panes"), input is also
+     * broadcast to all other panes in the session.
+     */
+    sendInput(data) {
+        if (!this._tmuxActive) {
+            return;
+        }
+        super.sendInput(data);
+        // Broadcast to all other panes when sync mode is active
+        if (this._tmuxSyncInput && this.controller) {
+            const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+            for (const pid of this.controller.getAllPaneIds()) {
+                if (pid !== this.paneId) {
+                    this.controller.writeToPane(pid, buf);
+                }
+            }
+        }
+    }
+    /**
+     * Guard paste so that only the active pane pastes into its tmux session.
+     */
+    async paste() {
+        if (!this._tmuxActive) {
+            return;
+        }
+        return super.paste();
+    }
+    /**
+     * Always allow closing a tmux pane tab without showing the
+     * "command is still running" confirmation dialog.
+     * The tmux server process is not a user command — lifetime is
+     * managed separately by TmuxService/TmuxController.
+     */
+    async canClose() {
+        return true;
+    }
+    // Override generic title behavior
+    getCustomTitle() {
+        return `Tmux Pane %${this.paneId}`;
+    }
+    /**
+     * Override the native context menu to provide tmux-specific items only.
+     * Keeps: Copy, Paste, Close (pane).
+     * Adds: Exit Tmux Mode, Split submenu, Focus all tmux panes.
+     */
+    async buildContextMenu() {
+        const items = [
+            {
+                label: this.translate.instant('Copy'),
+                click: () => { var _a; return (_a = this.frontend) === null || _a === void 0 ? void 0 : _a.copySelection(); },
+            },
+            {
+                label: this.translate.instant('Paste'),
+                click: () => this.paste(),
+            },
+            { type: 'separator' },
+            {
+                label: this.translate.instant('Split'),
+                submenu: [
+                    { label: this.translate.instant('Right'), click: () => this.splitPane('right') },
+                    { label: this.translate.instant('Down'), click: () => this.splitPane('down') },
+                    { label: this.translate.instant('Left'), click: () => this.splitPane('left') },
+                    { label: this.translate.instant('Up'), click: () => this.splitPane('up') },
+                ],
+            },
+            {
+                label: this.translate.instant('Focus all tmux panes'),
+                type: 'checkbox',
+                checked: this._tmuxSyncInput,
+                click: () => this.toggleSyncInput(),
+            },
+            { type: 'separator' },
+            {
+                label: this.translate.instant('Close'),
+                click: () => this.closePane(),
+            },
+        ];
+        return items;
+    }
+    async handleRightMouseDown(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.platform.popupContextMenu(await this.buildContextMenu(), event);
+    }
+    async splitPane(direction) {
+        if (!this.controller)
+            return;
+        const flagMap = {
+            'right': '-h',
+            'down': '-v',
+            'left': '-h -b',
+            'up': '-v -b',
+        };
+        await this.controller.gateway.sendCommand(`split-window ${flagMap[direction]} -t %${this.paneId}`);
+        // No explicit refresh needed — the %layout-change notification
+        // from tmux will trigger discoverPanesFromLayout() in TmuxController,
+        // which discovers the new pane and emits pane-add with pre-loaded
+        // history (iTerm2-style).
+    }
+    async closePane() {
+        if (!this.controller)
+            return;
+        await this.controller.killPane(this.paneId);
+    }
+    /**
+     * Toggle "Focus all tmux panes" (synchronize input) across all panes
+     * in the current tmux session.
+     */
+    toggleSyncInput() {
+        if (!this.controller)
+            return;
+        const newValue = !this._tmuxSyncInput;
+        for (const pid of this.controller.getAllPaneIds()) {
+            const tab = this.findPaneTab(pid);
+            if (tab) {
+                tab._tmuxSyncInput = newValue;
+            }
+        }
+    }
+    findPaneTab(paneId) {
+        // Walk the session tab's window pane map to find the tab
+        const parent = this.parent;
+        if (parent === null || parent === void 0 ? void 0 : parent.windowPaneTabs) {
+            for (const paneMap of parent.windowPaneTabs.values()) {
+                const tab = paneMap.get(paneId);
+                if (tab)
+                    return tab;
+            }
+        }
+        return null;
+    }
+};
+TmuxPaneTabComponent.ctorParameters = () => [
+    { type: core_1.Injector }
+];
+TmuxPaneTabComponent.propDecorators = {
+    controller: [{ type: core_1.Input }],
+    paneId: [{ type: core_1.Input }]
+};
+TmuxPaneTabComponent = __decorate([
+    (0, core_1.Component)({
+        selector: 'tmux-pane-tab',
+        template: tabby_terminal_1.BaseTerminalTabComponent.template,
+        animations: tabby_terminal_1.BaseTerminalTabComponent.animations,
+        styles: [...tabby_terminal_1.BaseTerminalTabComponent.styles,
+            __webpack_require__(/*! ./tmuxPaneTab.component.scss */ "./src/components/tmuxPaneTab.component.scss")]
+    }),
+    __metadata("design:paramtypes", [core_1.Injector])
+], TmuxPaneTabComponent);
+exports.TmuxPaneTabComponent = TmuxPaneTabComponent;
+
+
+/***/ },
+
+/***/ "./src/components/tmuxSessionTab.component.ts"
+/*!****************************************************!*\
+  !*** ./src/components/tmuxSessionTab.component.ts ***!
+  \****************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var TmuxSessionTabComponent_1;
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxSessionTabComponent = void 0;
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const tabby_core_1 = __webpack_require__(/*! tabby-core */ "tabby-core");
+const tabby_core_2 = __webpack_require__(/*! tabby-core */ "tabby-core");
+const session_1 = __webpack_require__(/*! ../session */ "./src/session.ts");
+const tmux_service_1 = __webpack_require__(/*! ../services/tmux.service */ "./src/services/tmux.service.ts");
+const tmuxPaneTab_component_1 = __webpack_require__(/*! ./tmuxPaneTab.component */ "./src/components/tmuxPaneTab.component.ts");
+const layoutParser_1 = __webpack_require__(/*! ../layoutParser */ "./src/layoutParser.ts");
+/**
+ * TmuxSessionTabComponent - Manages an entire tmux session within a single Tabby tab.
+ *
+ * Each tmux window is represented by its pane tabs, which are hidden/shown via
+ * removeTab()/addTab() when switching windows. The bottom window bar provides
+ * window switching UI.
+ *
+ * Always created by TmuxService.attachToTerminal() with existingController set.
+ */
+let TmuxSessionTabComponent = TmuxSessionTabComponent_1 = class TmuxSessionTabComponent extends tabby_core_1.SplitTabComponent {
+    constructor(injector, tmuxService, configService, tabsService, cdr, hostElement, log) {
+        super(injector.get(tabby_core_1.HotkeysService), tabsService, injector.get(tabby_core_2.TabRecoveryService), injector);
+        this.tmuxService = tmuxService;
+        this.configService = configService;
+        this.cdr = cdr;
+        this.hostElement = hostElement;
+        this.profile = {};
+        this.eventSubscription = null;
+        // windowId → (paneId → paneTab)
+        this.windowPaneTabs = new Map();
+        /** Queue for serializing async event processing */
+        this.eventQueue = Promise.resolve();
+        this.controller = null;
+        this.activeWindowId = null;
+        this.connected = false;
+        this.sessionName = '';
+        this._initialized = false;
+        this._resizeHandler = null;
+        this._resizeTimer = null;
+        this._paneAreaObserver = null;
+        /** Last dimensions sent to tmux, for dedup */
+        this._lastSentCols = 0;
+        this._lastSentRows = 0;
+        /** Custom tmux pane dividers — kept for interface compatibility but not rendered */
+        this._tmuxDividers = [];
+        /** mousedown handler attached to .pane-area for border drag detection */
+        this._paneAreaMouseDownHandler = null;
+        /** mousemove handler for border hover highlight */
+        this._paneAreaMouseMoveHandler = null;
+        this._tabsService = tabsService;
+        this.logger = log.create('tmux-session');
+    }
+    ngOnInit() {
+        this.logger.info('ngOnInit initialized');
+        this.controller = this.existingController;
+        if (!this.controller) {
+            this.logger.error('No controller provided');
+            return;
+        }
+        this.sessionName = this.controller.getSessionName() || this.profile.sessionName || 'default';
+        this.setTitle(`Tmux: ${this.sessionName}`);
+        // Subscribe to controller events.
+        // Events are queued to ensure serial async processing — critical because
+        // handleControllerEvent contains async operations (switchToWindow, syncLayout)
+        // that must not interleave. Without serialization, concurrent switches from
+        // multiple window-add events (during refreshPanes) corrupt activeWindowId.
+        this.eventSubscription = this.controller.events.subscribe(event => {
+            this.eventQueue = this.eventQueue.then(() => this.handleControllerEvent(event));
+        });
+        // Bootstrap from current controller snapshot in case early events were missed
+        this.bootstrapFromControllerState();
+    }
+    /**
+     * Called after the view is initialized.
+     * The parent SplitTabComponent has finished its own ngAfterViewInit
+     * (including recoverContainer if any), so #vc is ready.
+     */
+    async ngAfterViewInit() {
+        await super.ngAfterViewInit();
+        if (!this.controller)
+            return;
+        // Wait one more frame to ensure the wrapper's attachTabView
+        // has finished inserting us into its ViewContainerRef
+        requestAnimationFrame(async () => {
+            this._initialized = true;
+            await this.controller.refreshPanes();
+            this.bootstrapFromControllerState();
+            // Wait for all queued events (window-add, pane-add) from refreshPanes
+            // to be processed before switching to the first window.
+            await this.eventQueue;
+            // Prefer the tmux-side active window (from list-windows #{window_active}
+            // or %session-window-changed). Fall back to the first window in the map.
+            const activeWindowId = this.controller.getActiveWindowId();
+            const targetWindowId = (activeWindowId !== null && this.windowPaneTabs.has(activeWindowId))
+                ? activeWindowId
+                : this.controller.getFirstWindowId();
+            if (targetWindowId !== undefined) {
+                await this.switchToWindow(targetWindowId);
+            }
+            // Listen for window resize events (like iTerm2's windowDidResize).
+            // Only fires when the browser window changes size, not during
+            // internal SplitTab layout operations. Debounced to avoid flooding.
+            this._resizeHandler = () => this.scheduleRefreshClientSize();
+            window.addEventListener('resize', this._resizeHandler);
+            // Observe the .pane-area container directly. This is the single
+            // source of truth for the client size: any time the container's
+            // pixel size changes (window resize, spanner drag, sidebar toggle,
+            // first mount), we recompute and push the whole-window grid to tmux.
+            // Per-pane xterm fit is disabled, so this never feeds back.
+            const host = this.hostElement.nativeElement;
+            const paneArea = host.querySelector('.pane-area');
+            if (paneArea && typeof ResizeObserver !== 'undefined') {
+                this._paneAreaObserver = new ResizeObserver(() => this.scheduleRefreshClientSize());
+                this._paneAreaObserver.observe(paneArea);
+            }
+            // Attach border hover + drag handlers to the pane-area
+            this.attachPaneAreaBorderHandlers();
+            // Initial size sync after pane mount
+            this.scheduleRefreshClientSize();
+        });
+    }
+    bootstrapFromControllerState() {
+        if (!this.controller) {
+            return;
+        }
+        // Prime local maps from controller state so UI can render even if
+        // window-add / pane-add events happened before this component subscribed.
+        // This is critical: discoverWindowsAndPanes() emits window-add and pane-add
+        // during the first call (triggered by session-changed), but the SessionTab
+        // component may not exist yet. By the time ngOnInit runs, the controller
+        // already knows about all windows and panes — we must create pane tabs
+        // here so switchToWindow finds non-empty paneMaps.
+        for (const windowState of this.controller.getAllWindowStates()) {
+            if (!this.windowPaneTabs.has(windowState.id)) {
+                this.windowPaneTabs.set(windowState.id, new Map());
+            }
+            // Create pane tabs for all panes the controller already knows about
+            const paneMap = this.windowPaneTabs.get(windowState.id);
+            const ctrlWindowState = this.controller.getWindowState(windowState.id);
+            if (ctrlWindowState) {
+                for (const paneId of ctrlWindowState.panes) {
+                    if (!paneMap.has(paneId)) {
+                        this.logger.info(`Bootstrap: creating pane tab for %${paneId} in window @${windowState.id}`);
+                        const paneTab = this.createPaneTab(paneId);
+                        paneTab.controller = this.controller;
+                        paneTab.paneId = paneId;
+                        paneMap.set(paneId, paneTab);
+                    }
+                }
+            }
+        }
+        if (this.controller.isAttached) {
+            this.connected = true;
+        }
+        this.cdr.detectChanges();
+    }
+    async handleControllerEvent(event) {
+        var _a, _b;
+        this.logger.info('SessionTab event:', event.type, event);
+        switch (event.type) {
+            case 'initialized':
+            case 'session-changed':
+                this.connected = true;
+                this.sessionName = ((_a = this.controller) === null || _a === void 0 ? void 0 : _a.getSessionName()) || this.profile.sessionName || 'default';
+                this.setTitle(`Tmux: ${this.sessionName}`);
+                this.cdr.detectChanges();
+                break;
+            case 'window-add':
+                if (event.windowId !== undefined) {
+                    const isNewWindow = !this.windowPaneTabs.has(event.windowId);
+                    // Ensure the window has an entry in our map
+                    if (isNewWindow) {
+                        this.logger.info(`Adding new window @${event.windowId} to map`);
+                        this.windowPaneTabs.set(event.windowId, new Map());
+                    }
+                    // Switch to a new window if:
+                    // 1. No active window yet (initial attach), OR
+                    // 2. This is a genuinely new window created after attach
+                    //    AND we are past the initial bootstrap phase.
+                    //    During batch discovery, we defer switching to ngAfterViewInit.
+                    //
+                    // MUST await: switchToWindow is async and rebuilds the SplitContainer
+                    // tree. Without await, concurrent switches from multiple window-add
+                    // events (during refreshPanes) interleave and corrupt activeWindowId.
+                    if (this._initialized && this.activeWindowId === null) {
+                        this.logger.info(`Switching to first window @${event.windowId}`);
+                        await this.switchToWindow(event.windowId);
+                    }
+                    else if (this._initialized && isNewWindow && this.activeWindowId !== null) {
+                        // Runtime window creation (after initial attach)
+                        this.logger.info(`Switching to new runtime window @${event.windowId}`);
+                        await this.switchToWindow(event.windowId);
+                    }
+                }
+                break;
+            case 'window-close':
+                if (event.windowId !== undefined) {
+                    await this.handleWindowClose(event.windowId);
+                }
+                break;
+            case 'pane-add':
+                if (event.paneId !== undefined && event.windowId !== undefined) {
+                    this.logger.info(`Handling pane-add event: pane=${event.paneId}, window=${event.windowId}`);
+                    await this.handlePaneAdd(event.paneId, event.windowId);
+                }
+                break;
+            case 'pane-update':
+                if (event.paneId !== undefined && event.windowId !== undefined) {
+                    // Pane might have moved to a different window
+                    this.logger.info(`Handling pane-update event: pane=${event.paneId}, window=${event.windowId}`);
+                    await this.handlePaneUpdate(event.paneId, event.windowId);
+                }
+                break;
+            case 'pane-close':
+                if (event.paneId !== undefined && event.windowId !== undefined) {
+                    this.logger.info(`Handling pane-close event: pane=${event.paneId}, window=${event.windowId}`);
+                    this.handlePaneClose(event.paneId, event.windowId);
+                }
+                break;
+            case 'layout-change':
+                // NOTE: We always call syncLayout for the active window.
+                // For non-active windows, we save the layout but don't rebuild
+                // the tree (it will be rebuilt when the user switches to it).
+                if (event.windowId !== undefined && ((_b = event.data) === null || _b === void 0 ? void 0 : _b.layout)) {
+                    if (event.windowId === this.activeWindowId) {
+                        this.logger.info(`Syncing layout for active window @${event.windowId}`);
+                        await this.syncLayout(event.data.layout);
+                    }
+                    else {
+                        this.logger.info(`Layout changed for inactive window @${event.windowId}, saved for next switch`);
+                    }
+                }
+                break;
+            case 'exit':
+                this.connected = false;
+                this.cdr.detectChanges();
+                break;
+        }
+    }
+    /**
+     * Switch to a different tmux window.
+     * Hides current window's panes and shows target window's panes.
+     */
+    async switchToWindow(windowId) {
+        var _a, _b;
+        if (windowId === this.activeWindowId)
+            return;
+        this.logger.info(`Switching to window @${windowId}`);
+        // Clear dividers while switching windows
+        this._tmuxDividers = [];
+        // 1. Detach current active window's pane views (don't use removeTab —
+        //    SplitTabComponent.removeTab destroys the tab when root.children
+        //    becomes empty). Instead, clear the root directly.
+        if (this.activeWindowId !== null) {
+            const paneMap = this.windowPaneTabs.get(this.activeWindowId);
+            if (paneMap) {
+                this.logger.info(`Detaching ${paneMap.size} pane(s) for window @${this.activeWindowId}`);
+                for (const paneTab of paneMap.values()) {
+                    paneTab.emitVisibility(false);
+                    this.detachPaneView(paneTab);
+                }
+            }
+        }
+        // 2. Update active window
+        this.activeWindowId = windowId;
+        // 3. Ensure pane tabs exist for this window
+        if (!this.windowPaneTabs.has(windowId)) {
+            this.windowPaneTabs.set(windowId, new Map());
+        }
+        const paneMap = this.windowPaneTabs.get(windowId);
+        if (paneMap.size === 0) {
+            // First time visiting this window. Pane tabs will be created by
+            // handlePaneAdd (triggered by discoverPanesFromLayout on
+            // %layout-change). We don't call addPanesForWindow — panes are
+            // discovered asynchronously (iTerm2-style).
+            //
+            // HOWEVER: if the controller already knows the layout for this
+            // window (from batch discovery during attach), we can proactively
+            // discover panes from it instead of waiting for a layout-change
+            // event that may never come (tmux doesn't re-send layout-change
+            // for windows that haven't changed).
+            const windowState = (_a = this.controller) === null || _a === void 0 ? void 0 : _a.getWindowState(windowId);
+            if (windowState === null || windowState === void 0 ? void 0 : windowState.layout) {
+                this.logger.info(`No pane tabs yet for window @${windowId}, but layout is known — discovering panes proactively`);
+                // Extract pane IDs from the known layout and create pane tabs
+                const { parseTmuxLayout, flattenLayout } = await Promise.resolve().then(() => __importStar(__webpack_require__(/*! ../layoutParser */ "./src/layoutParser.ts")));
+                const layoutTree = parseTmuxLayout(windowState.layout);
+                if (layoutTree) {
+                    for (const pane of flattenLayout(layoutTree)) {
+                        if (!paneMap.has(pane.paneId)) {
+                            this.logger.info(`Proactively creating pane tab for %${pane.paneId} in window @${windowId}`);
+                            const paneTab = this.createPaneTab(pane.paneId);
+                            paneTab.controller = this.controller;
+                            paneTab.paneId = pane.paneId;
+                            paneMap.set(pane.paneId, paneTab);
+                        }
+                    }
+                }
+            }
+            else {
+                this.logger.info(`No pane tabs yet for window @${windowId}, waiting for pane-add events`);
+            }
+        }
+        else {
+            this.logger.info(`Mounting existing ${paneMap.size} pane(s) for window @${windowId}`);
+        }
+        // 4. Rebuild SplitContainer tree with this window's panes
+        this.root = new tabby_core_1.SplitContainer();
+        this.root.orientation = 'h';
+        const paneTabs = Array.from(paneMap.values());
+        if (paneTabs.length > 0) {
+            this.logger.info(`Adding ${paneTabs.length} pane tab(s) to SplitTab`);
+            for (let i = 0; i < paneTabs.length; i++) {
+                const paneTab = paneTabs[i];
+                if (i === 0) {
+                    await this.addTab(paneTab, null, 'r');
+                }
+                else {
+                    await this.addTab(paneTab, paneTabs[i - 1], 'r');
+                }
+                paneTab.emitVisibility(true);
+            }
+            // 5. Sync layout from tmux
+            const windowState = (_b = this.controller) === null || _b === void 0 ? void 0 : _b.getWindowState(windowId);
+            if (windowState === null || windowState === void 0 ? void 0 : windowState.layout) {
+                this.logger.info('Syncing layout after mounting panes');
+                await this.syncLayout(windowState.layout);
+            }
+        }
+        // 6. Detect changes; precise client size refresh happens via the
+        //    .pane-area ResizeObserver once xterm renders its cell grid.
+        this.cdr.detectChanges();
+        // 7. Push the correct client size to tmux once panes are mounted.
+        //    We use requestAnimationFrame to wait for xterm to render its
+        //    character grid (getCellSize needs real cell dimensions), then
+        //    force a non-deduplicated refresh-client -C.
+        if (paneTabs.length > 0) {
+            requestAnimationFrame(() => {
+                // Reset dedup so the next call always goes through
+                this._lastSentCols = 0;
+                this._lastSentRows = 0;
+                this.refreshClientSize();
+            });
+        }
+    }
+    /**
+     * Override focus to manage which pane is the active (hotkey-target) pane.
+     *
+     * In tmux integration, all panes are visible simultaneously (split layout),
+     * so we cannot blur other tabs (that would prevent their xterm frontends
+     * from staying initialized). Instead, all pane tabs keep `hasFocus = true`
+     * for frontend initialization, and we use `TmuxPaneTabComponent._tmuxActive`
+     * to control which pane processes hotkeys.
+     */
+    focus(tab) {
+        ;
+        this.focusedTab = tab;
+        tab.emitFocused();
+        // Mark only the focused pane as active for hotkey routing.
+        // Other panes remain visible and initialized but won't process
+        // hotkey-triggered input (Ctrl+C, paste, etc.).
+        for (const t of this.getAllTabs()) {
+            if (t instanceof tmuxPaneTab_component_1.TmuxPaneTabComponent) {
+                t._tmuxActive = (t === tab);
+            }
+        }
+    }
+    /**
+     * Detach a pane tab's view from the ViewContainer without calling
+     * removeTab() which would trigger self-destruction when root empties.
+     */
+    detachPaneView(tab) {
+        var _a;
+        // Remove from root tree structure
+        const parent = this.getParentOf(tab);
+        if (parent) {
+            const index = parent.children.indexOf(tab);
+            if (index !== -1) {
+                parent.children.splice(index, 1);
+                parent.ratios.splice(index, 1);
+            }
+        }
+        // Remove the embedded view reference so layout() won't position it
+        ;
+        (_a = this.viewRefs) === null || _a === void 0 ? void 0 : _a.delete(tab);
+        tab.removeFromContainer();
+        tab.parent = null;
+    }
+    /**
+     * Override removeTab to prevent self-destruction when root.children
+     * becomes empty. In TmuxSessionTab, an empty root is normal during
+     * window switches and should not destroy the session tab.
+     */
+    removeTab(tab) {
+        var _a;
+        const parent = this.getParentOf(tab);
+        if (!parent)
+            return;
+        const index = parent.children.indexOf(tab);
+        parent.ratios.splice(index, 1);
+        parent.children.splice(index, 1);
+        tab.removeFromContainer();
+        tab.parent = null;
+        (_a = this.viewRefs) === null || _a === void 0 ? void 0 : _a.delete(tab);
+        this.layout();
+        // Do NOT destroy self when root is empty — this is normal during
+        // tmux window switches.
+    }
+    /**
+    }
+
+    /**
+     * Create a TmuxPaneTabComponent using TabsService (proper Angular DI).
+     * This ensures the component has a hostView and ViewContainerRef.
+     */
+    createPaneTab(paneId) {
+        this.logger.info(`Creating TmuxPaneTabComponent for pane %${paneId}`);
+        const tab = this._tabsService.create({
+            type: tmuxPaneTab_component_1.TmuxPaneTabComponent,
+            inputs: {
+                controller: this.controller,
+                paneId,
+            },
+        });
+        this.logger.info(`TmuxPaneTabComponent created for pane %${paneId}`);
+        return tab;
+    }
+    /**
+     * Handle a new pane being added to a window (real-time from tmux).
+     *
+     * NOTE: We do NOT call addTab here. Instead, we just register the pane in
+     * the map and let syncLayout (called from the %layout-change event that
+     * tmux sends alongside new-pane creation) build the correct tree.
+     * Calling addTab with a fixed direction ('r') would create a wrong tree
+     * structure that syncLayout then has to undo — and the async view
+     * attachment inside addTab races with syncLayout, leaving panes invisible.
+     */
+    async handlePaneAdd(paneId, windowId) {
+        if (!this.controller)
+            return;
+        let paneMap = this.windowPaneTabs.get(windowId);
+        if (!paneMap) {
+            paneMap = new Map();
+            this.windowPaneTabs.set(windowId, paneMap);
+        }
+        if (paneMap.has(paneId)) {
+            this.logger.debug(`Pane %${paneId} already tracked for window @${windowId}`);
+            return;
+        }
+        // Create the pane tab and register it — the actual tree mounting
+        // happens when syncLayout runs from the %layout-change event.
+        const paneTab = this.createPaneTab(paneId);
+        paneTab.controller = this.controller;
+        paneTab.paneId = paneId;
+        paneMap.set(paneId, paneTab);
+        this.logger.info(`Registered new pane %${paneId} for window @${windowId}, awaiting layout sync`);
+    }
+    /**
+     * Handle pane-update event (pane might have moved between windows).
+     *
+     * IMPORTANT: This method MUST NOT trigger switchToWindow or handlePaneAdd.
+     * Doing so creates an infinite loop: pane-update → switchToWindow →
+     * refreshPanes → pane-update → switchToWindow → ...
+     *
+     * Only handle panes already tracked in windowPaneTabs. Untracked panes
+     * will be picked up by handlePaneAdd (from pane-add events triggered
+     * by discoverPanesFromLayout on %layout-change).
+     */
+    handlePaneUpdate(paneId, windowId) {
+        // Find which window currently owns this pane in our map
+        let currentWindowId = null;
+        for (const [wid, paneMap] of this.windowPaneTabs) {
+            if (paneMap.has(paneId)) {
+                currentWindowId = wid;
+                break;
+            }
+        }
+        if (currentWindowId === null) {
+            // Pane not yet tracked — will be added via pane-add or switchToWindow
+            return;
+        }
+        if (currentWindowId === windowId) {
+            // Same window — no action needed
+            return;
+        }
+        // Pane moved between windows — move the tab object
+        this.logger.info(`Moving pane %${paneId} from window @${currentWindowId} to @${windowId}`);
+        const oldPaneMap = this.windowPaneTabs.get(currentWindowId);
+        const paneTab = oldPaneMap.get(paneId);
+        if (paneTab) {
+            oldPaneMap.delete(paneId);
+            let newPaneMap = this.windowPaneTabs.get(windowId);
+            if (!newPaneMap) {
+                newPaneMap = new Map();
+                this.windowPaneTabs.set(windowId, newPaneMap);
+            }
+            newPaneMap.set(paneId, paneTab);
+            // If it was in the active window, remove from SplitTab
+            if (currentWindowId === this.activeWindowId) {
+                paneTab.emitVisibility(false);
+                this.detachPaneView(paneTab);
+            }
+        }
+    }
+    /**
+     * Handle a tmux window being closed.
+     */
+    async handleWindowClose(windowId) {
+        const paneMap = this.windowPaneTabs.get(windowId);
+        if (paneMap) {
+            // Destroy all pane tabs for this window
+            for (const paneTab of paneMap.values()) {
+                if (windowId === this.activeWindowId) {
+                    paneTab.emitVisibility(false);
+                    this.detachPaneView(paneTab);
+                }
+                paneTab.destroy();
+            }
+            this.windowPaneTabs.delete(windowId);
+        }
+        // If we just closed the active window, switch to another one
+        if (windowId === this.activeWindowId) {
+            this.activeWindowId = null;
+            const remainingWindows = Array.from(this.windowPaneTabs.keys());
+            if (remainingWindows.length > 0) {
+                await this.switchToWindow(remainingWindows[0]);
+            }
+            else {
+                // No windows left — reset
+                this.root = new tabby_core_1.SplitContainer();
+                this.root.orientation = 'h';
+                this.layout();
+                this.cdr.detectChanges();
+            }
+        }
+    }
+    /**
+     * Synchronize SplitTab layout with tmux's layout string.
+     *
+     * This is the SINGLE place where the SplitTab tree is built.
+     * It creates missing pane tabs, attaches their views, cleans up stale
+     * panes, and rebuilds the entire tree from the tmux layout string.
+     */
+    async syncLayout(layoutStr) {
+        var _a;
+        const layoutTree = (0, layoutParser_1.parseTmuxLayout)(layoutStr);
+        if (!layoutTree) {
+            this.logger.warn('Failed to parse layout:', layoutStr);
+            return;
+        }
+        const panes = (0, layoutParser_1.flattenLayout)(layoutTree);
+        this.logger.info(`Syncing layout for window @${this.activeWindowId}: ${panes.length} panes`);
+        // Ensure pane tabs exist and have attached views for every pane in
+        // the layout. New panes (from split-window) are registered by
+        // handlePaneAdd but have no view yet — we call addTab to create one.
+        if (this.activeWindowId !== null) {
+            let paneMap = this.windowPaneTabs.get(this.activeWindowId);
+            if (!paneMap) {
+                paneMap = new Map();
+                this.windowPaneTabs.set(this.activeWindowId, paneMap);
+            }
+            for (const pane of panes) {
+                if (!paneMap.has(pane.paneId)) {
+                    this.logger.info(`Creating pane tab for %${pane.paneId} during layout sync`);
+                    const paneTab = this.createPaneTab(pane.paneId);
+                    paneTab.controller = this.controller;
+                    paneTab.paneId = pane.paneId;
+                    paneMap.set(pane.paneId, paneTab);
+                }
+            }
+            // Attach views for panes that don't have one yet.
+            // The tree structure will be rebuilt below, so the addTab direction
+            // doesn't matter — we just need the view to exist.
+            for (const pane of panes) {
+                const paneTab = paneMap.get(pane.paneId);
+                if (!((_a = this.viewRefs) === null || _a === void 0 ? void 0 : _a.has(paneTab))) {
+                    this.logger.info(`Attaching view for pane %${pane.paneId}`);
+                    const existingTabs = this.getAllTabs();
+                    if (existingTabs.length === 0) {
+                        await this.addTab(paneTab, null, 'r');
+                    }
+                    else {
+                        await this.addTab(paneTab, existingTabs[existingTabs.length - 1], 'r');
+                    }
+                    ;
+                    paneTab.emitVisibility(true);
+                    paneTab.emitFocused();
+                }
+            }
+        }
+        // Detect and clean up stale pane tabs that are no longer in the layout.
+        // When tmux closes a pane, the %layout-change notification omits it.
+        // We remove the corresponding tab so the UI stays consistent.
+        if (this.activeWindowId !== null) {
+            const paneMap = this.windowPaneTabs.get(this.activeWindowId);
+            if (paneMap) {
+                const layoutPaneIds = new Set(panes.map(p => p.paneId));
+                for (const [paneId, paneTab] of paneMap) {
+                    if (!layoutPaneIds.has(paneId)) {
+                        this.logger.info(`Pane %${paneId} no longer in layout, cleaning up`);
+                        paneMap.delete(paneId);
+                        paneTab.emitVisibility(false);
+                        this.detachPaneView(paneTab);
+                        paneTab.destroy();
+                    }
+                }
+            }
+        }
+        // Build the SplitContainer tree from the parsed layout
+        const newRoot = this.buildSplitContainerFromLayout(layoutTree);
+        if (newRoot instanceof tabby_core_1.SplitContainer) {
+            this.root = newRoot;
+            this.layout();
+        }
+        else if (newRoot) {
+            // Single pane — wrap in a container
+            this.root = new tabby_core_1.SplitContainer();
+            this.root.orientation = 'h';
+            this.root.children.push(newRoot);
+            this.root.ratios.push(1);
+            this.layout();
+        }
+        this.cdr.detectChanges();
+        // tmux is authoritative over each pane's character grid: push the exact
+        // cell dimensions from the layout string into each xterm. This keeps
+        // wrapping aligned with tmux and avoids any pixel-derived resize.
+        this.applyLayoutGrids(layoutTree);
+    }
+    /**
+     * Handle a pane being closed (from %pane-close event or manual cleanup).
+     */
+    handlePaneClose(paneId, windowId) {
+        const paneMap = this.windowPaneTabs.get(windowId);
+        if (!paneMap)
+            return;
+        const paneTab = paneMap.get(paneId);
+        if (!paneTab)
+            return;
+        this.logger.info(`Cleaning up closed pane %${paneId} in window @${windowId}`);
+        paneMap.delete(paneId);
+        if (windowId === this.activeWindowId) {
+            ;
+            paneTab.emitVisibility(false);
+            this.detachPaneView(paneTab);
+            this.layout();
+            this.cdr.detectChanges();
+        }
+        ;
+        paneTab.destroy();
+    }
+    /**
+     * Build a SplitContainer tree from a tmux layout node.
+     */
+    buildSplitContainerFromLayout(node) {
+        if (node.type === 'pane' && node.paneId !== undefined && this.activeWindowId !== null) {
+            const paneMap = this.windowPaneTabs.get(this.activeWindowId);
+            return (paneMap === null || paneMap === void 0 ? void 0 : paneMap.get(node.paneId)) || null;
+        }
+        if (!node.children || node.children.length === 0) {
+            return null;
+        }
+        const container = new tabby_core_1.SplitContainer();
+        container.orientation = node.type === 'horizontal' ? 'h' : 'v';
+        const totalSize = node.type === 'horizontal'
+            ? node.children.reduce((sum, c) => sum + c.width, 0)
+            : node.children.reduce((sum, c) => sum + c.height, 0);
+        for (const child of node.children) {
+            const childComponent = this.buildSplitContainerFromLayout(child);
+            if (childComponent) {
+                container.children.push(childComponent);
+                const ratio = totalSize > 0
+                    ? (node.type === 'horizontal' ? child.width / totalSize : child.height / totalSize)
+                    : 1 / node.children.length;
+                container.ratios.push(ratio);
+            }
+        }
+        return container.children.length > 0 ? container : null;
+    }
+    /**
+     * Refresh tmux client size based purely on the container (.pane-area) size.
+     *
+     * This is the SINGLE source of truth for the overall client size and is the
+     * key to avoiding the resize feedback loop:
+     *
+     *   - We compute the whole-window character grid from the .pane-area pixel
+     *     size divided by the xterm cell size. This value depends only on the
+     *     container, NOT on tmux's per-pane layout.
+     *   - tmux receives this via `refresh-client -C` and decides how to split
+     *     the grid among panes (sending %layout-change).
+     *   - On %layout-change we set each pane's xterm grid explicitly
+     *     (TmuxPaneTabComponent.setTmuxGrid) — panes never fit-to-pixels and
+     *     never report a size back up.
+     *
+     * Because the result is derived from the (stable) container size, a tmux
+     * relayout does not change it, so `_lastSentCols/Rows` dedup terminates the
+     * loop after a single iteration.
+     */
+    refreshClientSize() {
+        if (!this.controller || !this._initialized)
+            return;
+        if (this.activeWindowId === null)
+            return;
+        const measured = this.measureClientSize();
+        if (!measured) {
+            // Cell size not available yet (no pane frontend mounted/rendered).
+            // Retry shortly so the first real size still gets sent once a pane
+            // has rendered its character grid — but only if panes are expected.
+            const paneMap = this.windowPaneTabs.get(this.activeWindowId);
+            if (paneMap && paneMap.size > 0) {
+                this.scheduleRefreshClientSize();
+            }
+            return;
+        }
+        const { cols, rows } = measured;
+        if (cols > 0 && rows > 0 &&
+            (cols !== this._lastSentCols || rows !== this._lastSentRows)) {
+            this._lastSentCols = cols;
+            this._lastSentRows = rows;
+            this.logger.info(`Setting tmux client size: ${cols}x${rows}`);
+            this.controller.resizePane(0, cols, rows);
+        }
+    }
+    /**
+     * Apply the tmux-authoritative character grid to each mounted pane.
+     *
+     * tmux's layout string gives the exact width/height (in cells) of every
+     * pane. We push those directly into the corresponding xterm so display
+     * wrapping matches tmux exactly. xterm auto-fit is disabled for tmux panes,
+     * so this is the only thing that sizes them.
+     */
+    applyLayoutGrids(layoutTree) {
+        if (this.activeWindowId === null)
+            return;
+        const paneMap = this.windowPaneTabs.get(this.activeWindowId);
+        if (!paneMap)
+            return;
+        for (const pane of (0, layoutParser_1.flattenLayout)(layoutTree)) {
+            const paneTab = paneMap.get(pane.paneId);
+            if (paneTab === null || paneTab === void 0 ? void 0 : paneTab.setTmuxGrid) {
+                paneTab.setTmuxGrid(pane.width, pane.height);
+            }
+        }
+    }
+    /**
+     * Measure the whole-window character grid from the .pane-area container.
+     *
+     * The container width includes per-pane decorations (xterm scrollbar +
+     * padding) and UI spanner dividers, none of which belong to the tmux
+     * character grid. We subtract them, divide by the real xterm cell size,
+     * then add tmux's 1-char dividers between panes so tmux's own grid lines up.
+     */
+    measureClientSize() {
+        var _a, _b;
+        const host = this.hostElement.nativeElement;
+        const paneArea = (_a = host.querySelector('.pane-area')) !== null && _a !== void 0 ? _a : host;
+        const rect = paneArea.getBoundingClientRect();
+        if (rect.width < 10 || rect.height < 10)
+            return null;
+        const cell = this.getCellSize();
+        if (!cell)
+            return null;
+        // Determine pane/split counts for the active window.
+        const paneMap = this.activeWindowId !== null
+            ? this.windowPaneTabs.get(this.activeWindowId)
+            : null;
+        const paneCount = (_b = paneMap === null || paneMap === void 0 ? void 0 : paneMap.size) !== null && _b !== void 0 ? _b : 1;
+        // UI spanner pixel widths: tabby's split-tab-spanner is 10px each.
+        // Our custom tmux dividers are purely visual overlays with no pixel cost.
+        // _spanners is still populated by layoutInternal() for tabby's internal
+        // bookkeeping, but we no longer render split-tab-spanner elements, so
+        // their pixel width should not be subtracted here.
+        const spannerPx = 0;
+        // Per-pane visual padding defined in tmuxPaneTab.component.scss.
+        // Each pane has 4px on all sides (8px total per axis).
+        // For N panes in a row: total horizontal padding = N * 8px.
+        // For N panes in a column: total vertical padding = N * 8px.
+        // Approximate as all panes contributing to both axes (safe overestimate).
+        const panePadPerAxis = 8;
+        const totalPadPx = paneCount * panePadPerAxis;
+        const availableWidth = rect.width - spannerPx - totalPadPx;
+        const availableHeight = rect.height - totalPadPx;
+        const contentCols = Math.floor(availableWidth / cell.width);
+        const contentRows = Math.floor(availableHeight / cell.height);
+        // tmux inserts a 1-char divider between adjacent panes; add them back so
+        // the size we report covers content + dividers (tmux subtracts them again
+        // when splitting). Approximate as a horizontal split (most common case).
+        const numDividers = Math.max(0, paneCount - 1);
+        const cols = contentCols + numDividers;
+        return {
+            cols: Math.max(2, cols),
+            rows: Math.max(1, contentRows),
+        };
+    }
+    /**
+     * Read the xterm character cell size (in CSS pixels) from any mounted pane.
+     */
+    getCellSize() {
+        var _a, _b, _c, _d, _e, _f;
+        for (const paneMap of this.windowPaneTabs.values()) {
+            for (const paneTab of paneMap.values()) {
+                const frontend = paneTab.frontend;
+                const dims = (_b = (_a = frontend === null || frontend === void 0 ? void 0 : frontend.xtermCore) === null || _a === void 0 ? void 0 : _a._renderService) === null || _b === void 0 ? void 0 : _b.dimensions;
+                if (((_d = (_c = dims === null || dims === void 0 ? void 0 : dims.css) === null || _c === void 0 ? void 0 : _c.cell) === null || _d === void 0 ? void 0 : _d.width) > 0 && ((_f = (_e = dims === null || dims === void 0 ? void 0 : dims.css) === null || _e === void 0 ? void 0 : _e.cell) === null || _f === void 0 ? void 0 : _f.height) > 0) {
+                    return { width: dims.css.cell.width, height: dims.css.cell.height };
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Debounced version of refreshClientSize.
+     * Multiple sources (window resize, switchToWindow, layout-change) may
+     * fire close together — debounce into one refresh-client -C call.
+     */
+    scheduleRefreshClientSize() {
+        var _a, _b;
+        if (this._resizeTimer)
+            clearTimeout(this._resizeTimer);
+        const debounceMs = (_b = (_a = this.configService.store.tmuxPlugin) === null || _a === void 0 ? void 0 : _a.resizeDebounceMs) !== null && _b !== void 0 ? _b : 150;
+        this._resizeTimer = setTimeout(() => {
+            this._resizeTimer = null;
+            this.refreshClientSize();
+        }, debounceMs);
+    }
+    /**
+     * Attach mousemove + mousedown handlers to .pane-area so that hovering
+     * near a .child's right/bottom border highlights it, and dragging starts
+     * a tmux resize-pane operation.
+     */
+    attachPaneAreaBorderHandlers() {
+        const host = this.hostElement.nativeElement;
+        const paneArea = host.querySelector('.pane-area');
+        if (!paneArea)
+            return;
+        const HIT = TmuxSessionTabComponent_1.BORDER_HIT;
+        // Track which child + edge is currently hovered
+        let hoveredChild = null;
+        let hoveredEdge = null;
+        const clearHover = () => {
+            if (hoveredChild) {
+                hoveredChild.classList.remove('border-hover-right', 'border-hover-bottom');
+            }
+            hoveredChild = null;
+            hoveredEdge = null;
+            paneArea.style.cursor = '';
+        };
+        const onMove = (e) => {
+            const areaRect = paneArea.getBoundingClientRect();
+            const mx = e.clientX - areaRect.left;
+            const my = e.clientY - areaRect.top;
+            // Find a .child whose right or bottom border is within HIT pixels
+            clearHover();
+            const children = paneArea.querySelectorAll('.child');
+            for (const child of Array.from(children)) {
+                const el = child;
+                const r = el.getBoundingClientRect();
+                const right = r.right - areaRect.left;
+                const bottom = r.bottom - areaRect.top;
+                const left = r.left - areaRect.left;
+                const top = r.top - areaRect.top;
+                // Right border hit: within HIT of right edge, vertically inside
+                if (Math.abs(mx - right) <= HIT && my >= top && my <= bottom) {
+                    el.classList.add('border-hover-right');
+                    paneArea.style.cursor = 'col-resize';
+                    hoveredChild = el;
+                    hoveredEdge = 'right';
+                    break;
+                }
+                // Bottom border hit: within HIT of bottom edge, horizontally inside
+                if (Math.abs(my - bottom) <= HIT && mx >= left && mx <= right) {
+                    el.classList.add('border-hover-bottom');
+                    paneArea.style.cursor = 'row-resize';
+                    hoveredChild = el;
+                    hoveredEdge = 'bottom';
+                    break;
+                }
+            }
+        };
+        const onDown = (e) => {
+            if (!hoveredChild || !hoveredEdge || !this.controller)
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            const edge = hoveredEdge;
+            const cell = this.getCellSize();
+            if (!cell)
+                return;
+            const startX = e.clientX;
+            const startY = e.clientY;
+            // Find the pane ID for this .child element
+            const resizeTarget = hoveredChild;
+            const paneId = this.findPaneIdForElement(resizeTarget);
+            if (paneId === null)
+                return;
+            // Track last sent delta to send incremental resize commands
+            let lastSentCols = 0;
+            let lastSentRows = 0;
+            const onDragMove = (de) => {
+                document.body.style.cursor = edge === 'right' ? 'col-resize' : 'row-resize';
+                if (edge === 'right') {
+                    const deltaCols = Math.round((de.clientX - startX) / cell.width);
+                    if (deltaCols !== lastSentCols) {
+                        const diff = deltaCols - lastSentCols;
+                        const flag = diff > 0 ? '-R' : '-L';
+                        this.controller.gateway.sendCommand(`resize-pane ${flag} -t %${paneId} ${Math.abs(diff)}`);
+                        lastSentCols = deltaCols;
+                    }
+                }
+                else {
+                    const deltaRows = Math.round((de.clientY - startY) / cell.height);
+                    if (deltaRows !== lastSentRows) {
+                        const diff = deltaRows - lastSentRows;
+                        const flag = diff > 0 ? '-D' : '-U';
+                        this.controller.gateway.sendCommand(`resize-pane ${flag} -t %${paneId} ${Math.abs(diff)}`);
+                        lastSentRows = deltaRows;
+                    }
+                }
+            };
+            const onDragUp = () => {
+                document.removeEventListener('mousemove', onDragMove);
+                document.removeEventListener('mouseup', onDragUp);
+                document.body.style.cursor = '';
+                clearHover();
+            };
+            document.addEventListener('mousemove', onDragMove);
+            document.addEventListener('mouseup', onDragUp);
+        };
+        const onLeave = () => clearHover();
+        this._paneAreaMouseMoveHandler = onMove;
+        this._paneAreaMouseDownHandler = onDown;
+        paneArea.addEventListener('mousemove', onMove);
+        paneArea.addEventListener('mousedown', onDown);
+        paneArea.addEventListener('mouseleave', onLeave);
+    }
+    detachPaneAreaBorderHandlers() {
+        const host = this.hostElement.nativeElement;
+        const paneArea = host.querySelector('.pane-area');
+        if (!paneArea)
+            return;
+        if (this._paneAreaMouseMoveHandler) {
+            paneArea.removeEventListener('mousemove', this._paneAreaMouseMoveHandler);
+            this._paneAreaMouseMoveHandler = null;
+        }
+        if (this._paneAreaMouseDownHandler) {
+            paneArea.removeEventListener('mousedown', this._paneAreaMouseDownHandler);
+            this._paneAreaMouseDownHandler = null;
+        }
+    }
+    /**
+     * Map a .child DOM element back to the tmux pane ID it represents.
+     */
+    findPaneIdForElement(el) {
+        var _a, _b, _c;
+        if (this.activeWindowId === null)
+            return null;
+        const paneMap = this.windowPaneTabs.get(this.activeWindowId);
+        if (!paneMap)
+            return null;
+        for (const [paneId, paneTab] of paneMap) {
+            const tabEl = (_b = (_a = paneTab.hostElement) === null || _a === void 0 ? void 0 : _a.nativeElement) !== null && _b !== void 0 ? _b : (_c = paneTab.element) === null || _c === void 0 ? void 0 : _c.nativeElement;
+            if (tabEl && (tabEl === el || tabEl.contains(el) || el.contains(tabEl))) {
+                return paneId;
+            }
+        }
+        return null;
+    }
+    // ─── (legacy divider stubs removed) ─────────────────────────────────────
+    /**
+     * Override onSpannerAdjusted to notify tmux of layout change.
+     * When the user drags a spanner (split divider), the pane containers
+     * resize and xterm.js auto-fits. We need to tell tmux the new client size
+     * so it can recalculate its layout accordingly.
+     */
+    onSpannerAdjusted(spanner) {
+        super.onSpannerAdjusted(spanner);
+        this.scheduleRefreshClientSize();
+    }
+    // --- UI Event Handlers ---
+    onDisconnect() {
+        const ctx = this.tmuxService.findContextForTab(this);
+        if (ctx) {
+            this.tmuxService.disconnectContext(ctx);
+        }
+    }
+    async onWindowClose(windowId) {
+        if (this.controller) {
+            await this.controller.killWindow(windowId);
+        }
+    }
+    async onCreateWindow() {
+        if (this.controller) {
+            const newWindowId = await this.controller.createWindow();
+            if (newWindowId !== null) {
+                await this.switchToWindow(newWindowId);
+            }
+        }
+    }
+    ngOnDestroy() {
+        if (this.eventSubscription) {
+            this.eventSubscription.unsubscribe();
+        }
+        if (this._resizeHandler) {
+            window.removeEventListener('resize', this._resizeHandler);
+            this._resizeHandler = null;
+        }
+        if (this._paneAreaObserver) {
+            this._paneAreaObserver.disconnect();
+            this._paneAreaObserver = null;
+        }
+        if (this._resizeTimer) {
+            clearTimeout(this._resizeTimer);
+            this._resizeTimer = null;
+        }
+        this.detachPaneAreaBorderHandlers();
+        super.ngOnDestroy();
+    }
+    async canClose() {
+        return true;
+    }
+    /**
+     * Override recovery to delegate to the hidden host tab.
+     *
+     * When Tabby saves tabs on exit, the original terminal tab (topmostTab)
+     * is hidden from app.tabs and would be lost. Instead of persisting the
+     * tmux session tab (which cannot be meaningfully restored), we return
+     * the host tab's recovery token so Tabby restores the pre-tmux terminal.
+     * The tmux session remains alive in the background and can be re-attached.
+     */
+    async getRecoveryToken(options) {
+        const ctx = this.tmuxService.findContextForTab(this);
+        if (ctx === null || ctx === void 0 ? void 0 : ctx.topmostTab) {
+            return ctx.topmostTab.getRecoveryToken(options);
+        }
+        return null;
+    }
+};
+// ─── Border-based pane separator ────────────────────────────────────────
+/** Pixels from the right/bottom edge of a .child that counts as "on border" */
+TmuxSessionTabComponent.BORDER_HIT = 10;
+TmuxSessionTabComponent.ctorParameters = () => [
+    { type: core_1.Injector },
+    { type: tmux_service_1.TmuxService },
+    { type: tabby_core_1.ConfigService },
+    { type: tabby_core_1.TabsService },
+    { type: core_1.ChangeDetectorRef },
+    { type: core_1.ElementRef },
+    { type: tabby_core_1.LogService }
+];
+TmuxSessionTabComponent.propDecorators = {
+    profile: [{ type: core_1.Input }],
+    existingController: [{ type: core_1.Input }]
+};
+TmuxSessionTabComponent = TmuxSessionTabComponent_1 = __decorate([
+    (0, core_1.Component)({
+        selector: 'tmux-session-tab',
+        host: {
+            '[class.tmux-session-host]': 'true'
+        },
+        template: `
+        <div class="pane-area" #paneAreaEl>
+            <ng-container #vc></ng-container>
+        </div>
+        <tmux-window-bar
+            [controller]="controller"
+            [activeWindowId]="activeWindowId"
+            (windowSwitch)="switchToWindow($event)"
+            (windowClose)="onWindowClose($event)"
+            (disconnect)="onDisconnect()"
+            (createWindow)="onCreateWindow()"
+        ></tmux-window-bar>
+    `,
+        styles: ["\n        :host {\n            position: relative;\n            display: flex;\n            flex-direction: column;\n            width: 100%;\n            height: 100%;\n        }\n        .pane-area {\n            flex: 1 1 0;\n            position: relative;\n            min-height: 0;\n        }\n        /* SplitTab.layoutInternal() positions .child with inline left/top/width/height %.\n           border-right + border-bottom render the tmux pane separator line.\n           box-sizing: border-box keeps the border inside the layout box so\n           xterm content is not displaced.\n           The border area also serves as the resize drag handle (see onPaneAreaMouseDown). */\n        ::ng-deep .pane-area > .child {\n            position: absolute;\n            transition: 0.125s all;\n            opacity: .75;\n            box-sizing: border-box;\n            border-right: 1px solid rgba(128,128,128,0.3);\n            border-bottom: 1px solid rgba(128,128,128,0.3);\n        }\n        ::ng-deep .pane-area > .child.focused {\n            opacity: 1;\n        }\n        /*\n         * Transparent hit-target overlays at the right/bottom edges.\n         * xterm renders a scrollbar (~14px wide) that intercepts mouse events,\n         * preventing the pane-area mousemove handler from detecting border\n         * proximity.  These ::after pseudo-elements sit above the scrollbar\n         * (z-index: 10) and capture events for resize dragging.\n         */\n        ::ng-deep .pane-area > .child::after {\n            content: '';\n            position: absolute;\n            top: 0;\n            right: 0;\n            width: 10px;\n            height: 100%;\n            z-index: 10;\n            pointer-events: auto;\n            cursor: col-resize;\n        }\n        ::ng-deep .pane-area > .child::before {\n            content: '';\n            position: absolute;\n            bottom: 0;\n            left: 0;\n            width: 100%;\n            height: 10px;\n            z-index: 10;\n            pointer-events: auto;\n            cursor: row-resize;\n        }\n        /* Highlight the border when hovering near the right/bottom edge */\n        ::ng-deep .pane-area > .child.border-hover-right {\n            border-right-color: rgba(128,128,128,0.75);\n        }\n        ::ng-deep .pane-area > .child.border-hover-bottom {\n            border-bottom-color: rgba(128,128,128,0.75);\n        }\n        tmux-window-bar {\n            flex: 0 0 auto;\n            position: relative;\n            z-index: 10;\n        }\n    "]
+    }),
+    __metadata("design:paramtypes", [core_1.Injector,
+        tmux_service_1.TmuxService,
+        tabby_core_1.ConfigService,
+        tabby_core_1.TabsService,
+        core_1.ChangeDetectorRef,
+        core_1.ElementRef,
+        tabby_core_1.LogService])
+], TmuxSessionTabComponent);
+exports.TmuxSessionTabComponent = TmuxSessionTabComponent;
+
+
+/***/ },
+
+/***/ "./src/components/tmuxWindowBar.component.ts"
+/*!***************************************************!*\
+  !*** ./src/components/tmuxWindowBar.component.ts ***!
+  \***************************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxWindowBarComponent = void 0;
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const session_1 = __webpack_require__(/*! ../session */ "./src/session.ts");
+let TmuxWindowBarComponent = class TmuxWindowBarComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        this.activeWindowId = null;
+        this.windowSwitch = new core_1.EventEmitter();
+        this.windowClose = new core_1.EventEmitter();
+        this.disconnect = new core_1.EventEmitter();
+        this.createWindow = new core_1.EventEmitter();
+        this.windows = [];
+    }
+    ngOnInit() {
+        this.refreshWindows();
+        if (!this.controller) {
+            return;
+        }
+        this.subscription = this.controller.events.subscribe(event => {
+            switch (event.type) {
+                case 'window-add':
+                case 'window-close':
+                case 'window-renamed':
+                case 'pane-add':
+                case 'pane-close':
+                case 'initialized':
+                    this.refreshWindows();
+                    break;
+            }
+        });
+    }
+    ngOnDestroy() {
+        var _a;
+        (_a = this.subscription) === null || _a === void 0 ? void 0 : _a.unsubscribe();
+    }
+    refreshWindows() {
+        if (!this.controller) {
+            this.windows = [];
+            this.cdr.detectChanges();
+            return;
+        }
+        const windowStates = this.controller.getAllWindowStates();
+        this.windows = windowStates.map(ws => ({
+            id: ws.id,
+            name: ws.name,
+            paneCount: ws.panes.size,
+        }));
+        this.cdr.detectChanges();
+    }
+    onCloseWindow(event, win) {
+        event.stopPropagation();
+        this.windowClose.emit(win.id);
+    }
+    onContextMenu(event, _win) {
+        // Reserved for future context menu (rename, close window, etc.)
+        event.preventDefault();
+    }
+};
+TmuxWindowBarComponent.ctorParameters = () => [
+    { type: core_1.ChangeDetectorRef }
+];
+TmuxWindowBarComponent.propDecorators = {
+    controller: [{ type: core_1.Input }],
+    activeWindowId: [{ type: core_1.Input }],
+    windowSwitch: [{ type: core_1.Output }],
+    windowClose: [{ type: core_1.Output }],
+    disconnect: [{ type: core_1.Output }],
+    createWindow: [{ type: core_1.Output }]
+};
+TmuxWindowBarComponent = __decorate([
+    (0, core_1.Component)({
+        selector: 'tmux-window-bar',
+        template: `
+        <div class="window-bar">
+            <div class="window-tabs">
+                <button
+                    *ngFor="let win of windows"
+                    class="window-tab"
+                    [class.active]="win.id === activeWindowId"
+                    (click)="windowSwitch.emit(win.id)"
+                    (contextmenu)="onContextMenu($event, win)"
+                    [title]="win.name"
+                >
+                    <span class="window-name">{{ win.name }}</span>
+                    <span class="pane-badge" *ngIf="win.paneCount > 1">{{ win.paneCount }}</span>
+                    <span class="window-close" title="Close Window" (click)="onCloseWindow($event, win)">
+                        <i class="fas fa-times"></i>
+                    </span>
+                </button>
+                <button class="window-tab add-btn" title="New Window" (click)="createWindow.emit()">
+                    <i class="fas fa-plus"></i>
+                </button>
+            </div>
+            <div class="bar-actions">
+                <button class="bar-btn" title="Disconnect" (click)="disconnect.emit()">
+                    <i class="fas fa-eject"></i>
+                </button>
+            </div>
+        </div>
+    `,
+        styles: ["\n        :host {\n            display: block;\n            flex: 0 0 auto;\n        }\n        .window-bar {\n            display: flex;\n            align-items: center;\n            justify-content: space-between;\n            padding: 2px 8px;\n            background: rgba(30, 30, 30, 0.95);\n            border-top: 1px solid rgba(255, 255, 255, 0.1);\n            min-height: 28px;\n            overflow-x: auto;\n        }\n        .window-tabs {\n            display: flex;\n            align-items: center;\n            gap: 2px;\n            overflow-x: auto;\n            flex: 1;\n            min-width: 0;\n        }\n        .window-tab {\n            display: flex;\n            align-items: center;\n            gap: 4px;\n            height: 22px;\n            padding: 0 8px;\n            border: 1px solid transparent;\n            border-radius: 3px;\n            background: transparent;\n            color: #999;\n            font-size: 0.82em;\n            cursor: pointer;\n            white-space: nowrap;\n            transition: background 0.15s, color 0.15s, border-color 0.15s;\n        }\n        .window-tab:hover {\n            background: rgba(255, 255, 255, 0.08);\n            color: #ccc;\n        }\n        .window-tab.active {\n            background: rgba(255, 255, 255, 0.12);\n            color: #fff;\n            border-color: rgba(255, 255, 255, 0.15);\n        }\n        .pane-badge {\n            display: inline-flex;\n            align-items: center;\n            justify-content: center;\n            min-width: 16px;\n            height: 16px;\n            padding: 0 3px;\n            border-radius: 8px;\n            background: rgba(255, 255, 255, 0.1);\n            font-size: 0.85em;\n            color: #aaa;\n        }\n        .window-close {\n            display: inline-flex;\n            align-items: center;\n            justify-content: center;\n            margin-left: auto;\n            margin-right: -4px;\n            width: 14px;\n            height: 14px;\n            border-radius: 2px;\n            font-size: 0.7em;\n            color: transparent;\n            cursor: pointer;\n            visibility: hidden;\n        }\n        .window-tab:hover .window-close {\n            visibility: visible;\n            color: #888;\n        }\n        .window-close:hover {\n            background: rgba(255, 80, 80, 0.3);\n            color: #f66;\n        }\n        .add-btn {\n            color: #666;\n            padding: 0 6px;\n        }\n        .add-btn:hover {\n            color: #aaa;\n        }\n        .bar-actions {\n            display: flex;\n            align-items: center;\n            gap: 2px;\n            margin-left: 8px;\n        }\n        .bar-btn {\n            display: flex;\n            align-items: center;\n            justify-content: center;\n            width: 24px;\n            height: 24px;\n            border: none;\n            border-radius: 3px;\n            background: transparent;\n            color: #888;\n            font-size: 0.8em;\n            cursor: pointer;\n        }\n        .bar-btn:hover {\n            background: rgba(255, 255, 255, 0.1);\n            color: #ccc;\n        }\n    "]
+    }),
+    __metadata("design:paramtypes", [core_1.ChangeDetectorRef])
+], TmuxWindowBarComponent);
+exports.TmuxWindowBarComponent = TmuxWindowBarComponent;
+
+
+/***/ },
+
+/***/ "./src/config.ts"
+/*!***********************!*\
+  !*** ./src/config.ts ***!
+  \***********************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxConfigProvider = void 0;
+const tabby_core_1 = __webpack_require__(/*! tabby-core */ "tabby-core");
+// eslint-disable-next-line new-cap
+class TmuxConfigProvider extends tabby_core_1.ConfigProvider {
+    constructor() {
+        super(...arguments);
+        this.defaults = {
+            tmuxPlugin: {
+                defaultSessionName: 'default',
+                commandTimeoutMs: 30000,
+                sendKeysChunkSize: 200,
+                resizeDebounceMs: 150,
+                debugLogging: false,
+            },
+        };
+    }
+}
+exports.TmuxConfigProvider = TmuxConfigProvider;
+
+
+/***/ },
+
+/***/ "./src/gateway.ts"
+/*!************************!*\
+  !*** ./src/gateway.ts ***!
+  \************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxGateway = exports.TMUX_COMMAND_WANTS_DATA = exports.TMUX_COMMAND_TOLERATE_ERRORS = void 0;
+const rxjs_1 = __webpack_require__(/*! rxjs */ "rxjs");
+const logHelper_1 = __webpack_require__(/*! ./logHelper */ "./src/logHelper.ts");
+// Command flags
+exports.TMUX_COMMAND_TOLERATE_ERRORS = 1 << 0;
+exports.TMUX_COMMAND_WANTS_DATA = 1 << 1;
+const DEFAULT_COMMAND_TIMEOUT_MS = 30000;
+const DEFAULT_SEND_KEYS_CHUNK_SIZE = 200;
+/**
+ * TmuxGateway - Protocol layer for tmux control mode
+ *
+ * Handles:
+ * - Command queuing with response matching
+ * - Protocol parsing (%begin/%end/%error blocks)
+ * - Notification dispatch
+ * - Key encoding and sending
+ */
+class TmuxGateway {
+    constructor(logger, writer, configService) {
+        this.logger = logger;
+        this.writer = writer;
+        this.configService = configService;
+        this.commandQueue = [];
+        this.currentCommand = null;
+        this.currentCommandId = '';
+        this.currentResponse = [];
+        this.inResponseBlock = false;
+        this.nextCommandId = 1;
+        this.disconnected = false;
+        this.detachSent = false;
+        this.acceptNotifications = false;
+        this.initialized = false;
+        /** Number of fire-and-forget writes whose %begin/%end responses need consuming */
+        this.directWritesPending = 0;
+        /** Incomplete line buffer for byte-level DCS parsing */
+        this.lineBuffer = '';
+        this.minimumServerVersion = null;
+        this.maximumServerVersion = null;
+        this.pauseModeEnabled = false;
+        // Events for notifications
+        this.output$ = new rxjs_1.Subject();
+        this.layoutChange$ = new rxjs_1.Subject();
+        this.windowAdd$ = new rxjs_1.Subject();
+        this.windowClose$ = new rxjs_1.Subject();
+        this.windowRenamed$ = new rxjs_1.Subject();
+        this.sessionChanged$ = new rxjs_1.Subject();
+        this.sessionsChanged$ = new rxjs_1.Subject();
+        this.paneChanged$ = new rxjs_1.Subject();
+        this.sessionWindowChanged$ = new rxjs_1.Subject();
+        this.paneClose$ = new rxjs_1.Subject();
+        this.exit$ = new rxjs_1.Subject();
+        this.initialized$ = new rxjs_1.Subject();
+    }
+    get log() {
+        return (0, logHelper_1.createConditionalLogger)(this.logger, this.configService);
+    }
+    get commandTimeoutMs() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.configService) === null || _a === void 0 ? void 0 : _a.store.tmuxPlugin) === null || _b === void 0 ? void 0 : _b.commandTimeoutMs) !== null && _c !== void 0 ? _c : DEFAULT_COMMAND_TIMEOUT_MS;
+    }
+    get sendKeysChunkSize() {
+        var _a, _b, _c;
+        return (_c = (_b = (_a = this.configService) === null || _a === void 0 ? void 0 : _a.store.tmuxPlugin) === null || _b === void 0 ? void 0 : _b.sendKeysChunkSize) !== null && _c !== void 0 ? _c : DEFAULT_SEND_KEYS_CHUNK_SIZE;
+    }
+    /**
+     * Send a single command and wait for response
+     */
+    async sendCommand(command, flags = 0) {
+        if (this.detachSent || this.disconnected) {
+            throw new Error('Gateway disconnected');
+        }
+        const original = new Promise((resolve, reject) => {
+            const cmd = {
+                id: this.nextCommandId++,
+                command,
+                resolve,
+                reject,
+                flags,
+                timestamp: Date.now()
+            };
+            this.commandQueue.push(cmd);
+            this.write(command + '\r');
+            this.log.debug(`Sent command: ${command}`);
+        });
+        // Race against timeout — if tmux never responds, reject instead of hanging
+        let timer;
+        const timeout = new Promise((_, reject) => {
+            timer = setTimeout(() => {
+                // Remove the timed-out command from the queue so it won't
+                // consume a later response and cause command-id mismatch.
+                reject(new Error(`Command timed out after ${this.commandTimeoutMs}ms: ${command}`));
+            }, this.commandTimeoutMs);
+        });
+        // Clean up timer when original settles
+        original.then(() => clearTimeout(timer), () => clearTimeout(timer));
+        return Promise.race([original, timeout]);
+    }
+    /**
+     * Send a list of commands atomically (separated by ;)
+     */
+    async sendCommandList(commands) {
+        if (this.detachSent || this.disconnected || commands.length === 0) {
+            return [];
+        }
+        const promises = [];
+        const combined = commands.map((c) => {
+            const promise = new Promise((resolve, reject) => {
+                const cmd = {
+                    id: this.nextCommandId++,
+                    command: c.command,
+                    resolve,
+                    reject,
+                    flags: c.flags || 0,
+                    timestamp: Date.now()
+                };
+                this.commandQueue.push(cmd);
+            });
+            promises.push(promise);
+            return c.command;
+        }).join('; ');
+        this.write(combined + '\r');
+        this.log.debug(`Sent command list: ${combined}`);
+        return Promise.all(promises);
+    }
+    /**
+     * Send keystrokes to a specific pane.
+     *
+     * Writes directly to the PTY — bypasses the command queue for zero-latency
+     * input.  tmux will still send %begin/%end for the send-keys command;
+     * parseBegin() tracks these via directWritesPending so they are consumed
+     * without trying to dequeue a queued command.
+     */
+    sendKeys(data, paneId) {
+        var _a;
+        if (this.disconnected)
+            return;
+        const hex = data.toString('hex');
+        if (hex.length > 0) {
+            // Split into chunks to avoid command length limits
+            for (let i = 0; i < hex.length; i += this.sendKeysChunkSize) {
+                const chunk = hex.substring(i, i + this.sendKeysChunkSize);
+                const hexBytes = ((_a = chunk.match(/.{2}/g)) === null || _a === void 0 ? void 0 : _a.join(' ')) || '';
+                // Write directly — bypasses command queue for zero-latency input
+                this.write(`send-keys -t %${paneId} -H ${hexBytes}\r`);
+                this.directWritesPending++;
+            }
+        }
+    }
+    /**
+     * Request detach
+     */
+    detach() {
+        if (!this.detachSent) {
+            this.write('detach\r');
+            this.detachSent = true;
+        }
+    }
+    /**
+     * Feed raw PTY data.  Buffers incomplete lines across calls so that TCP
+     * fragment boundaries never split a protocol line.
+     */
+    executeData(data) {
+        this.lineBuffer += data.toString('utf-8');
+        let newlineIdx;
+        while ((newlineIdx = this.lineBuffer.indexOf('\n')) !== -1) {
+            const rawLine = this.lineBuffer.substring(0, newlineIdx);
+            this.lineBuffer = this.lineBuffer.substring(newlineIdx + 1);
+            const line = rawLine.replace(/\r$/, '');
+            if (line) {
+                this.executeLine(line);
+            }
+        }
+    }
+    /**
+     * Process a single complete line from tmux control mode
+     */
+    executeLine(line) {
+        // Strip DCS artifacts
+        line = line.replace(/^\x1bP\d+p/, '').replace(/^P\d+p/, '').replace(/\x1b\\$/, '');
+        if (!line)
+            return;
+        this.log.info(`Received: ${line.substring(0, 100)}${line.length > 100 ? '...' : ''}`);
+        // Handle response blocks
+        if (this.inResponseBlock) {
+            if (line.startsWith(`%end ${this.currentCommandId}`) ||
+                line.startsWith(`%end `)) {
+                this.stripLastNewline();
+                this.finishCurrentCommand(false);
+                return;
+            }
+            else if (line.startsWith(`%error ${this.currentCommandId}`) ||
+                line.startsWith(`%error `)) {
+                this.stripLastNewline();
+                this.finishCurrentCommand(true);
+                return;
+            }
+            else if (line.startsWith('%exit')) {
+                // Tmux 1.8 bug workaround
+                this.stripLastNewline();
+                this.finishCurrentCommand(false);
+                // Fall through to handle %exit
+            }
+            else if (line.startsWith('%output ') || line.startsWith('%extended-output ')) {
+                // Dispatch pane output notifications even during response blocks.
+                // Otherwise they get accumulated as garbage text in the command
+                // response (e.g. capture-pane) and the live output is lost.
+                if (this.acceptNotifications) {
+                    if (line.startsWith('%output ')) {
+                        this.parseOutput(line);
+                    }
+                    else {
+                        this.parseExtendedOutput(line);
+                    }
+                }
+                return;
+            }
+            else {
+                // Accumulate response
+                this.currentResponse.push(line);
+                return;
+            }
+        }
+        // Handle notifications and commands
+        if (line.startsWith('%begin')) {
+            this.parseBegin(line);
+        }
+        else if (line.startsWith('%output ')) {
+            if (this.acceptNotifications) {
+                this.log.info(`Parsing output line: ${line.substring(0, 50)}...`);
+                this.parseOutput(line);
+            }
+            else {
+                this.log.warn(`Ignored output (not accepting notifications): ${line.substring(0, 50)}...`);
+            }
+        }
+        else if (line.startsWith('%extended-output ')) {
+            if (this.acceptNotifications) {
+                this.parseExtendedOutput(line);
+            }
+        }
+        else if (line.startsWith('%layout-change ')) {
+            if (this.acceptNotifications) {
+                this.parseLayoutChange(line);
+            }
+        }
+        else if (line.startsWith('%window-add')) {
+            if (this.acceptNotifications) {
+                this.parseWindowAdd(line);
+            }
+        }
+        else if (line.startsWith('%window-close') || line.startsWith('%unlinked-window-close')) {
+            if (this.acceptNotifications) {
+                this.parseWindowClose(line);
+            }
+        }
+        else if (line.startsWith('%window-renamed') || line.startsWith('%unlinked-window-renamed')) {
+            if (this.acceptNotifications) {
+                this.parseWindowRenamed(line);
+            }
+        }
+        else if (line.startsWith('%session-changed')) {
+            this.parseSessionChanged(line);
+        }
+        else if (line.startsWith('%sessions-changed')) {
+            if (this.acceptNotifications) {
+                this.sessionsChanged$.next();
+            }
+        }
+        else if (line.startsWith('%session-window-changed')) {
+            if (this.acceptNotifications) {
+                this.parseSessionWindowChanged(line);
+            }
+        }
+        else if (line.startsWith('%window-pane-changed')) {
+            if (this.acceptNotifications) {
+                this.parsePaneChanged(line);
+            }
+        }
+        else if (line.startsWith('%pane-close') || line.startsWith('%unlinked-pane-close')) {
+            if (this.acceptNotifications) {
+                this.parsePaneClose(line);
+            }
+        }
+        else if (line.startsWith('%pause') || line.startsWith('%continue')) {
+            // Flow control notifications (tmux 3.2+) — acknowledged
+            this.log.debug(`Flow control: ${line}`);
+        }
+        else if (line.startsWith('%no-output')) {
+            // Empty response block — no action needed
+        }
+        else if (line.startsWith('%exit')) {
+            this.parseExit(line);
+        }
+        else if (line.startsWith('%')) {
+            // Unknown notification, ignore
+            this.log.debug(`Unknown notification: ${line}`);
+        }
+    }
+    // --- Protocol Parsing ---
+    parseBegin(line) {
+        // %begin timestamp commandId flags
+        // Format: %begin 1767853190 875 1
+        // tmux Control Mode docs: flags is always 1 for client-originated.
+        const parts = line.split(' ');
+        if (parts.length < 3) {
+            this.logger.warn(`Malformed %begin: ${line}`);
+            return;
+        }
+        const commandId = parts[2];
+        this.currentCommandId = commandId;
+        this.currentResponse = [];
+        this.inResponseBlock = true;
+        // If this response is for a fire-and-forget write (sendKeys),
+        // consume it without dequeuing a queued command.
+        if (this.commandQueue.length === 0 && this.directWritesPending > 0) {
+            this.directWritesPending--;
+            this.currentCommand = null;
+            return;
+        }
+        if (this.commandQueue.length === 0) {
+            // Server-initiated or unexpected response block
+            this.currentCommand = null;
+            return;
+        }
+        this.currentCommand = this.commandQueue.shift();
+    }
+    finishCurrentCommand(isError) {
+        this.inResponseBlock = false;
+        const response = this.currentResponse.join('\n');
+        if (this.currentCommand) {
+            if (isError && !(this.currentCommand.flags & exports.TMUX_COMMAND_TOLERATE_ERRORS)) {
+                this.currentCommand.reject(new Error(response));
+            }
+            else {
+                this.currentCommand.resolve(response);
+            }
+            this.currentCommand = null;
+        }
+        // Mark as initialized after first successful response
+        if (!this.initialized) {
+            this.initialized = true;
+            this.acceptNotifications = true;
+            this.initialized$.next();
+        }
+    }
+    stripLastNewline() {
+        if (this.currentResponse.length > 0) {
+            const last = this.currentResponse[this.currentResponse.length - 1];
+            if (last === '') {
+                this.currentResponse.pop();
+            }
+        }
+    }
+    parseOutput(line) {
+        // %output %<pane> <data>
+        const match = line.match(/^%output %(\d+) (.*)$/);
+        if (!match) {
+            this.logger.error(`Output regex FAILED for line: <${line}>`);
+            return;
+        }
+        const paneId = parseInt(match[1]);
+        const data = this.decodeOutput(match[2]);
+        this.log.info(`Parsed output for pane %${paneId}: ${data.length} bytes (match_len=${match[2].length})`);
+        this.output$.next({ paneId, data });
+    }
+    parseExtendedOutput(line) {
+        // %extended-output %<pane> <latency> : <data>
+        const match = line.match(/^%extended-output %(\d+) (\d+) : (.*)$/);
+        if (!match)
+            return;
+        const paneId = parseInt(match[1]);
+        const latency = parseInt(match[2]) / 1000; // Convert ms to seconds
+        const data = this.decodeOutput(match[3]);
+        this.output$.next({ paneId, data, latency });
+    }
+    parseLayoutChange(line) {
+        // %layout-change @<window> <layout> [visible_layout flags]
+        const match = line.match(/^%layout-change @(\d+) (.+)$/);
+        if (!match)
+            return;
+        const windowId = parseInt(match[1]);
+        const parts = match[2].split(' ');
+        const layout = parts[0];
+        const visibleLayout = parts.length > 1 ? parts[1] : undefined;
+        const zoomed = parts.length > 2 ? parts[2].includes('Z') : undefined;
+        this.layoutChange$.next({ windowId, layout, visibleLayout, zoomed });
+    }
+    parseWindowAdd(line) {
+        // %window-add @<id>
+        const match = line.match(/^%window-add @(\d+)$/);
+        if (match) {
+            this.windowAdd$.next(parseInt(match[1]));
+        }
+    }
+    parseWindowClose(line) {
+        // %window-close @<id> or %unlinked-window-close @<id>
+        const match = line.match(/@(\d+)$/);
+        if (match) {
+            this.windowClose$.next(parseInt(match[1]));
+        }
+    }
+    parseWindowRenamed(line) {
+        // %window-renamed @<id> <name>
+        const match = line.match(/^%(?:unlinked-)?window-renamed @(\d+) (.+)$/);
+        if (match) {
+            this.windowRenamed$.next({
+                windowId: parseInt(match[1]),
+                name: this.unescapeTmuxWindowName(match[2])
+            });
+        }
+    }
+    parseSessionChanged(line) {
+        // %session-changed $<id> <name>
+        const match = line.match(/^%session-changed \$(\d+) (.+)$/);
+        if (match) {
+            this.sessionChanged$.next({
+                sessionId: parseInt(match[1]),
+                sessionName: match[2]
+            });
+            // Enable notifications after session change
+            this.acceptNotifications = true;
+        }
+    }
+    parseSessionWindowChanged(line) {
+        // %session-window-changed $session @window
+        const match = line.match(/^%session-window-changed \$\d+ @(\d+)/);
+        if (match) {
+            this.sessionWindowChanged$.next({
+                windowId: parseInt(match[1])
+            });
+        }
+    }
+    parsePaneChanged(line) {
+        // %window-pane-changed @<window> %<pane>
+        const match = line.match(/^%window-pane-changed @(\d+) %(\d+)$/);
+        if (match) {
+            this.paneChanged$.next({
+                windowId: parseInt(match[1]),
+                paneId: parseInt(match[2])
+            });
+        }
+    }
+    parsePaneClose(line) {
+        // %pane-close @<window> %<pane>
+        const match = line.match(/^%(?:unlinked-)?pane-close @(\d+) %(\d+)$/);
+        if (match) {
+            this.paneClose$.next({
+                windowId: parseInt(match[1]),
+                paneId: parseInt(match[2])
+            });
+        }
+    }
+    parseExit(line) {
+        // %exit or %exit <reason>
+        const reason = line.replace(/^%exit\s*/, '');
+        this.exit$.next(reason);
+        this.disconnected = true;
+    }
+    // --- Utility Methods ---
+    write(data) {
+        this.writer(data);
+    }
+    /**
+     * Decode tmux octal-escaped output to Buffer
+     */
+    decodeOutput(str) {
+        const bytes = [];
+        for (let i = 0; i < str.length; i++) {
+            if (str[i] === '\\' && i + 3 < str.length) {
+                const octal = str.substring(i + 1, i + 4);
+                if (/^[0-7]{3}$/.test(octal)) {
+                    bytes.push(parseInt(octal, 8));
+                    i += 3;
+                    continue;
+                }
+            }
+            // Handle UTF-8 properly
+            const buf = Buffer.from(str[i], 'utf-8');
+            for (const byte of buf) {
+                bytes.push(byte);
+            }
+        }
+        return Buffer.from(bytes);
+    }
+    unescapeTmuxWindowName(name) {
+        // Tmux may escape window names
+        return name.replace(/\\(.)/g, '$1');
+    }
+    /**
+     * Check if server version is at least the given version
+     */
+    versionAtLeast(version) {
+        return this.minimumServerVersion !== null && this.minimumServerVersion >= version;
+    }
+}
+exports.TmuxGateway = TmuxGateway;
+
+
+/***/ },
+
+/***/ "./src/index.ts"
+/*!**********************!*\
+  !*** ./src/index.ts ***!
+  \**********************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const common_1 = __webpack_require__(/*! @angular/common */ "@angular/common");
+const forms_1 = __webpack_require__(/*! @angular/forms */ "@angular/forms");
+const tabby_core_1 = __importStar(__webpack_require__(/*! tabby-core */ "tabby-core"));
+const tabby_settings_1 = __webpack_require__(/*! tabby-settings */ "tabby-settings");
+const tabContextMenu_1 = __webpack_require__(/*! ./tabContextMenu */ "./src/tabContextMenu.ts");
+const config_1 = __webpack_require__(/*! ./config */ "./src/config.ts");
+const settings_1 = __webpack_require__(/*! ./settings */ "./src/settings.ts");
+const tmuxPaneTab_component_1 = __webpack_require__(/*! ./components/tmuxPaneTab.component */ "./src/components/tmuxPaneTab.component.ts");
+const tmuxSessionTab_component_1 = __webpack_require__(/*! ./components/tmuxSessionTab.component */ "./src/components/tmuxSessionTab.component.ts");
+const tmuxWindowBar_component_1 = __webpack_require__(/*! ./components/tmuxWindowBar.component */ "./src/components/tmuxWindowBar.component.ts");
+const settings_component_1 = __webpack_require__(/*! ./components/settings.component */ "./src/components/settings.component.ts");
+let TmuxModule = class TmuxModule {
+};
+TmuxModule = __decorate([
+    (0, core_1.NgModule)({
+        imports: [
+            common_1.CommonModule,
+            forms_1.FormsModule,
+            tabby_core_1.default,
+        ],
+        providers: [
+            { provide: tabby_core_1.TabContextMenuItemProvider, useClass: tabContextMenu_1.TmuxContextMenuProvider, multi: true },
+            { provide: tabby_core_1.ConfigProvider, useClass: config_1.TmuxConfigProvider, multi: true },
+            { provide: tabby_settings_1.SettingsTabProvider, useClass: settings_1.TmuxSettingsTabProvider, multi: true },
+        ],
+        declarations: [
+            tmuxPaneTab_component_1.TmuxPaneTabComponent,
+            tmuxSessionTab_component_1.TmuxSessionTabComponent,
+            tmuxWindowBar_component_1.TmuxWindowBarComponent,
+            settings_component_1.TmuxSettingsTabComponent,
+        ],
+        entryComponents: [
+            tmuxPaneTab_component_1.TmuxPaneTabComponent,
+            tmuxSessionTab_component_1.TmuxSessionTabComponent,
+            settings_component_1.TmuxSettingsTabComponent,
+        ],
+    })
+], TmuxModule);
+exports["default"] = TmuxModule;
+
+
+/***/ },
+
+/***/ "./src/layoutParser.ts"
+/*!*****************************!*\
+  !*** ./src/layoutParser.ts ***!
+  \*****************************/
+(__unused_webpack_module, exports) {
+
+"use strict";
+
+/**
+ * TmuxLayoutParser - Parse tmux layout strings to extract pane positions
+ *
+ * Tmux layout string format:
+ * - Checksum,WxH,X,Y<content>
+ * - Content can be:
+ *   - Just a pane ID: "93x52,0,0,185"
+ *   - Vertical split [...]: contains comma-separated panes stacked top-to-bottom
+ *   - Horizontal split {...}: contains comma-separated panes arranged left-to-right
+ *
+ * Example: "41e9,279x71,0,0[279x40,0,0,71,279x30,0,41{147x30,0,41,72,131x30,148,41,73}]"
+ */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.layoutToSplitFormat = exports.flattenLayout = exports.parseTmuxLayout = void 0;
+/**
+ * Parse a tmux layout string into a tree structure
+ */
+function parseTmuxLayout(layoutStr) {
+    if (!layoutStr)
+        return null;
+    // Remove checksum if present (4 hex chars followed by comma)
+    const checksumMatch = layoutStr.match(/^[0-9a-f]{4},/);
+    if (checksumMatch) {
+        layoutStr = layoutStr.substring(5);
+    }
+    try {
+        return parseNode(layoutStr, 0).node;
+    }
+    catch (e) {
+        console.error('Failed to parse tmux layout:', e);
+        return null;
+    }
+}
+exports.parseTmuxLayout = parseTmuxLayout;
+/**
+ * Parse a single node from the layout string
+ */
+function parseNode(str, start) {
+    // Parse dimension: WxH,X,Y
+    const dimMatch = str.substring(start).match(/^(\d+)x(\d+),(\d+),(\d+)/);
+    if (!dimMatch) {
+        throw new Error(`Invalid dimension at position ${start}: ${str.substring(start, start + 20)}`);
+    }
+    const width = parseInt(dimMatch[1]);
+    const height = parseInt(dimMatch[2]);
+    const x = parseInt(dimMatch[3]);
+    const y = parseInt(dimMatch[4]);
+    let pos = start + dimMatch[0].length;
+    // Check what follows
+    if (pos >= str.length) {
+        // End of string - this shouldn't happen for a complete layout
+        throw new Error('Unexpected end of layout string');
+    }
+    const nextChar = str[pos];
+    if (nextChar === '[') {
+        // Vertical split (top-to-bottom) — tmux [...] = panes stacked vertically
+        pos++; // skip '['
+        const children = [];
+        while (str[pos] !== ']') {
+            const result = parseNode(str, pos);
+            children.push(result.node);
+            pos = result.consumed;
+            if (str[pos] === ',') {
+                pos++; // skip comma between children
+            }
+        }
+        pos++; // skip ']'
+        return {
+            node: { type: 'vertical', x, y, width, height, children },
+            consumed: pos
+        };
+    }
+    else if (nextChar === '{') {
+        // Horizontal split (left-to-right) — tmux {...} = panes side by side
+        pos++; // skip '{'
+        const children = [];
+        while (str[pos] !== '}') {
+            const result = parseNode(str, pos);
+            children.push(result.node);
+            pos = result.consumed;
+            if (str[pos] === ',') {
+                pos++; // skip comma between children
+            }
+        }
+        pos++; // skip '}'
+        return {
+            node: { type: 'horizontal', x, y, width, height, children },
+            consumed: pos
+        };
+    }
+    else if (nextChar === ',' || nextChar === ']' || nextChar === '}' || pos >= str.length) {
+        // This is a pane - the next number is the pane ID
+        // But wait, we need to check if there's a pane ID
+        // The format is WxH,X,Y,PaneID for a simple pane
+        if (nextChar === ',') {
+            pos++; // skip comma
+            const paneIdMatch = str.substring(pos).match(/^(\d+)/);
+            if (paneIdMatch) {
+                const paneId = parseInt(paneIdMatch[1]);
+                pos += paneIdMatch[0].length;
+                return {
+                    node: { type: 'pane', x, y, width, height, paneId },
+                    consumed: pos
+                };
+            }
+        }
+        // No pane ID found, this might be a container
+        return {
+            node: { type: 'pane', x, y, width, height },
+            consumed: pos
+        };
+    }
+    else {
+        throw new Error(`Unexpected character '${nextChar}' at position ${pos}`);
+    }
+}
+/**
+ * Flatten a layout tree into a list of panes
+ */
+function flattenLayout(node) {
+    const panes = [];
+    function traverse(n) {
+        if (n.type === 'pane' && n.paneId !== undefined) {
+            panes.push({
+                paneId: n.paneId,
+                x: n.x,
+                y: n.y,
+                width: n.width,
+                height: n.height
+            });
+        }
+        if (n.children) {
+            for (const child of n.children) {
+                traverse(child);
+            }
+        }
+    }
+    traverse(node);
+    return panes;
+}
+exports.flattenLayout = flattenLayout;
+function layoutToSplitFormat(node) {
+    var _a;
+    if (node.type === 'pane') {
+        return (_a = node.paneId) !== null && _a !== void 0 ? _a : null;
+    }
+    if (!node.children || node.children.length === 0) {
+        return null;
+    }
+    const orientation = node.type === 'horizontal' ? 'horizontal' : 'vertical';
+    // Calculate ratios based on dimensions
+    const totalSize = orientation === 'horizontal'
+        ? node.children.reduce((sum, c) => sum + c.width, 0)
+        : node.children.reduce((sum, c) => sum + c.height, 0);
+    const ratios = node.children.map(c => orientation === 'horizontal'
+        ? c.width / totalSize
+        : c.height / totalSize);
+    const children = node.children.map(c => layoutToSplitFormat(c)).filter(c => c !== null);
+    return { orientation, ratios, children: children };
+}
+exports.layoutToSplitFormat = layoutToSplitFormat;
+
+
+/***/ },
+
+/***/ "./src/logHelper.ts"
+/*!**************************!*\
+  !*** ./src/logHelper.ts ***!
+  \**************************/
+(__unused_webpack_module, exports) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createConditionalLogger = void 0;
+/**
+ * Wrap a Logger so that debug/info are gated behind debugLogging config,
+ * while warn/error always pass through.
+ */
+function createConditionalLogger(logger, configService) {
+    return {
+        debug: (...args) => {
+            var _a, _b;
+            if ((_b = (_a = configService === null || configService === void 0 ? void 0 : configService.store) === null || _a === void 0 ? void 0 : _a.tmuxPlugin) === null || _b === void 0 ? void 0 : _b.debugLogging)
+                logger.debug(...args);
+        },
+        info: (...args) => {
+            var _a, _b;
+            if ((_b = (_a = configService === null || configService === void 0 ? void 0 : configService.store) === null || _a === void 0 ? void 0 : _a.tmuxPlugin) === null || _b === void 0 ? void 0 : _b.debugLogging)
+                logger.info(...args);
+        },
+        warn: logger.warn.bind(logger),
+        error: logger.error.bind(logger),
+    };
+}
+exports.createConditionalLogger = createConditionalLogger;
+
+
+/***/ },
+
+/***/ "./src/services/tmux.service.ts"
+/*!**************************************!*\
+  !*** ./src/services/tmux.service.ts ***!
+  \**************************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxService = exports.TmuxOutputInterceptor = void 0;
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const tabby_core_1 = __webpack_require__(/*! tabby-core */ "tabby-core");
+const logHelper_1 = __webpack_require__(/*! ../logHelper */ "./src/logHelper.ts");
+const tabby_terminal_1 = __webpack_require__(/*! tabby-terminal */ "tabby-terminal");
+const rxjs_1 = __webpack_require__(/*! rxjs */ "rxjs");
+const session_1 = __webpack_require__(/*! ../session */ "./src/session.ts");
+const tmuxSessionTab_component_1 = __webpack_require__(/*! ../components/tmuxSessionTab.component */ "./src/components/tmuxSessionTab.component.ts");
+/**
+ * Middleware inserted at position 0 of the original session's middleware chain
+ * when entering tmux mode.  It captures raw output data for the tmux gateway
+ * and BLOCKS it from propagating further, so that other middleware plugins
+ * (e.g. trzsz) on the original session do not see tmux control mode data.
+ *
+ * Without this interceptor, trzsz middleware on the original session would
+ * detect trzsz protocol markers embedded in %output lines and trigger
+ * chooseSendFiles() a second time ("double file dialog" bug).
+ */
+class TmuxOutputInterceptor extends tabby_terminal_1.SessionMiddleware {
+    constructor() {
+        super(...arguments);
+        this._rawOutput = new rxjs_1.Subject();
+        /** Raw session output, before any middleware processing */
+        this.rawOutput$ = this._rawOutput.asObservable();
+        // feedFromTerminal is NOT overridden — terminal→session data flows
+        // through normally so the session can still receive input.
+    }
+    feedFromSession(data) {
+        // Capture raw data for the tmux gateway
+        this._rawOutput.next(data);
+        // Do NOT call super.feedFromSession() — this blocks data from
+        // propagating to the rest of the middleware chain (trzsz, etc.)
+    }
+}
+exports.TmuxOutputInterceptor = TmuxOutputInterceptor;
+let TmuxService = class TmuxService {
+    constructor(injector, appService, configService, log) {
+        this.injector = injector;
+        this.appService = appService;
+        this.configService = configService;
+        this.sessions = new Set();
+        this.logger = log.create('tmux-service');
+    }
+    get log() {
+        return (0, logHelper_1.createConditionalLogger)(this.logger, this.configService);
+    }
+    get isConnected() {
+        return this.sessions.size > 0;
+    }
+    get controller() {
+        var _a;
+        return ((_a = this.sessions.values().next().value) === null || _a === void 0 ? void 0 : _a.controller) || null;
+    }
+    /**
+     * Find the SessionContext that owns a given sessionTab.
+     */
+    findContextForTab(tab) {
+        for (const ctx of this.sessions) {
+            if (ctx.sessionTab === tab)
+                return ctx;
+        }
+        return undefined;
+    }
+    setupControllerEvents(context) {
+        context.subscriptions.push(context.controller.events.subscribe(event => {
+            // On initialized, replace the terminal tab with the session tab
+            if (event.type === 'initialized' && !context.sessionTab) {
+                this.replaceWithSessionTab(context);
+            }
+        }));
+    }
+    replaceWithSessionTab(context) {
+        if (context.sessionTab)
+            return;
+        this.log.info('Creating TmuxSessionTab...');
+        // Find the topmost parent tab (the actual tab listed in the top tab bar)
+        const topmostTab = context.terminalTab.topmostParent || context.terminalTab;
+        context.topmostTab = topmostTab;
+        // Remember the original index so we can replace in-place
+        const tabs = this.appService.tabs;
+        const index = tabs.indexOf(topmostTab);
+        context.topmostTabIndex = index;
+        // IMPORTANT: We must use openNewTabRaw, NOT openNewTab.
+        // openNewTab wraps non-SplitTab types in a wrapper SplitTab via wrapAndAddTab().
+        // But TmuxSessionTabComponent extends SplitTabComponent, and wrapAndAddTab's
+        // SplitTab.addTab(thing) has special logic: when thing instanceof SplitTabComponent,
+        // it extracts thing.root and then DESTROYS thing. This kills our component instance
+        // before it ever gets rendered, so ngOnInit/ngAfterViewInit never fire.
+        //
+        // openNewTabRaw adds the tab directly without wrapping, so our component's
+        // view is properly attached and lifecycle hooks execute normally.
+        const sessionTab = this.appService.openNewTabRaw({
+            type: tmuxSessionTab_component_1.TmuxSessionTabComponent,
+            inputs: {
+                existingController: context.controller,
+                profile: { sessionName: context.controller.getSessionName() },
+            },
+        });
+        context.sessionTab = sessionTab;
+        // Move the session tab to the same position as the original tab
+        if (index !== -1) {
+            const sessionIndex = tabs.indexOf(sessionTab);
+            if (sessionIndex !== -1) {
+                tabs.splice(sessionIndex, 1); // remove from end
+                tabs.splice(index, 0, sessionTab) // insert at original position
+                ;
+                this.appService.tabsChanged.next();
+            }
+        }
+        // Hide the original topmost tab
+        if (index !== -1) {
+            const origIndex = tabs.indexOf(topmostTab);
+            if (origIndex !== -1) {
+                tabs.splice(origIndex, 1);
+                this.appService.tabsChanged.next();
+            }
+        }
+        // When the session tab is closed (by user or disconnect), clean up
+        context.subscriptions.push(sessionTab.destroyed$.subscribe(() => {
+            context.sessionTab = undefined;
+        }));
+    }
+    async disconnectContext(context) {
+        var _a;
+        this.sessions.delete(context);
+        context.subscriptions.forEach(s => s.unsubscribe());
+        // Detach from tmux control mode so the tmux client process exits
+        // cleanly. Without this, the original terminal tab's PTY still has
+        // a running `tmux -CC attach` process, causing "tmux is still running"
+        // confirmation dialogs when the user tries to close the restored tab.
+        context.controller.gateway.detach();
+        // Remove the output interceptor from the original session's middleware chain
+        if (context.outputInterceptor) {
+            (_a = context.terminalTab.session) === null || _a === void 0 ? void 0 : _a.middleware.remove(context.outputInterceptor);
+            context.outputInterceptor = undefined;
+        }
+        await context.controller.destroy();
+        // Destroy the session tab (removes from tab bar)
+        if (context.sessionTab) {
+            context.sessionTab.destroy();
+            context.sessionTab = undefined;
+        }
+        // Restore the original topmost tab to the tab bar at its original position
+        if (context.topmostTab) {
+            const tabs = this.appService.tabs;
+            const insertAt = context.topmostTabIndex !== undefined
+                ? Math.min(context.topmostTabIndex, tabs.length)
+                : tabs.length;
+            tabs.splice(insertAt, 0, context.topmostTab);
+            this.appService.tabsChanged.next();
+            this.appService.selectTab(context.topmostTab);
+        }
+        this.log.info('Disconnected tmux context');
+    }
+    /**
+     * Disconnect from all sessions
+     */
+    async disconnect() {
+        for (const context of this.sessions) {
+            await this.disconnectContext(context);
+        }
+    }
+    /**
+     * Attach to tmux from an existing terminal tab.
+     * Replaces the terminal tab with a TmuxSessionTab, keeping the terminal tab
+     * hidden in context. On disconnect, the terminal tab is restored.
+     */
+    async attachToTerminal(terminalTab) {
+        var _a, _b;
+        const session = terminalTab.session;
+        if (!session) {
+            this.logger.error('Terminal tab has no session');
+            return;
+        }
+        this.log.info('Attaching tmux to existing terminal session');
+        const context = {
+            controller: null,
+            terminalTab,
+            subscriptions: []
+        };
+        // Insert a tmux output interceptor at position 0 of the session's
+        // middleware chain.  This captures raw output for the gateway and
+        // prevents trzsz (or other) middleware on the original session from
+        // seeing tmux control mode data (which would cause false positives).
+        const interceptor = new TmuxOutputInterceptor();
+        session.middleware.unshift(interceptor);
+        context.outputInterceptor = interceptor;
+        // Create a controller that uses the terminal's session for I/O
+        context.controller = new session_1.TmuxController(this.logger, this.injector, (data) => session.write(Buffer.from(data)), () => this.disconnectContext(context), this.configService);
+        // Subscribe to the interceptor's raw output to parse tmux control mode.
+        // Feed raw buffers directly — the gateway handles line buffering internally
+        // via executeData(), which properly handles TCP fragment boundaries.
+        context.subscriptions.push(interceptor.rawOutput$.subscribe((data) => {
+            context.controller.handleData(data);
+        }));
+        // Handle terminal tab closure (disconnect on close)
+        context.subscriptions.push(terminalTab.destroyed$.subscribe(() => {
+            this.log.info('Attached terminal tab closed, disconnecting session');
+            this.disconnectContext(context);
+        }));
+        this.sessions.add(context);
+        this.setupControllerEvents(context);
+        // Send the tmux -CC command to the terminal
+        const sessionName = (_b = (_a = this.configService.store.tmuxPlugin) === null || _a === void 0 ? void 0 : _a.defaultSessionName) !== null && _b !== void 0 ? _b : 'default';
+        session.write(Buffer.from(`tmux -CC new -A -s ${sessionName}\n`));
+    }
+};
+TmuxService.ctorParameters = () => [
+    { type: core_1.Injector },
+    { type: tabby_core_1.AppService },
+    { type: tabby_core_1.ConfigService },
+    { type: tabby_core_1.LogService }
+];
+TmuxService = __decorate([
+    (0, core_1.Injectable)({ providedIn: 'root' }),
+    __metadata("design:paramtypes", [core_1.Injector,
+        tabby_core_1.AppService,
+        tabby_core_1.ConfigService,
+        tabby_core_1.LogService])
+], TmuxService);
+exports.TmuxService = TmuxService;
+
+
+/***/ },
+
+/***/ "./src/session.ts"
+/*!************************!*\
+  !*** ./src/session.ts ***!
+  \************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxControllerSession = exports.TmuxController = exports.TmuxPaneSession = void 0;
+const rxjs_1 = __webpack_require__(/*! rxjs */ "rxjs");
+const tabby_terminal_1 = __webpack_require__(/*! tabby-terminal */ "tabby-terminal");
+const logHelper_1 = __webpack_require__(/*! ./logHelper */ "./src/logHelper.ts");
+const gateway_1 = __webpack_require__(/*! ./gateway */ "./src/gateway.ts");
+/**
+ * TmuxPaneSession - Represents a single tmux pane as a terminal session
+ */
+class TmuxPaneSession extends tabby_terminal_1.BaseSession {
+    constructor(logger, controller, paneId) {
+        super(logger);
+        this.controller = controller;
+        this.paneId = paneId;
+        /**
+         * Saved alternate screen content + cursor position, persisted after
+         * restorePaneHistory so that xterm.resize() (from setTmuxGrid after
+         * %layout-change) can re-apply it.  xterm.resize() clears the
+         * alternate screen buffer, so the content must be written again.
+         */
+        this.pendingAltRestore = null;
+        /**
+         * Incomplete screen-title sequence (ESC k ... ESC \) spanning
+         * multiple feedOutput calls.  Buffered until the closing ST arrives.
+         */
+        this._pendingTitleSeq = null;
+        this.open = true;
+        this.controller.registerPane(this.paneId, this);
+    }
+    async start() {
+        this.open = true;
+        // Restore history — for initial attach this is instant (pre-loaded
+        // during batch discovery); for runtime panes it falls back to
+        // capture-pane.
+        await this.controller.restorePaneHistory(this.paneId);
+    }
+    resize(_columns, _rows) {
+        // No-op by design. In tmux integration, tmux is authoritative over the
+        // cell grid: each pane's character size comes from the %layout-change
+        // string and is applied via TmuxPaneTabComponent.setTmuxGrid().
+        //
+        // The xterm frontend's automatic fit-to-container resizing is disabled
+        // for tmux panes (frontend.enableResizing = false), so this method
+        // should normally never be called. Sending refresh-client -C from here
+        // would re-introduce the resize feedback loop (pane refit → client
+        // size → tmux relayout → pane refit → ...), so we deliberately do
+        // nothing. Overall client size is driven only by the container size
+        // in TmuxSessionTabComponent.refreshClientSize().
+    }
+    write(data) {
+        this.controller.writeToPane(this.paneId, data);
+    }
+    // NOTE: feedFromTerminal is NOT overridden — it goes through the
+    // middleware chain (BaseSession.feedFromTerminal → middleware →
+    // outputToSession$ → write()) so that SessionMiddleware plugins
+    // such as trzsz can intercept terminal input.
+    kill(_signal) {
+        this.destroy();
+    }
+    async destroy() {
+        this.pendingAltRestore = null;
+        this._pendingTitleSeq = null;
+        await super.destroy();
+        this.controller.unregisterPane(this.paneId);
+    }
+    async gracefullyKillProcess() {
+        this.destroy();
+    }
+    supportsWorkingDirectory() {
+        return false;
+    }
+    async getWorkingDirectory() {
+        return null;
+    }
+    /**
+     * Public wrapper for the protected emitOutput().
+     * Used by TmuxController to deliver history and buffered output.
+     *
+     * Filters out screen/tmux "set window title" sequences (ESC k ... ESC \)
+     * which xterm.js does not recognize. Without filtering, zsh precmd/preexec
+     * hooks that set the terminal title via `print -Pn "\ek%s\e\\"` would leak
+     * the title text as visible output (e.g. `echo111` instead of `111`).
+     */
+    feedOutput(data) {
+        data = this.filterScreenTitleSequences(data);
+        if (data.length > 0) {
+            this.emitOutput(data);
+        }
+    }
+    /**
+     * Strip screen/tmux "set window title" sequences (ESC k ... ESC \)
+     * from the output stream.
+     *
+     * In screen/tmux, `ESC k <title> ESC \` sets the window/tab title.
+     * tmux processes these internally but also forwards them verbatim to
+     * control-mode clients. xterm.js does NOT handle this sequence — it
+     * only recognizes `ESC ] ... BEL/ST` (OSC) — so the title text leaks
+     * as visible content (e.g. the command name appears before output).
+     *
+     * Handles sequences that span multiple feedOutput calls by buffering
+     * the incomplete portion until the closing ST (ESC \) arrives.
+     */
+    filterScreenTitleSequences(data) {
+        // Prepend leftover from previous call
+        if (this._pendingTitleSeq) {
+            data = Buffer.concat([this._pendingTitleSeq, data]);
+            this._pendingTitleSeq = null;
+        }
+        const ESC = 0x1b;
+        const parts = [];
+        let pos = 0;
+        while (pos < data.length) {
+            // Find next ESC k (0x1b 0x6b)
+            let startIdx = -1;
+            for (let i = pos; i < data.length - 1; i++) {
+                if (data[i] === ESC && data[i + 1] === 0x6b) {
+                    startIdx = i;
+                    break;
+                }
+            }
+            if (startIdx < 0) {
+                // No more title sequences — emit the rest.
+                // Buffer a trailing ESC (0x1b) in case the next call
+                // starts with 0x6b ('k'), forming a split ESC k pair.
+                const tail = data[data.length - 1];
+                if (tail === ESC) {
+                    parts.push(data.subarray(pos, data.length - 1));
+                    this._pendingTitleSeq = data.subarray(data.length - 1);
+                }
+                else {
+                    parts.push(data.subarray(pos));
+                }
+                break;
+            }
+            // Emit data before the title sequence
+            if (startIdx > pos) {
+                parts.push(data.subarray(pos, startIdx));
+            }
+            // Search for ESC \ (ST: 0x1b 0x5c) after ESC k
+            let stIdx = -1;
+            for (let i = startIdx + 2; i < data.length - 1; i++) {
+                if (data[i] === ESC && data[i + 1] === 0x5c) {
+                    stIdx = i;
+                    break;
+                }
+            }
+            if (stIdx >= 0) {
+                // Complete sequence found — skip it entirely
+                pos = stIdx + 2;
+            }
+            else {
+                // Incomplete sequence — buffer from ESC k onwards
+                this._pendingTitleSeq = data.subarray(startIdx);
+                break;
+            }
+        }
+        if (parts.length === 0)
+            return Buffer.alloc(0);
+        if (parts.length === 1)
+            return parts[0];
+        return Buffer.concat(parts);
+    }
+}
+exports.TmuxPaneSession = TmuxPaneSession;
+/**
+ * TmuxController - Manages a tmux control mode session
+ *
+ * Based on iTerm2's TmuxController architecture.
+ */
+class TmuxController {
+    get log() {
+        return (0, logHelper_1.createConditionalLogger)(this.logger, this.configService);
+    }
+    constructor(logger, _injector, // eslint-disable-line @typescript-eslint/no-unused-vars
+    writer, closer, configService) {
+        this.logger = logger;
+        this.closer = closer;
+        this.configService = configService;
+        this.paneSessions = new Map();
+        this.windowStates = new Map();
+        this.knownPanes = new Set();
+        this.pendingPaneOutput = new Map();
+        /** Pre-loaded history from batch discovery (iTerm2-style). */
+        this.pendingSnapshots = new Map();
+        this.sessionName = '';
+        this.sessionId = -1;
+        this.attached = false;
+        this.activeWindowId = null;
+        this.events = new rxjs_1.Subject();
+        this.gateway = new gateway_1.TmuxGateway(logger, writer, configService);
+        this.setupGatewaySubscriptions();
+    }
+    setupGatewaySubscriptions() {
+        // Handle pane output
+        this.gateway.output$.subscribe(({ paneId, data }) => {
+            this.log.info(`Session received output for pane %${paneId}: ${data.length} bytes`);
+            if (this.paneSessions.has(paneId)) {
+                this.paneSessions.get(paneId).feedOutput(data);
+            }
+            else {
+                // Buffer output for panes not yet registered
+                if (!this.pendingPaneOutput.has(paneId)) {
+                    this.pendingPaneOutput.set(paneId, []);
+                }
+                this.pendingPaneOutput.get(paneId).push(data);
+            }
+        });
+        // Handle session changes - this is our main initialization point
+        // Like iTerm2, we immediately batch-discover all windows and panes
+        // instead of relying on delayed list-panes or passive %output discovery.
+        this.gateway.sessionChanged$.subscribe(({ sessionName, sessionId }) => {
+            this.sessionName = sessionName;
+            this.sessionId = sessionId;
+            this.attached = true;
+            this.log.info(`Attached to session: ${sessionName} ($${sessionId})`);
+            this.events.next({ type: 'session-changed', data: { sessionName, sessionId } });
+            // Immediate batch discovery — no setTimeout delay
+            this.discoverWindowsAndPanes();
+        });
+        // Handle window events
+        this.gateway.windowAdd$.subscribe(windowId => {
+            if (!this.windowStates.has(windowId)) {
+                this.windowStates.set(windowId, {
+                    id: windowId,
+                    name: `Window ${windowId}`,
+                    panes: new Set()
+                });
+            }
+            this.events.next({ type: 'window-add', windowId });
+            // For new windows created at runtime (after initial attach),
+            // tmux may NOT send %layout-change — only %window-add and %output.
+            // We must proactively discover the window's layout and panes.
+            // The window-add event has already been emitted above, so the UI
+            // has registered the window. discoverWindowsAndPanes will update
+            // the windowState with layout and emit pane-add + layout-change.
+            this.discoverWindowsAndPanes();
+        });
+        this.gateway.windowClose$.subscribe(windowId => {
+            this.windowStates.delete(windowId);
+            this.events.next({ type: 'window-close', windowId });
+        });
+        this.gateway.windowRenamed$.subscribe(({ windowId, name }) => {
+            const state = this.windowStates.get(windowId);
+            if (state) {
+                state.name = name;
+            }
+            this.events.next({ type: 'window-renamed', windowId, data: { name } });
+        });
+        // Handle pane close events (tmux 3.2+)
+        this.gateway.paneClose$.subscribe(({ windowId, paneId }) => {
+            this.log.info(`Pane %${paneId} closed in window @${windowId}`);
+            // Remove from known panes
+            this.knownPanes.delete(paneId);
+            // Remove from window state
+            const windowState = this.windowStates.get(windowId);
+            if (windowState) {
+                windowState.panes.delete(paneId);
+            }
+            // Clean up pane session if exists
+            const session = this.paneSessions.get(paneId);
+            if (session) {
+                session.destroy();
+                this.paneSessions.delete(paneId);
+            }
+            this.pendingPaneOutput.delete(paneId);
+            this.events.next({ type: 'pane-close', paneId, windowId });
+        });
+        // Handle layout changes — primary pane discovery trigger (iTerm2-style).
+        // Layout strings contain pane IDs. We extract new panes, capture their
+        // history/state, then emit pane-add events so the UI can create tabs
+        // with pre-loaded data. This replaces the old refreshPanes()-based
+        // discovery for runtime pane creation (split-window etc.).
+        //
+        // IMPORTANT: We do NOT emit 'layout-change' here. discoverPanesFromLayout
+        // emits it after pane-add events, ensuring syncLayout() always runs
+        // after pane tabs have been created.
+        this.gateway.layoutChange$.subscribe(({ windowId, layout, visibleLayout, zoomed }) => {
+            const state = this.windowStates.get(windowId);
+            if (state) {
+                state.layout = layout;
+            }
+            // Discover new panes from the layout string, then emit layout-change
+            this.discoverPanesFromLayout(windowId, layout, visibleLayout, zoomed);
+        });
+        // Handle exit
+        // Handle session-window-changed — the current window changed
+        this.gateway.sessionWindowChanged$.subscribe(({ windowId }) => {
+            this.log.info(`Active window changed to @${windowId}`);
+            this.activeWindowId = windowId;
+            this.events.next({ type: 'active-window-changed', windowId });
+        });
+        this.gateway.exit$.subscribe(reason => {
+            this.attached = false;
+            this.events.next({ type: 'exit', data: { reason } });
+            this.closer();
+        });
+        // Handle initialization
+        this.gateway.initialized$.subscribe(() => {
+            this.events.next({ type: 'initialized' });
+            this.discoverWindowsAndPanes();
+        });
+    }
+    /**
+     * Process a line from the underlying session
+     */
+    handleLine(line) {
+        this.gateway.executeLine(line);
+    }
+    /**
+     * Feed raw PTY data to the gateway for byte-level DCS buffering.
+     * Preferred over handleLine for proper handling of TCP fragments.
+     */
+    handleData(data) {
+        this.gateway.executeData(data);
+    }
+    /**
+     * Batch-discover all windows, panes, and history (iTerm2-style).
+     *
+     * Sequence (mirrors TmuxWindowOpener):
+     * 1. list-windows → discover windows with names + layout
+     * 2. list-panes → discover pane IDs
+     * 3. capture-pane for each new pane → pre-load history
+     * 4. emit pane-add events (history already in pendingHistory)
+     *
+     * By the time the UI creates a TmuxPaneTabComponent for a pane,
+     * its history is already captured — no async restore or buffering
+     * is needed at the session level.
+     */
+    async discoverWindowsAndPanes() {
+        this.log.info('Batch discovering windows and panes...');
+        try {
+            // Step 1: Discover all windows with names, layout and active flag
+            const winResult = await this.gateway.sendCommand('list-windows -F "#{window_id} #{window_name} #{window_active} #{window_layout}"', gateway_1.TMUX_COMMAND_TOLERATE_ERRORS);
+            const winLines = winResult.split(/[\r\n]+/).map(l => l.trim()).filter(l => l);
+            this.log.info(`Found ${winLines.length} window(s) from list-windows`);
+            for (const line of winLines) {
+                // Format: "@0 mywindow 1 1234,0x0,0,0{60x24,0,0,1}"
+                const match = line.match(/^@?(\d+)\s+(.+?)\s+([01])\s+(.+)$/);
+                if (match) {
+                    const windowId = parseInt(match[1]);
+                    const windowName = match[2];
+                    const active = match[3] === '1';
+                    const layout = match[4];
+                    if (active) {
+                        this.activeWindowId = windowId;
+                    }
+                    if (!this.windowStates.has(windowId)) {
+                        this.windowStates.set(windowId, {
+                            id: windowId,
+                            name: windowName,
+                            layout,
+                            panes: new Set()
+                        });
+                        this.events.next({ type: 'window-add', windowId });
+                    }
+                    else {
+                        const state = this.windowStates.get(windowId);
+                        state.name = windowName;
+                        state.layout = layout;
+                    }
+                }
+            }
+            // Step 2: Discover all panes and map to windows
+            const paneResult = await this.gateway.sendCommand('list-panes -s -F "#{pane_id} #{window_id}"', gateway_1.TMUX_COMMAND_TOLERATE_ERRORS);
+            const paneLines = paneResult.split(/[\r\n]+/).map(l => l.trim()).filter(l => l);
+            this.log.info(`Found ${paneLines.length} pane(s) from list-panes`);
+            const newPaneIds = [];
+            for (const line of paneLines) {
+                const match = line.match(/^%?(\d+)\s+@?(\d+)$/);
+                if (match) {
+                    const paneId = parseInt(match[1]);
+                    const windowId = parseInt(match[2]);
+                    let windowState = this.windowStates.get(windowId);
+                    if (!windowState) {
+                        windowState = {
+                            id: windowId,
+                            name: `Window ${windowId}`,
+                            panes: new Set()
+                        };
+                        this.windowStates.set(windowId, windowState);
+                        this.events.next({ type: 'window-add', windowId });
+                    }
+                    windowState.panes.add(paneId);
+                    if (!this.knownPanes.has(paneId)) {
+                        this.knownPanes.add(paneId);
+                        newPaneIds.push({ paneId, windowId });
+                    }
+                }
+            }
+            // Step 3: Batch-capture history + state for all new panes
+            // (mirrors iTerm2 TmuxWindowOpener)
+            if (newPaneIds.length > 0) {
+                this.log.info(`Capturing history/state for ${newPaneIds.length} new pane(s)...`);
+                await this.capturePaneSnapshots(newPaneIds);
+            }
+            // Step 4: Emit pane-add events — history is now pre-loaded
+            for (const { paneId, windowId } of newPaneIds) {
+                this.log.info(`Discovered pane %${paneId} in window @${windowId}`);
+                this.events.next({ type: 'pane-add', paneId, windowId });
+            }
+            // Step 5: Emit layout-change for all discovered windows so the UI
+            // can build the SplitContainer tree. Without this, syncLayout()
+            // never runs and panes remain registered but unmounted.
+            for (const windowState of this.windowStates.values()) {
+                if (windowState.layout) {
+                    this.events.next({
+                        type: 'layout-change',
+                        windowId: windowState.id,
+                        data: { layout: windowState.layout },
+                    });
+                }
+            }
+        }
+        catch (e) {
+            this.logger.warn('Failed to batch discover windows/panes:', e);
+        }
+    }
+    /**
+     * Public alias for discoverWindowsAndPanes.
+     * Used by external callers (context menu, session tab ngAfterViewInit)
+     * to trigger a full re-scan. For runtime pane creation (split-window),
+     * discoverPanesFromLayout() handles it via %layout-change instead.
+     */
+    async refreshPanes() {
+        return this.discoverWindowsAndPanes();
+    }
+    /**
+     * Discover new panes from a %layout-change notification (iTerm2-style).
+     *
+     * When tmux sends a layout change, the layout string contains all pane
+     * IDs for that window. We compare against known panes, capture
+     * history/state for any new ones, emit pane-add events, then emit
+     * layout-change so syncLayout() runs after pane tabs exist.
+     */
+    async discoverPanesFromLayout(windowId, layout, visibleLayout, zoomed) {
+        // Extract pane IDs from the layout string
+        // Pane IDs appear as trailing numbers in layout leaf nodes like "80x24,0,0,3"
+        // Match pattern: dimension,position,paneId  (paneId is the last number after the last comma)
+        const paneIdSet = new Set();
+        // Match all occurrences of ,\d+ at the end of leaf node specs
+        const leafPattern = /\d+x\d+,\d+,\d+,(\d+)/g;
+        let m;
+        while ((m = leafPattern.exec(layout)) !== null) {
+            paneIdSet.add(parseInt(m[1]));
+        }
+        if (paneIdSet.size === 0)
+            return;
+        const windowState = this.windowStates.get(windowId);
+        const newPaneIds = [];
+        for (const paneId of paneIdSet) {
+            if (windowState) {
+                windowState.panes.add(paneId);
+            }
+            if (!this.knownPanes.has(paneId)) {
+                this.knownPanes.add(paneId);
+                newPaneIds.push({ paneId, windowId });
+            }
+        }
+        if (newPaneIds.length > 0) {
+            this.log.info(`Discovered ${newPaneIds.length} new pane(s) from layout-change for window @${windowId}`);
+            // Capture history + state for new panes (same as discoverWindowsAndPanes Step 3)
+            await this.capturePaneSnapshots(newPaneIds);
+            // Emit pane-add events — history is now pre-loaded
+            for (const { paneId, windowId: wid } of newPaneIds) {
+                this.events.next({ type: 'pane-add', paneId, windowId: wid });
+            }
+        }
+        // Emit layout-change AFTER pane-add events, so syncLayout() can
+        // create views for newly discovered panes. This ordering is critical:
+        // pane-add → handlePaneAdd (creates pane tab) → layout-change →
+        // syncLayout (attaches view + builds SplitTree).
+        this.events.next({ type: 'layout-change', windowId, data: { layout, visibleLayout, zoomed } });
+    }
+    /**
+     * Capture history + state for an array of panes.
+     * Shared by discoverWindowsAndPanes() and discoverPanesFromLayout().
+     */
+    async capturePaneSnapshots(paneIds) {
+        const stateFormat = [
+            'pane_id=#{pane_id}',
+            'alternate_on=#{alternate_on}',
+            'alternate_saved_x=#{alternate_saved_x}',
+            'alternate_saved_y=#{alternate_saved_y}',
+            'cursor_x=#{cursor_x}',
+            'cursor_y=#{cursor_y}',
+            'scroll_region_upper=#{scroll_region_upper}',
+            'scroll_region_lower=#{scroll_region_lower}',
+            'pane_tabs=#{pane_tabs}',
+            'cursor_flag=#{cursor_flag}',
+            'insert_flag=#{insert_flag}',
+            'keypad_cursor_flag=#{keypad_cursor_flag}',
+            'keypad_flag=#{keypad_flag}',
+            'wrap_flag=#{wrap_flag}',
+            'bracket_paste_flag=#{bracket_paste_flag}',
+            'mouse_standard_flag=#{mouse_standard_flag}',
+            'mouse_button_flag=#{mouse_button_flag}',
+            'mouse_any_flag=#{mouse_any_flag}',
+        ].join('\t');
+        const captures = paneIds.map(async ({ paneId }) => {
+            try {
+                const [history, altHistory, stateResult] = await Promise.all([
+                    this.gateway.sendCommand(`capture-pane -peqJN -S- -t %${paneId}`, gateway_1.TMUX_COMMAND_TOLERATE_ERRORS),
+                    this.gateway.sendCommand(`capture-pane -peqJN -a -S- -t %${paneId}`, gateway_1.TMUX_COMMAND_TOLERATE_ERRORS),
+                    this.gateway.sendCommand(`list-panes -t %${paneId} -F "${stateFormat}"`, gateway_1.TMUX_COMMAND_TOLERATE_ERRORS),
+                ]);
+                const state = this.parsePaneState(stateResult, paneId);
+                this.pendingSnapshots.set(paneId, { history, altHistory, state });
+            }
+            catch (e) {
+                this.logger.warn(`Failed to capture snapshot for pane %${paneId}:`, e);
+            }
+        });
+        await Promise.all(captures);
+    }
+    // --- Pane Management ---
+    registerPane(paneId, session) {
+        this.paneSessions.set(paneId, session);
+        this.knownPanes.add(paneId);
+        // Flush any buffered output that arrived before registration
+        const buffered = this.pendingPaneOutput.get(paneId);
+        if (buffered) {
+            for (const data of buffered) {
+                session.feedOutput(data);
+            }
+            this.pendingPaneOutput.delete(paneId);
+        }
+    }
+    unregisterPane(paneId) {
+        this.paneSessions.delete(paneId);
+        this.pendingPaneOutput.delete(paneId);
+        this.pendingSnapshots.delete(paneId);
+    }
+    getPaneSession(paneId) {
+        return this.paneSessions.get(paneId);
+    }
+    hasPaneSession(paneId) {
+        return this.paneSessions.has(paneId);
+    }
+    resizePane(_paneId, columns, rows) {
+        // Use refresh-client -C to set client size
+        // This affects all panes uniformly in non-variable-size mode
+        // Note: paneId is ignored as tmux control mode uses uniform size
+        this.gateway.sendCommand(`refresh-client -C ${columns},${rows}`, gateway_1.TMUX_COMMAND_TOLERATE_ERRORS).catch(e => this.logger.warn('Resize failed:', e));
+    }
+    writeToPane(paneId, data) {
+        this.log.info(`Writing ${data.length} bytes to pane %${paneId}: <${data.toString('hex')}>`);
+        this.gateway.sendKeys(data, paneId);
+    }
+    /**
+     * Restore pane history.
+     *
+     * History + state are pre-loaded during discoverWindowsAndPanes()
+     * (stored in pendingSnapshots) — this is instant, no capture-pane needed.
+     * Both initial attach and runtime panes (split-window etc.) go through
+     * discoverWindowsAndPanes() before pane-add events are emitted, so
+     * pendingSnapshots is always populated by the time this runs.
+     *
+     * Restores (like iTerm2 setTmuxHistory:altHistory:state:):
+     * 1. Primary screen history
+     * 2. Alternate screen history (via CSI ?1047h / escape sequences)
+     * 3. Terminal state (cursor, scroll region, modes)
+     */
+    async restorePaneHistory(paneId) {
+        const snapshot = this.pendingSnapshots.get(paneId);
+        if (!snapshot) {
+            this.logger.warn(`No pre-loaded snapshot for pane %${paneId}, skipping`);
+            return;
+        }
+        this.pendingSnapshots.delete(paneId);
+        const session = this.paneSessions.get(paneId);
+        if (!session)
+            return;
+        const state = snapshot.state;
+        // Step 1: Write primary screen history to the primary screen.
+        // This sets up the scrollback so it's available if the user leaves
+        // the program running on the alternate screen.
+        if (snapshot.history) {
+            const normalized = snapshot.history.replace(/\n/g, '\r\n');
+            session.feedOutput(Buffer.from(normalized, 'utf-8'));
+        }
+        // Step 2: If the pane is on the alternate screen (vim, less, etc.),
+        // switch to it and write the alternate content.  We stay on alternate.
+        if (state.alternateOn) {
+            // ?1047h enters alternate screen and clears it
+            session.feedOutput(Buffer.from('\x1b[?1047h', 'utf-8'));
+            // Apply terminal state on the alternate screen (scroll region,
+            // modes, cursor visibility — NOT the cursor position yet).
+            this.applyPaneState(session, state);
+            // Write the alternate screen content at the top-left corner.
+            // capture-pane with -a gives us exactly what was on the alternate
+            // screen, starting from row 0.
+            if (snapshot.altHistory && snapshot.altHistory.trim()) {
+                session.feedOutput(Buffer.from('\x1b[H', 'utf-8'));
+                const normalized = snapshot.altHistory.replace(/\n/g, '\r\n');
+                session.feedOutput(Buffer.from(normalized, 'utf-8'));
+            }
+            // Re-apply cursor position after content write (content may
+            // have moved the cursor via embedded CUP sequences).
+            const csi = (s) => `\x1b[${s}`;
+            session.feedOutput(Buffer.from(csi(`${state.cursorY + 1};${state.cursorX + 1}H`), 'utf-8'));
+            // Save alternate screen data for re-apply after xterm.resize()
+            // (called by setTmuxGrid).  xterm.resize() clears the alternate
+            // screen buffer, so the content must be written again.
+            session.pendingAltRestore = {
+                content: snapshot.altHistory || '',
+                cursorY: state.cursorY,
+                cursorX: state.cursorX,
+                modes: this.buildModeSequences(state),
+            };
+        }
+        else {
+            // Normal mode — write alternate history if present (rare)
+            if (snapshot.altHistory && snapshot.altHistory.trim()) {
+                session.feedOutput(Buffer.from('\x1b[?1047h', 'utf-8'));
+                const normalized = snapshot.altHistory.replace(/\n/g, '\r\n');
+                session.feedOutput(Buffer.from(normalized, 'utf-8'));
+                session.feedOutput(Buffer.from('\x1b[?1047l', 'utf-8'));
+            }
+            // Apply terminal state (cursor, scroll region, modes)
+            this.applyPaneState(session, state);
+        }
+    }
+    /**
+     * Parse pane state from `list-panes -F` response.
+     * Mirrors iTerm2 TmuxStateParser.
+     */
+    parsePaneState(response, expectedPaneId) {
+        const state = {
+            paneId: expectedPaneId,
+            cursorX: 0, cursorY: 0,
+            alternateOn: false,
+            alternateSavedX: 0, alternateSavedY: 0,
+            scrollRegionUpper: 0, scrollRegionLower: 0,
+            wrapFlag: true, cursorFlag: true,
+            insertFlag: false, bracketPasteFlag: false,
+            keypadCursorFlag: false, keypadFlag: false,
+            paneTabs: [],
+            mouseStandardMode: false,
+            mouseButtonMode: false,
+            mouseAnyMode: false,
+        };
+        // `list-panes -t %paneId -F ...` may return multiple lines (one per pane
+        // in the window) or a single tab-separated line.  We must find the
+        // segment whose pane_id matches expectedPaneId — the first match is NOT
+        // necessarily the one we asked for.
+        const lines = response.split(/[\r\n]+/);
+        let targetLine = '';
+        for (const line of lines) {
+            if (!line.includes('pane_id='))
+                continue;
+            // Check if this line's pane_id matches our expected pane
+            const idMatch = line.match(/pane_id=%?(\d+)/);
+            if (idMatch && parseInt(idMatch[1]) === expectedPaneId) {
+                targetLine = line;
+                break;
+            }
+        }
+        // Fallback: if no exact match found, use the first line with pane_id
+        // (happens when list-panes returns only the target pane)
+        if (!targetLine) {
+            targetLine = lines.find(l => l.includes('pane_id=')) || '';
+        }
+        if (!targetLine)
+            return state;
+        for (const part of targetLine.split('\t')) {
+            const eqIdx = part.indexOf('=');
+            if (eqIdx < 0)
+                continue;
+            const key = part.substring(0, eqIdx);
+            const value = part.substring(eqIdx + 1);
+            const n = parseInt(value);
+            switch (key) {
+                case 'pane_id':
+                    state.paneId = n;
+                    break;
+                case 'cursor_x':
+                    state.cursorX = n;
+                    break;
+                case 'cursor_y':
+                    state.cursorY = n;
+                    break;
+                case 'alternate_on':
+                    state.alternateOn = n === 1;
+                    break;
+                case 'alternate_saved_x':
+                    state.alternateSavedX = n;
+                    break;
+                case 'alternate_saved_y':
+                    state.alternateSavedY = n;
+                    break;
+                case 'scroll_region_upper':
+                    state.scrollRegionUpper = n;
+                    break;
+                case 'scroll_region_lower':
+                    state.scrollRegionLower = n;
+                    break;
+                case 'pane_tabs':
+                    state.paneTabs = value.split(',').map(Number).filter(x => !isNaN(x));
+                    break;
+                case 'cursor_flag':
+                    state.cursorFlag = n === 1;
+                    break;
+                case 'insert_flag':
+                    state.insertFlag = n === 1;
+                    break;
+                case 'keypad_cursor_flag':
+                    state.keypadCursorFlag = n === 1;
+                    break;
+                case 'keypad_flag':
+                    state.keypadFlag = n === 1;
+                    break;
+                case 'wrap_flag':
+                    state.wrapFlag = n === 1;
+                    break;
+                case 'bracket_paste_flag':
+                    state.bracketPasteFlag = n === 1;
+                    break;
+                case 'mouse_standard_flag':
+                    state.mouseStandardMode = n === 1;
+                    break;
+                case 'mouse_button_flag':
+                    state.mouseButtonMode = n === 1;
+                    break;
+                case 'mouse_any_flag':
+                    state.mouseAnyMode = n === 1;
+                    break;
+            }
+        }
+        return state;
+    }
+    /**
+     * Apply parsed pane state to the terminal via ANSI escape sequences.
+     * Mirrors iTerm2 VT100ScreenMutableState.setTmuxState:.
+     */
+    applyPaneState(session, state) {
+        // Build a sequence of escape codes to restore terminal state.
+        const seq = this.buildModeSequences(state);
+        session.feedOutput(Buffer.from(seq, 'utf-8'));
+    }
+    /**
+     * Build ANSI escape sequences for terminal mode state (without alternate
+     * screen entry).  Used by both applyPaneState and pendingAltRestore.
+     */
+    buildModeSequences(state) {
+        const csi = (s) => `\x1b[${s}`;
+        const esc = (s) => `\x1b${s}`;
+        let seq = '';
+        // Set scroll region (DECSTBM)
+        if (state.scrollRegionUpper > 0 || state.scrollRegionLower > 0) {
+            seq += csi(`${state.scrollRegionUpper + 1};${state.scrollRegionLower + 1}r`);
+        }
+        // Restore cursor position (CUP)
+        seq += csi(`${state.cursorY + 1};${state.cursorX + 1}H`);
+        // Cursor visibility (DECTCEM)
+        seq += state.cursorFlag ? csi('?25h') : csi('?25l');
+        // Insert mode (IRM)
+        seq += state.insertFlag ? csi('4h') : csi('4l');
+        // Application cursor keys (DECCKM)
+        seq += state.keypadCursorFlag ? csi('?1h') : csi('?1l');
+        // Application keypad mode (DECKPAM / DECKPNM)
+        seq += state.keypadFlag ? esc('=') : esc('>');
+        // Bracketed paste mode
+        seq += state.bracketPasteFlag ? csi('?2004h') : csi('?2004l');
+        // Wrap mode (DECAWM)
+        seq += state.wrapFlag ? csi('?7h') : csi('?7l');
+        // Mouse tracking modes (?1000=normal, ?1002=button, ?1003=any)
+        seq += state.mouseStandardMode ? csi('?1000h') : csi('?1000l');
+        seq += state.mouseButtonMode ? csi('?1002h') : csi('?1002l');
+        seq += state.mouseAnyMode ? csi('?1003h') : csi('?1003l');
+        // Tab stops (HTS / TBC)
+        // TBC 3 = clear all tab stops, then HTS at each position
+        seq += csi('3g');
+        for (const col of state.paneTabs) {
+            seq += csi(`${col + 1}G`); // CUP to column
+            seq += esc('H'); // HTS
+        }
+        // Reset cursor back to final position (tab stop setup moves it)
+        seq += csi(`${state.cursorY + 1};${state.cursorX + 1}H`);
+        return seq;
+    }
+    /**
+     * Re-apply alternate screen content after xterm.resize() clears it.
+     * Called by TmuxPaneTabComponent.applyTmuxGrid() after resize.
+     */
+    reapplyAltContent(session) {
+        const alt = session.pendingAltRestore;
+        if (!alt)
+            return;
+        // Clear immediately — this is a one-shot re-apply after the initial
+        // resize.  After this, live tmux output maintains the alternate screen.
+        session.pendingAltRestore = null;
+        // Enter alternate screen (clears it)
+        session.feedOutput(Buffer.from('\x1b[?1047h', 'utf-8'));
+        // Apply modes
+        session.feedOutput(Buffer.from(alt.modes, 'utf-8'));
+        // Write content at top-left
+        if (alt.content && alt.content.trim()) {
+            session.feedOutput(Buffer.from('\x1b[H', 'utf-8'));
+            const normalized = alt.content.replace(/\n/g, '\r\n');
+            session.feedOutput(Buffer.from(normalized, 'utf-8'));
+        }
+        // Re-apply cursor position
+        const csi = (s) => `\x1b[${s}`;
+        session.feedOutput(Buffer.from(csi(`${alt.cursorY + 1};${alt.cursorX + 1}H`), 'utf-8'));
+    }
+    async killPane(paneId) {
+        await this.gateway.sendCommand(`kill-pane -t %${paneId}`, gateway_1.TMUX_COMMAND_TOLERATE_ERRORS);
+    }
+    // --- Window Operations ---
+    async createWindow() {
+        try {
+            const result = await this.gateway.sendCommand('new-window -P -F "#{window_id}"');
+            const match = result.match(/@(\d+)/);
+            return match ? parseInt(match[1]) : null;
+        }
+        catch (e) {
+            this.logger.warn('Failed to create window:', e);
+            return null;
+        }
+    }
+    async killWindow(windowId) {
+        await this.gateway.sendCommand(`kill-window -t @${windowId}`, gateway_1.TMUX_COMMAND_TOLERATE_ERRORS);
+    }
+    async renameWindow(windowId, name) {
+        await this.gateway.sendCommand(`rename-window -t @${windowId} "${name.replace(/"/g, '\\"')}"`, gateway_1.TMUX_COMMAND_TOLERATE_ERRORS);
+    }
+    // --- Session Operations ---
+    async detach() {
+        this.gateway.detach();
+    }
+    async listSessions() {
+        try {
+            const result = await this.gateway.sendCommand('list-sessions -F "#{session_id} #{session_name}"');
+            const sessions = [];
+            for (const line of result.split('\n')) {
+                const match = line.match(/^\$(\d+) (.+)$/);
+                if (match) {
+                    sessions.push({
+                        id: parseInt(match[1]),
+                        name: match[2]
+                    });
+                }
+            }
+            return sessions;
+        }
+        catch (e) {
+            this.logger.warn('Failed to list sessions:', e);
+            return [];
+        }
+    }
+    // --- Lifecycle ---
+    async destroy() {
+        // Close all pane sessions
+        for (const [_paneId, session] of this.paneSessions) {
+            await session.destroy();
+        }
+        this.paneSessions.clear();
+        this.attached = false;
+    }
+    // --- Getters ---
+    get isAttached() {
+        return this.attached;
+    }
+    getSessionName() {
+        return this.sessionName;
+    }
+    getSessionId() {
+        return this.sessionId;
+    }
+    getWindowState(windowId) {
+        return this.windowStates.get(windowId);
+    }
+    getAllWindowStates() {
+        return Array.from(this.windowStates.values());
+    }
+    getFirstWindowId() {
+        const first = this.windowStates.keys().next();
+        return first.done ? undefined : first.value;
+    }
+    /**
+     * Get the tmux-side active window ID, as reported by list-windows
+     * #{window_active} or %session-window-changed. Falls back to null.
+     */
+    getActiveWindowId() {
+        return this.activeWindowId;
+    }
+    /**
+     * Get all known pane IDs across all windows.
+     * Used by TmuxPaneTabComponent for "Focus all tmux panes" (sync input).
+     */
+    getAllPaneIds() {
+        return Array.from(this.knownPanes);
+    }
+}
+exports.TmuxController = TmuxController;
+exports.TmuxControllerSession = TmuxController;
+
+
+/***/ },
+
+/***/ "./src/settings.ts"
+/*!*************************!*\
+  !*** ./src/settings.ts ***!
+  \*************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxSettingsTabProvider = void 0;
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const tabby_settings_1 = __webpack_require__(/*! tabby-settings */ "tabby-settings");
+const settings_component_1 = __webpack_require__(/*! ./components/settings.component */ "./src/components/settings.component.ts");
+// eslint-disable-next-line new-cap
+let TmuxSettingsTabProvider = class TmuxSettingsTabProvider extends tabby_settings_1.SettingsTabProvider {
+    constructor() {
+        super(...arguments);
+        this.id = 'tmux';
+        this.icon = 'border-all';
+        this.title = 'Tmux';
+    }
+    getComponentType() {
+        return settings_component_1.TmuxSettingsTabComponent;
+    }
+};
+TmuxSettingsTabProvider = __decorate([
+    (0, core_1.Injectable)()
+], TmuxSettingsTabProvider);
+exports.TmuxSettingsTabProvider = TmuxSettingsTabProvider;
+
+
+/***/ },
+
+/***/ "./src/tabContextMenu.ts"
+/*!*******************************!*\
+  !*** ./src/tabContextMenu.ts ***!
+  \*******************************/
+(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.TmuxContextMenuProvider = void 0;
+const core_1 = __webpack_require__(/*! @angular/core */ "@angular/core");
+const tabby_core_1 = __webpack_require__(/*! tabby-core */ "tabby-core");
+const tabby_terminal_1 = __webpack_require__(/*! tabby-terminal */ "tabby-terminal");
+const tmux_service_1 = __webpack_require__(/*! ./services/tmux.service */ "./src/services/tmux.service.ts");
+const tmuxSessionTab_component_1 = __webpack_require__(/*! ./components/tmuxSessionTab.component */ "./src/components/tmuxSessionTab.component.ts");
+const tmuxPaneTab_component_1 = __webpack_require__(/*! ./components/tmuxPaneTab.component */ "./src/components/tmuxPaneTab.component.ts");
+/**
+ * TmuxContextMenuProvider - Adds tmux-related items to tab context menu.
+ *
+ * - On a terminal tab: "Enter Tmux Mode"
+ * - On a TmuxSessionTab / TmuxPaneTab: "Exit Tmux Mode" + Split + Close pane
+ */
+let TmuxContextMenuProvider = class TmuxContextMenuProvider extends tabby_core_1.TabContextMenuItemProvider {
+    constructor(tmuxService) {
+        super();
+        this.tmuxService = tmuxService;
+        this.weight = 5;
+    }
+    async getItems(tab, _tabHeader) {
+        // On a TmuxSessionTab: show exit option
+        if (tab instanceof tmuxSessionTab_component_1.TmuxSessionTabComponent) {
+            return [
+                {
+                    label: 'Exit Tmux Mode',
+                    click: async () => {
+                        await this.tmuxService.disconnect();
+                    },
+                },
+            ];
+        }
+        // On a TmuxPaneTab: show exit, split, and close pane
+        if (tab instanceof tmuxPaneTab_component_1.TmuxPaneTabComponent) {
+            const items = [
+                {
+                    label: 'Exit Tmux Mode',
+                    click: async () => {
+                        await this.tmuxService.disconnect();
+                    },
+                },
+                {
+                    label: 'Split',
+                    submenu: [
+                        { label: 'Right', click: () => this.splitPane(tab, 'right') },
+                        { label: 'Down', click: () => this.splitPane(tab, 'down') },
+                        { label: 'Left', click: () => this.splitPane(tab, 'left') },
+                        { label: 'Up', click: () => this.splitPane(tab, 'up') },
+                    ],
+                },
+                {
+                    label: 'Close',
+                    click: () => this.closePane(tab),
+                },
+            ];
+            return items;
+        }
+        // On a terminal tab: show enter tmux mode option
+        if (tab instanceof tabby_terminal_1.BaseTerminalTabComponent) {
+            return [
+                {
+                    label: 'Enter Tmux Mode',
+                    click: async () => {
+                        await this.tmuxService.attachToTerminal(tab);
+                    },
+                },
+            ];
+        }
+        return [];
+    }
+    async splitPane(paneTab, direction) {
+        const controller = paneTab.controller;
+        if (!controller)
+            return;
+        const paneId = paneTab.paneId;
+        const flagMap = {
+            'right': '-h',
+            'down': '-v',
+            'left': '-h -b',
+            'up': '-v -b',
+        };
+        const flag = flagMap[direction];
+        await controller.gateway.sendCommand(`split-window ${flag} -t %${paneId}`);
+        // Discover the new pane and trigger layout update
+        await controller.refreshPanes();
+    }
+    async closePane(paneTab) {
+        const controller = paneTab.controller;
+        if (!controller)
+            return;
+        await controller.killPane(paneTab.paneId);
+    }
+};
+TmuxContextMenuProvider.ctorParameters = () => [
+    { type: tmux_service_1.TmuxService }
+];
+TmuxContextMenuProvider = __decorate([
+    (0, core_1.Injectable)(),
+    __metadata("design:paramtypes", [tmux_service_1.TmuxService])
+], TmuxContextMenuProvider);
+exports.TmuxContextMenuProvider = TmuxContextMenuProvider;
+
+
+/***/ },
+
+/***/ "@angular/common"
+/*!**********************************!*\
+  !*** external "@angular/common" ***!
+  \**********************************/
+(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__angular_common__;
+
+/***/ },
+
+/***/ "@angular/core"
+/*!********************************!*\
+  !*** external "@angular/core" ***!
+  \********************************/
+(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__angular_core__;
+
+/***/ },
+
+/***/ "@angular/forms"
+/*!*********************************!*\
+  !*** external "@angular/forms" ***!
+  \*********************************/
+(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE__angular_forms__;
+
+/***/ },
+
+/***/ "rxjs"
+/*!***********************!*\
+  !*** external "rxjs" ***!
+  \***********************/
+(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE_rxjs__;
+
+/***/ },
+
+/***/ "tabby-core"
+/*!*****************************!*\
+  !*** external "tabby-core" ***!
+  \*****************************/
+(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE_tabby_core__;
+
+/***/ },
+
+/***/ "tabby-settings"
+/*!*********************************!*\
+  !*** external "tabby-settings" ***!
+  \*********************************/
+(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE_tabby_settings__;
+
+/***/ },
+
+/***/ "tabby-terminal"
+/*!*********************************!*\
+  !*** external "tabby-terminal" ***!
+  \*********************************/
+(module) {
+
+"use strict";
+module.exports = __WEBPACK_EXTERNAL_MODULE_tabby_terminal__;
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Check if module exists (development only)
+/******/ 		if (__webpack_modules__[moduleId] === undefined) {
+/******/ 			var e = new Error("Cannot find module '" + moduleId + "'");
+/******/ 			e.code = 'MODULE_NOT_FOUND';
+/******/ 			throw e;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			id: moduleId,
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/compat get default export */
+/******/ 	(() => {
+/******/ 		// getDefaultExport function for compatibility with non-harmony modules
+/******/ 		__webpack_require__.n = (module) => {
+/******/ 			var getter = module && module.__esModule ?
+/******/ 				() => (module['default']) :
+/******/ 				() => (module);
+/******/ 			__webpack_require__.d(getter, { a: getter });
+/******/ 			return getter;
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./src/index.ts");
+/******/ 	
+/******/ 	return __webpack_exports__;
+/******/ })()
+;
+});
+//# sourceMappingURL=index.js.map