@platless/axom-cli 0.5.9 → 0.6.52

package/dist/keepers/terminal/keeper.mjs

@@ -5072,375 +5072,10 @@ ${i3.join("\n")}
   }
 });
 
-// node_modules/@xterm/addon-serialize/lib/addon-serialize.js
-var require_addon_serialize = __commonJS({
-  "node_modules/@xterm/addon-serialize/lib/addon-serialize.js"(exports, module) {
-    !(function(t, e) {
-      "object" == typeof exports && "object" == typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define([], e) : "object" == typeof exports ? exports.SerializeAddon = e() : t.SerializeAddon = e();
-    })(globalThis, (() => (() => {
-      "use strict";
-      var t = { 992: (t2, e2, s2) => {
-        Object.defineProperty(e2, "__esModule", { value: true }), e2.DEFAULT_ANSI_COLORS = void 0;
-        const r2 = s2(993);
-        e2.DEFAULT_ANSI_COLORS = Object.freeze((() => {
-          const t3 = [r2.css.toColor("#2e3436"), r2.css.toColor("#cc0000"), r2.css.toColor("#4e9a06"), r2.css.toColor("#c4a000"), r2.css.toColor("#3465a4"), r2.css.toColor("#75507b"), r2.css.toColor("#06989a"), r2.css.toColor("#d3d7cf"), r2.css.toColor("#555753"), r2.css.toColor("#ef2929"), r2.css.toColor("#8ae234"), r2.css.toColor("#fce94f"), r2.css.toColor("#729fcf"), r2.css.toColor("#ad7fa8"), r2.css.toColor("#34e2e2"), r2.css.toColor("#eeeeec")], e3 = [0, 95, 135, 175, 215, 255];
-          for (let s3 = 0; s3 < 216; s3++) {
-            const i = e3[s3 / 36 % 6 | 0], o = e3[s3 / 6 % 6 | 0], n = e3[s3 % 6];
-            t3.push({ css: r2.channels.toCss(i, o, n), rgba: r2.channels.toRgba(i, o, n) });
-          }
-          for (let e4 = 0; e4 < 24; e4++) {
-            const s3 = 8 + 10 * e4;
-            t3.push({ css: r2.channels.toCss(s3, s3, s3), rgba: r2.channels.toRgba(s3, s3, s3) });
-          }
-          return t3;
-        })());
-      }, 993: (t2, e2) => {
-        Object.defineProperty(e2, "__esModule", { value: true }), e2.rgba = e2.rgb = e2.css = e2.color = e2.channels = e2.NULL_COLOR = void 0, e2.toPaddedHex = c, e2.contrastRatio = _;
-        let s2 = 0, r2 = 0, i = 0, o = 0;
-        var n, l, a, u, h;
-        function c(t3) {
-          const e3 = t3.toString(16);
-          return e3.length < 2 ? "0" + e3 : e3;
-        }
-        function _(t3, e3) {
-          return t3 < e3 ? (e3 + 0.05) / (t3 + 0.05) : (t3 + 0.05) / (e3 + 0.05);
-        }
-        e2.NULL_COLOR = { css: "#00000000", rgba: 0 }, (function(t3) {
-          t3.toCss = function(t4, e3, s3, r3) {
-            return void 0 !== r3 ? `#${c(t4)}${c(e3)}${c(s3)}${c(r3)}` : `#${c(t4)}${c(e3)}${c(s3)}`;
-          }, t3.toRgba = function(t4, e3, s3, r3 = 255) {
-            return (t4 << 24 | e3 << 16 | s3 << 8 | r3) >>> 0;
-          }, t3.toColor = function(e3, s3, r3, i2) {
-            return { css: t3.toCss(e3, s3, r3, i2), rgba: t3.toRgba(e3, s3, r3, i2) };
-          };
-        })(n || (e2.channels = n = {})), (function(t3) {
-          function e3(t4, e4) {
-            return o = Math.round(255 * e4), [s2, r2, i] = h.toChannels(t4.rgba), { css: n.toCss(s2, r2, i, o), rgba: n.toRgba(s2, r2, i, o) };
-          }
-          t3.blend = function(t4, e4) {
-            if (o = (255 & e4.rgba) / 255, 1 === o) return { css: e4.css, rgba: e4.rgba };
-            const l2 = e4.rgba >> 24 & 255, a2 = e4.rgba >> 16 & 255, u2 = e4.rgba >> 8 & 255, h2 = t4.rgba >> 24 & 255, c2 = t4.rgba >> 16 & 255, _2 = t4.rgba >> 8 & 255;
-            return s2 = h2 + Math.round((l2 - h2) * o), r2 = c2 + Math.round((a2 - c2) * o), i = _2 + Math.round((u2 - _2) * o), { css: n.toCss(s2, r2, i), rgba: n.toRgba(s2, r2, i) };
-          }, t3.isOpaque = function(t4) {
-            return !(255 & ~t4.rgba);
-          }, t3.ensureContrastRatio = function(t4, e4, s3) {
-            const r3 = h.ensureContrastRatio(t4.rgba, e4.rgba, s3);
-            if (r3) return n.toColor(r3 >> 24 & 255, r3 >> 16 & 255, r3 >> 8 & 255);
-          }, t3.opaque = function(t4) {
-            const e4 = (255 | t4.rgba) >>> 0;
-            return [s2, r2, i] = h.toChannels(e4), { css: n.toCss(s2, r2, i), rgba: e4 };
-          }, t3.opacity = e3, t3.multiplyOpacity = function(t4, s3) {
-            return o = 255 & t4.rgba, e3(t4, o * s3 / 255);
-          }, t3.toColorRGB = function(t4) {
-            return [t4.rgba >> 24 & 255, t4.rgba >> 16 & 255, t4.rgba >> 8 & 255];
-          };
-        })(l || (e2.color = l = {})), (function(t3) {
-          let e3, l2;
-          try {
-            const t4 = document.createElement("canvas");
-            t4.width = 1, t4.height = 1;
-            const s3 = t4.getContext("2d", { willReadFrequently: true });
-            s3 && (e3 = s3, e3.globalCompositeOperation = "copy", l2 = e3.createLinearGradient(0, 0, 1, 1));
-          } catch {
-          }
-          t3.toColor = function(t4) {
-            if (t4.match(/#[\da-f]{3,8}/i)) switch (t4.length) {
-              case 4:
-                return s2 = parseInt(t4.slice(1, 2).repeat(2), 16), r2 = parseInt(t4.slice(2, 3).repeat(2), 16), i = parseInt(t4.slice(3, 4).repeat(2), 16), n.toColor(s2, r2, i);
-              case 5:
-                return s2 = parseInt(t4.slice(1, 2).repeat(2), 16), r2 = parseInt(t4.slice(2, 3).repeat(2), 16), i = parseInt(t4.slice(3, 4).repeat(2), 16), o = parseInt(t4.slice(4, 5).repeat(2), 16), n.toColor(s2, r2, i, o);
-              case 7:
-                return { css: t4, rgba: (parseInt(t4.slice(1), 16) << 8 | 255) >>> 0 };
-              case 9:
-                return { css: t4, rgba: parseInt(t4.slice(1), 16) >>> 0 };
-            }
-            const a2 = t4.match(/rgba?\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*(,\s*(0|1|\d?\.(\d+))\s*)?\)/);
-            if (a2) return s2 = parseInt(a2[1]), r2 = parseInt(a2[2]), i = parseInt(a2[3]), o = Math.round(255 * (void 0 === a2[5] ? 1 : parseFloat(a2[5]))), n.toColor(s2, r2, i, o);
-            if (!e3 || !l2) throw new Error("css.toColor: Unsupported css format");
-            if (e3.fillStyle = l2, e3.fillStyle = t4, "string" != typeof e3.fillStyle) throw new Error("css.toColor: Unsupported css format");
-            if (e3.fillRect(0, 0, 1, 1), [s2, r2, i, o] = e3.getImageData(0, 0, 1, 1).data, 255 !== o) throw new Error("css.toColor: Unsupported css format");
-            return { rgba: n.toRgba(s2, r2, i, o), css: t4 };
-          };
-        })(a || (e2.css = a = {})), (function(t3) {
-          function e3(t4, e4, s3) {
-            const r3 = t4 / 255, i2 = e4 / 255, o2 = s3 / 255;
-            return 0.2126 * (r3 <= 0.03928 ? r3 / 12.92 : Math.pow((r3 + 0.055) / 1.055, 2.4)) + 0.7152 * (i2 <= 0.03928 ? i2 / 12.92 : Math.pow((i2 + 0.055) / 1.055, 2.4)) + 0.0722 * (o2 <= 0.03928 ? o2 / 12.92 : Math.pow((o2 + 0.055) / 1.055, 2.4));
-          }
-          t3.relativeLuminance = function(t4) {
-            return e3(t4 >> 16 & 255, t4 >> 8 & 255, 255 & t4);
-          }, t3.relativeLuminance2 = e3;
-        })(u || (e2.rgb = u = {})), (function(t3) {
-          function e3(t4, e4, s3) {
-            const r3 = t4 >> 24 & 255, i2 = t4 >> 16 & 255, o2 = t4 >> 8 & 255;
-            let n2 = e4 >> 24 & 255, l3 = e4 >> 16 & 255, a2 = e4 >> 8 & 255, h2 = _(u.relativeLuminance2(n2, l3, a2), u.relativeLuminance2(r3, i2, o2));
-            for (; h2 < s3 && (n2 > 0 || l3 > 0 || a2 > 0); ) n2 -= Math.max(0, Math.ceil(0.1 * n2)), l3 -= Math.max(0, Math.ceil(0.1 * l3)), a2 -= Math.max(0, Math.ceil(0.1 * a2)), h2 = _(u.relativeLuminance2(n2, l3, a2), u.relativeLuminance2(r3, i2, o2));
-            return (n2 << 24 | l3 << 16 | a2 << 8 | 255) >>> 0;
-          }
-          function l2(t4, e4, s3) {
-            const r3 = t4 >> 24 & 255, i2 = t4 >> 16 & 255, o2 = t4 >> 8 & 255;
-            let n2 = e4 >> 24 & 255, l3 = e4 >> 16 & 255, a2 = e4 >> 8 & 255, h2 = _(u.relativeLuminance2(n2, l3, a2), u.relativeLuminance2(r3, i2, o2));
-            for (; h2 < s3 && (n2 < 255 || l3 < 255 || a2 < 255); ) n2 = Math.min(255, n2 + Math.ceil(0.1 * (255 - n2))), l3 = Math.min(255, l3 + Math.ceil(0.1 * (255 - l3))), a2 = Math.min(255, a2 + Math.ceil(0.1 * (255 - a2))), h2 = _(u.relativeLuminance2(n2, l3, a2), u.relativeLuminance2(r3, i2, o2));
-            return (n2 << 24 | l3 << 16 | a2 << 8 | 255) >>> 0;
-          }
-          t3.blend = function(t4, e4) {
-            if (o = (255 & e4) / 255, 1 === o) return e4;
-            const l3 = e4 >> 24 & 255, a2 = e4 >> 16 & 255, u2 = e4 >> 8 & 255, h2 = t4 >> 24 & 255, c2 = t4 >> 16 & 255, _2 = t4 >> 8 & 255;
-            return s2 = h2 + Math.round((l3 - h2) * o), r2 = c2 + Math.round((a2 - c2) * o), i = _2 + Math.round((u2 - _2) * o), n.toRgba(s2, r2, i);
-          }, t3.ensureContrastRatio = function(t4, s3, r3) {
-            const i2 = u.relativeLuminance(t4 >> 8), o2 = u.relativeLuminance(s3 >> 8);
-            if (_(i2, o2) < r3) {
-              if (o2 < i2) {
-                const o3 = e3(t4, s3, r3), n3 = _(i2, u.relativeLuminance(o3 >> 8));
-                if (n3 < r3) {
-                  const e4 = l2(t4, s3, r3);
-                  return n3 > _(i2, u.relativeLuminance(e4 >> 8)) ? o3 : e4;
-                }
-                return o3;
-              }
-              const n2 = l2(t4, s3, r3), a2 = _(i2, u.relativeLuminance(n2 >> 8));
-              if (a2 < r3) {
-                const o3 = e3(t4, s3, r3);
-                return a2 > _(i2, u.relativeLuminance(o3 >> 8)) ? n2 : o3;
-              }
-              return n2;
-            }
-          }, t3.reduceLuminance = e3, t3.increaseLuminance = l2, t3.toChannels = function(t4) {
-            return [t4 >> 24 & 255, t4 >> 16 & 255, t4 >> 8 & 255, 255 & t4];
-          };
-        })(h || (e2.rgba = h = {}));
-      } }, e = {};
-      function s(r2) {
-        var i = e[r2];
-        if (void 0 !== i) return i.exports;
-        var o = e[r2] = { exports: {} };
-        return t[r2](o, o.exports, s), o.exports;
-      }
-      var r = {};
-      return (() => {
-        var t2 = r;
-        Object.defineProperty(t2, "__esModule", { value: true }), t2.HTMLSerializeHandler = t2.SerializeAddon = void 0;
-        const e2 = s(992);
-        function i(t3, e3, s2) {
-          return Math.max(e3, Math.min(t3, s2));
-        }
-        class o {
-          constructor(t3) {
-            this._buffer = t3;
-          }
-          serialize(t3, e3) {
-            const s2 = this._buffer.getNullCell(), r2 = this._buffer.getNullCell();
-            let i2 = s2;
-            const o2 = t3.start.y, n2 = t3.end.y, l2 = t3.start.x, a2 = t3.end.x;
-            this._beforeSerialize(n2 - o2, o2, n2);
-            for (let e4 = o2; e4 <= n2; e4++) {
-              const o3 = this._buffer.getLine(e4);
-              if (o3) {
-                const n3 = e4 === t3.start.y ? l2 : 0, u2 = e4 === t3.end.y ? a2 : o3.length;
-                for (let t4 = n3; t4 < u2; t4++) {
-                  const n4 = o3.getCell(t4, i2 === s2 ? r2 : s2);
-                  n4 ? (this._nextCell(n4, i2, e4, t4), i2 = n4) : console.warn(`Can't get cell at row=${e4}, col=${t4}`);
-                }
-              }
-              this._rowEnd(e4, e4 === n2);
-            }
-            return this._afterSerialize(), this._serializeString(e3);
-          }
-          _nextCell(t3, e3, s2, r2) {
-          }
-          _rowEnd(t3, e3) {
-          }
-          _beforeSerialize(t3, e3, s2) {
-          }
-          _afterSerialize() {
-          }
-          _serializeString(t3) {
-            return "";
-          }
-        }
-        function n(t3, e3) {
-          return t3.getFgColorMode() === e3.getFgColorMode() && t3.getFgColor() === e3.getFgColor();
-        }
-        function l(t3, e3) {
-          return t3.getBgColorMode() === e3.getBgColorMode() && t3.getBgColor() === e3.getBgColor();
-        }
-        function a(t3, e3) {
-          return t3.isInverse() === e3.isInverse() && t3.isBold() === e3.isBold() && t3.isUnderline() === e3.isUnderline() && t3.isOverline() === e3.isOverline() && t3.isBlink() === e3.isBlink() && t3.isInvisible() === e3.isInvisible() && t3.isItalic() === e3.isItalic() && t3.isDim() === e3.isDim() && t3.isStrikethrough() === e3.isStrikethrough();
-        }
-        class u extends o {
-          constructor(t3, e3) {
-            super(t3), this._terminal = e3, this._rowIndex = 0, this._allRows = new Array(), this._allRowSeparators = new Array(), this._currentRow = "", this._nullCellCount = 0, this._cursorStyle = this._buffer.getNullCell(), this._cursorStyleRow = 0, this._cursorStyleCol = 0, this._backgroundCell = this._buffer.getNullCell(), this._firstRow = 0, this._lastCursorRow = 0, this._lastCursorCol = 0, this._lastContentCursorRow = 0, this._lastContentCursorCol = 0, this._thisRowLastChar = this._buffer.getNullCell(), this._thisRowLastSecondChar = this._buffer.getNullCell(), this._nextRowFirstChar = this._buffer.getNullCell();
-          }
-          _beforeSerialize(t3, e3, s2) {
-            this._allRows = new Array(t3), this._lastContentCursorRow = e3, this._lastCursorRow = e3, this._firstRow = e3;
-          }
-          _rowEnd(t3, e3) {
-            this._nullCellCount > 0 && !l(this._cursorStyle, this._backgroundCell) && (this._currentRow += `\x1B[${this._nullCellCount}X`);
-            let s2 = "";
-            if (!e3) {
-              t3 - this._firstRow >= this._terminal.rows && this._buffer.getLine(this._cursorStyleRow)?.getCell(this._cursorStyleCol, this._backgroundCell);
-              const e4 = this._buffer.getLine(t3), r2 = this._buffer.getLine(t3 + 1);
-              if (r2.isWrapped) {
-                s2 = "";
-                const i2 = e4.getCell(e4.length - 1, this._thisRowLastChar), o2 = e4.getCell(e4.length - 2, this._thisRowLastSecondChar), n2 = r2.getCell(0, this._nextRowFirstChar), a2 = n2.getWidth() > 1;
-                let u2 = false;
-                (n2.getChars() && a2 ? this._nullCellCount <= 1 : this._nullCellCount <= 0) && ((i2.getChars() || 0 === i2.getWidth()) && l(i2, n2) && (u2 = true), a2 && (o2.getChars() || 0 === o2.getWidth()) && l(i2, n2) && l(o2, n2) && (u2 = true)), u2 || (s2 = "-".repeat(this._nullCellCount + 1), s2 += "\x1B[1D\x1B[1X", this._nullCellCount > 0 && (s2 += "\x1B[A", s2 += `\x1B[${e4.length - this._nullCellCount}C`, s2 += `\x1B[${this._nullCellCount}X`, s2 += `\x1B[${e4.length - this._nullCellCount}D`, s2 += "\x1B[B"), this._lastContentCursorRow = t3 + 1, this._lastContentCursorCol = 0, this._lastCursorRow = t3 + 1, this._lastCursorCol = 0);
-              } else s2 = "\r\n", this._lastCursorRow = t3 + 1, this._lastCursorCol = 0;
-            }
-            this._allRows[this._rowIndex] = this._currentRow, this._allRowSeparators[this._rowIndex++] = s2, this._currentRow = "", this._nullCellCount = 0;
-          }
-          _diffStyle(t3, e3) {
-            const s2 = [], r2 = !n(t3, e3), i2 = !l(t3, e3), o2 = !a(t3, e3);
-            if (r2 || i2 || o2) if (t3.isAttributeDefault()) e3.isAttributeDefault() || s2.push(0);
-            else {
-              if (r2) {
-                const e4 = t3.getFgColor();
-                t3.isFgRGB() ? s2.push(38, 2, e4 >>> 16 & 255, e4 >>> 8 & 255, 255 & e4) : t3.isFgPalette() ? e4 >= 16 ? s2.push(38, 5, e4) : s2.push(8 & e4 ? 90 + (7 & e4) : 30 + (7 & e4)) : s2.push(39);
-              }
-              if (i2) {
-                const e4 = t3.getBgColor();
-                t3.isBgRGB() ? s2.push(48, 2, e4 >>> 16 & 255, e4 >>> 8 & 255, 255 & e4) : t3.isBgPalette() ? e4 >= 16 ? s2.push(48, 5, e4) : s2.push(8 & e4 ? 100 + (7 & e4) : 40 + (7 & e4)) : s2.push(49);
-              }
-              o2 && (t3.isInverse() !== e3.isInverse() && s2.push(t3.isInverse() ? 7 : 27), t3.isBold() !== e3.isBold() && s2.push(t3.isBold() ? 1 : 22), t3.isUnderline() !== e3.isUnderline() && s2.push(t3.isUnderline() ? 4 : 24), t3.isOverline() !== e3.isOverline() && s2.push(t3.isOverline() ? 53 : 55), t3.isBlink() !== e3.isBlink() && s2.push(t3.isBlink() ? 5 : 25), t3.isInvisible() !== e3.isInvisible() && s2.push(t3.isInvisible() ? 8 : 28), t3.isItalic() !== e3.isItalic() && s2.push(t3.isItalic() ? 3 : 23), t3.isDim() !== e3.isDim() && s2.push(t3.isDim() ? 2 : 22), t3.isStrikethrough() !== e3.isStrikethrough() && s2.push(t3.isStrikethrough() ? 9 : 29));
-            }
-            return s2;
-          }
-          _nextCell(t3, e3, s2, r2) {
-            if (0 === t3.getWidth()) return;
-            const i2 = "" === t3.getChars(), o2 = this._diffStyle(t3, this._cursorStyle);
-            if (i2 ? !l(this._cursorStyle, t3) : o2.length > 0) {
-              this._nullCellCount > 0 && (l(this._cursorStyle, this._backgroundCell) || (this._currentRow += `\x1B[${this._nullCellCount}X`), this._currentRow += `\x1B[${this._nullCellCount}C`, this._nullCellCount = 0), this._lastContentCursorRow = this._lastCursorRow = s2, this._lastContentCursorCol = this._lastCursorCol = r2, this._currentRow += `\x1B[${o2.join(";")}m`;
-              const t4 = this._buffer.getLine(s2);
-              void 0 !== t4 && (t4.getCell(r2, this._cursorStyle), this._cursorStyleRow = s2, this._cursorStyleCol = r2);
-            }
-            i2 ? this._nullCellCount += t3.getWidth() : (this._nullCellCount > 0 && (l(this._cursorStyle, this._backgroundCell) || (this._currentRow += `\x1B[${this._nullCellCount}X`), this._currentRow += `\x1B[${this._nullCellCount}C`, this._nullCellCount = 0), this._currentRow += t3.getChars(), this._lastContentCursorRow = this._lastCursorRow = s2, this._lastContentCursorCol = this._lastCursorCol = r2 + t3.getWidth());
-          }
-          _serializeString(t3) {
-            let e3 = this._allRows.length;
-            this._buffer.length - this._firstRow <= this._terminal.rows && (e3 = this._lastContentCursorRow + 1 - this._firstRow, this._lastCursorCol = this._lastContentCursorCol, this._lastCursorRow = this._lastContentCursorRow);
-            let s2 = "";
-            for (let t4 = 0; t4 < e3; t4++) s2 += this._allRows[t4], t4 + 1 < e3 && (s2 += this._allRowSeparators[t4]);
-            if (!t3) {
-              const t4 = this._buffer.baseY + this._buffer.cursorY, e4 = this._buffer.cursorX, i3 = (t5) => {
-                t5 > 0 ? s2 += `\x1B[${t5}C` : t5 < 0 && (s2 += `\x1B[${-t5}D`);
-              };
-              (t4 !== this._lastCursorRow || e4 !== this._lastCursorCol) && ((r2 = t4 - this._lastCursorRow) > 0 ? s2 += `\x1B[${r2}B` : r2 < 0 && (s2 += `\x1B[${-r2}A`), i3(e4 - this._lastCursorCol));
-            }
-            var r2;
-            const i2 = this._terminal._core._inputHandler._curAttrData, o2 = this._diffStyle(i2, this._cursorStyle);
-            return o2.length > 0 && (s2 += `\x1B[${o2.join(";")}m`), s2;
-          }
-        }
-        t2.SerializeAddon = class {
-          activate(t3) {
-            this._terminal = t3;
-          }
-          _serializeBufferByScrollback(t3, e3, s2) {
-            const r2 = e3.length, o2 = void 0 === s2 ? r2 : i(s2 + t3.rows, 0, r2);
-            return this._serializeBufferByRange(t3, e3, { start: r2 - o2, end: r2 - 1 }, false);
-          }
-          _serializeBufferByRange(t3, e3, s2, r2) {
-            return new u(e3, t3).serialize({ start: { x: 0, y: "number" == typeof s2.start ? s2.start : s2.start.line }, end: { x: t3.cols, y: "number" == typeof s2.end ? s2.end : s2.end.line } }, r2);
-          }
-          _serializeBufferAsHTML(t3, e3) {
-            const s2 = t3.buffer.active, r2 = new h(s2, t3, e3), o2 = e3.onlySelection ?? false, n2 = e3.range;
-            if (n2) return r2.serialize({ start: { x: n2.startCol, y: (n2.startLine, n2.startLine) }, end: { x: t3.cols, y: (n2.endLine, n2.endLine) } });
-            if (!o2) {
-              const o3 = s2.length, n3 = e3.scrollback, l3 = void 0 === n3 ? o3 : i(n3 + t3.rows, 0, o3);
-              return r2.serialize({ start: { x: 0, y: o3 - l3 }, end: { x: t3.cols, y: o3 - 1 } });
-            }
-            const l2 = this._terminal?.getSelectionPosition();
-            return void 0 !== l2 ? r2.serialize({ start: { x: l2.start.x, y: l2.start.y }, end: { x: l2.end.x, y: l2.end.y } }) : "";
-          }
-          _serializeModes(t3) {
-            let e3 = "";
-            const s2 = t3.modes;
-            if (s2.applicationCursorKeysMode && (e3 += "\x1B[?1h"), s2.applicationKeypadMode && (e3 += "\x1B[?66h"), s2.bracketedPasteMode && (e3 += "\x1B[?2004h"), s2.insertMode && (e3 += "\x1B[4h"), s2.originMode && (e3 += "\x1B[?6h"), s2.reverseWraparoundMode && (e3 += "\x1B[?45h"), s2.sendFocusMode && (e3 += "\x1B[?1004h"), false === s2.wraparoundMode && (e3 += "\x1B[?7l"), "none" !== s2.mouseTrackingMode) switch (s2.mouseTrackingMode) {
-              case "x10":
-                e3 += "\x1B[?9h";
-                break;
-              case "vt200":
-                e3 += "\x1B[?1000h";
-                break;
-              case "drag":
-                e3 += "\x1B[?1002h";
-                break;
-              case "any":
-                e3 += "\x1B[?1003h";
-            }
-            return e3;
-          }
-          serialize(t3) {
-            if (!this._terminal) throw new Error("Cannot use addon until it has been loaded");
-            let e3 = t3?.range ? this._serializeBufferByRange(this._terminal, this._terminal.buffer.normal, t3.range, true) : this._serializeBufferByScrollback(this._terminal, this._terminal.buffer.normal, t3?.scrollback);
-            return t3?.excludeAltBuffer || "alternate" !== this._terminal.buffer.active.type || (e3 += `\x1B[?1049h\x1B[H${this._serializeBufferByScrollback(this._terminal, this._terminal.buffer.alternate, void 0)}`), t3?.excludeModes || (e3 += this._serializeModes(this._terminal)), e3;
-          }
-          serializeAsHTML(t3) {
-            if (!this._terminal) throw new Error("Cannot use addon until it has been loaded");
-            return this._serializeBufferAsHTML(this._terminal, t3 || {});
-          }
-          dispose() {
-          }
-        };
-        class h extends o {
-          constructor(t3, s2, r2) {
-            super(t3), this._terminal = s2, this._options = r2, this._currentRow = "", this._htmlContent = "", s2._core._themeService ? this._ansiColors = s2._core._themeService.colors.ansi : this._ansiColors = e2.DEFAULT_ANSI_COLORS;
-          }
-          _padStart(t3, e3, s2) {
-            return e3 |= 0, s2 = s2 ?? " ", t3.length > e3 ? t3 : ((e3 -= t3.length) > s2.length && (s2 += s2.repeat(e3 / s2.length)), s2.slice(0, e3) + t3);
-          }
-          _beforeSerialize(t3, e3, s2) {
-            this._htmlContent += "<html><body><!--StartFragment--><pre>";
-            let r2 = "#000000", i2 = "#ffffff";
-            this._options.includeGlobalBackground && (r2 = this._terminal.options.theme?.foreground ?? "#ffffff", i2 = this._terminal.options.theme?.background ?? "#000000");
-            const o2 = [];
-            o2.push("color: " + r2 + ";"), o2.push("background-color: " + i2 + ";"), o2.push("font-family: " + this._terminal.options.fontFamily + ";"), o2.push("font-size: " + this._terminal.options.fontSize + "px;"), this._htmlContent += "<div style='" + o2.join(" ") + "'>";
-          }
-          _afterSerialize() {
-            this._htmlContent += "</div>", this._htmlContent += "</pre><!--EndFragment--></body></html>";
-          }
-          _rowEnd(t3, e3) {
-            this._htmlContent += "<div><span>" + this._currentRow + "</span></div>", this._currentRow = "";
-          }
-          _getHexColor(t3, e3) {
-            const s2 = e3 ? t3.getFgColor() : t3.getBgColor();
-            return (e3 ? t3.isFgRGB() : t3.isBgRGB()) ? "#" + [s2 >> 16 & 255, s2 >> 8 & 255, 255 & s2].map(((t4) => this._padStart(t4.toString(16), 2, "0"))).join("") : (e3 ? t3.isFgPalette() : t3.isBgPalette()) ? this._ansiColors[s2].css : void 0;
-          }
-          _diffStyle(t3, e3) {
-            const s2 = [], r2 = !n(t3, e3), i2 = !l(t3, e3), o2 = !a(t3, e3);
-            if (r2 || i2 || o2) {
-              const e4 = this._getHexColor(t3, true);
-              e4 && s2.push("color: " + e4 + ";");
-              const r3 = this._getHexColor(t3, false);
-              return r3 && s2.push("background-color: " + r3 + ";"), t3.isInverse() && s2.push("color: #000000; background-color: #BFBFBF;"), t3.isBold() && s2.push("font-weight: bold;"), t3.isUnderline() && t3.isOverline() ? s2.push("text-decoration: overline underline;") : t3.isUnderline() ? s2.push("text-decoration: underline;") : t3.isOverline() && s2.push("text-decoration: overline;"), t3.isBlink() && s2.push("text-decoration: blink;"), t3.isInvisible() && s2.push("visibility: hidden;"), t3.isItalic() && s2.push("font-style: italic;"), t3.isDim() && s2.push("opacity: 0.5;"), t3.isStrikethrough() && s2.push("text-decoration: line-through;"), s2;
-            }
-          }
-          _nextCell(t3, e3, s2, r2) {
-            if (0 === t3.getWidth()) return;
-            const i2 = "" === t3.getChars(), o2 = this._diffStyle(t3, e3);
-            o2 && (this._currentRow += 0 === o2.length ? "</span><span>" : "</span><span style='" + o2.join(" ") + "'>"), this._currentRow += i2 ? " " : (function(t4) {
-              switch (t4) {
-                case "&":
-                  return "&amp;";
-                case "<":
-                  return "&lt;";
-              }
-              return t4;
-            })(t3.getChars());
-          }
-          _serializeString() {
-            return this._htmlContent;
-          }
-        }
-        t2.HTMLSerializeHandler = h;
-      })(), r;
-    })()));
-  }
-});
-
 // src/workstation/keepers/terminal/main.ts
 import { realpathSync } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import path5, { sep } from "node:path";
+import { createRequire as createRequire3 } from "node:module";
+import path6, { sep } from "node:path";
 
 // src/workstation/keepers/kit/bootstrap.ts
 import { readFileSync, unlinkSync as unlinkSync2 } from "node:fs";
@@ -5954,19 +5589,19 @@ var Connection = class {
       this.subscriptions.get(frame.stream)?.grant(frame.n, frame.bytes);
       return;
     }
-    const reply = (ok, payload, then) => this.send(ok ? { t: "res", id: frame.id, ok: true, result: payload } : { t: "res", id: frame.id, ok: false, error: payload }, then);
-    const fail = (code, message, then) => reply(false, wireError(code, message), then);
+    const reply = (ok2, payload, then) => this.send(ok2 ? { t: "res", id: frame.id, ok: true, result: payload } : { t: "res", id: frame.id, ok: false, error: payload }, then);
+    const fail2 = (code, message, then) => reply(false, wireError(code, message), then);
     const { method } = frame;
     const params = frame.params ?? {};
     if (method === "keeper.hello") {
       const token = typeof params.token === "string" ? Buffer.from(params.token) : Buffer.alloc(0);
       const expected = Buffer.from(this.server.token);
       if (token.length !== expected.length || !timingSafeEqual(token, expected)) {
-        fail(ErrorCode.badToken, "Invalid keeper token", () => this.destroy());
+        fail2(ErrorCode.badToken, "Invalid keeper token", () => this.destroy());
         return;
       }
       if (!isProtocolWindow(params.daemonProtocol)) {
-        fail(ErrorCode.badRequest, "daemonProtocol must be [min, max]");
+        fail2(ErrorCode.badRequest, "daemonProtocol must be [min, max]");
         return;
       }
       this.authenticated = true;
@@ -5976,7 +5611,7 @@ var Connection = class {
       return;
     }
     if (!this.authenticated && method !== "keeper.ping") {
-      fail(ErrorCode.unauthenticated, "keeper.hello required");
+      fail2(ErrorCode.unauthenticated, "keeper.hello required");
       return;
     }
     const context = {
@@ -5993,8 +5628,8 @@ var Connection = class {
         this.startSubscriptions();
       } catch (error) {
         this.discardStarts();
-        if (error instanceof KeeperMethodError) fail(error.code, error.message);
-        else fail(ErrorCode.internal, error instanceof Error ? error.message : String(error));
+        if (error instanceof KeeperMethodError) fail2(error.code, error.message);
+        else fail2(ErrorCode.internal, error instanceof Error ? error.message : String(error));
       }
     })();
   }
@@ -6675,11 +6310,11 @@ var StreamLog = class _StreamLog {
    * (a retry would duplicate it), so the error is reported through `onError` and `stats().syncErrors`/`lastSyncError`
    * instead of being thrown, and the record stays counted as unsynced. Only a failure to write the line itself throws.
    */
-  append(input, options = {}) {
+  append(input2, options = {}) {
     this.assertOpen();
-    if (typeof input.k !== "string" || input.k === "") throw new TypeError("A stream record needs a non-empty kind `k`");
-    if ("o" in input || "t" in input) throw new TypeError("`o` and `t` are stamped by the stream log");
-    const { k, ...rest } = input;
+    if (typeof input2.k !== "string" || input2.k === "") throw new TypeError("A stream record needs a non-empty kind `k`");
+    if ("o" in input2 || "t" in input2) throw new TypeError("`o` and `t` are stamped by the stream log");
+    const { k, ...rest } = input2;
     const record = { o: this.nextOffset, t: this.now(), k, ...rest };
     const line = Buffer.from(`${JSON.stringify(record)}
 `);
@@ -7148,24 +6783,7 @@ function environment(value) {
 }
 
 // src/workstation/keepers/terminal/protocol.ts
-var PTY_CAPABILITY = "pty";
-var PTY_UNAVAILABLE_ERROR = "Terminal native dependency unavailable; reinstall CLI with optional node-pty support";
-var PTY_HISTORY_BYTES = 1024 * 1024;
-var PTY_MAX_POLL_BYTES = 64 * 1024;
-var PTY_SCROLLBACK = 1e3;
-var PTY_RESULT_BYTES = 2 * 1024 * 1024;
-var PTY_SESSION_LIMIT = 8;
-var PTY_INPUT_BYTES = 64 * 1024;
-var PTY_LABEL_CHARS = 64;
-var PtyErrorCode = {
-  unavailable: "pty_unavailable",
-  badRequest: "bad_request",
-  notFound: "pty_not_found",
-  notController: "pty_not_controller",
-  limit: "pty_limit",
-  exited: "pty_exited",
-  snapshotTooLarge: "pty_snapshot_too_large"
-};
+var PTY_CAPABILITY = "pty-grid-v1";
 var EXEC_CAPABILITY = "exec";
 var execStream = (execId) => `exec/${execId}`;
 var EXEC_RUNNING_LIMIT = 128;
@@ -7199,7 +6817,7 @@ var MAX_READ_RECORDS = 1024;
 var MAX_READ_BYTES = 1536 * 1024;
 var MAX_GRACE_MS = 10 * 60 * 1e3;
 var EXEC_ID = /^[A-Za-z0-9_.:-]{1,128}$/;
-var START_KEYS = ["execId", "argv", "cwd", "env", "deadlineEpochMs", "killGraceMs", "retainHeadBytes", "maxUncommittedBytes", "onKeeperLoss", "label", "jobId"];
+var START_KEYS = ["execId", "argv", "cwd", "env", "deadlineEpochMs", "killGraceMs", "retainHeadBytes", "maxUncommittedBytes", "onKeeperLoss", "label", "jobId", "registrationId"];
 function survivesCommit(record, committed) {
   return record.o > committed || record.k === "spawn" || record.k === "out" || record.k === "err";
 }
@@ -7441,6 +7059,8 @@ var ExecHost = class {
     const jobId = params.jobId;
     if (jobId !== void 0 && (typeof jobId !== "string" || !jobId || jobId.length > 256)) badRequest("Invalid jobId");
     if (this.runningCount() >= (this.options.runningLimit ?? EXEC_RUNNING_LIMIT)) throw new KeeperMethodError(ExecErrorCode.limit, "Too many running commands in keeper-terminal");
+    const registrationId = params.registrationId;
+    if (registrationId !== void 0 && (typeof registrationId !== "string" || !registrationId || registrationId.length > 128 || /[\x00-\x1f]/.test(registrationId))) badRequest("Invalid registrationId");
     const meta = {
       v: 1,
       execId,
@@ -7456,6 +7076,7 @@ var ExecHost = class {
       onKeeperLoss,
       createdAtMs: this.now(),
       owner: this.options.owner,
+      ...typeof registrationId === "string" ? { registrationId } : {},
       spawn: null,
       exit: null,
       logReclaimed: null
@@ -7666,14 +7287,14 @@ var ExecHost = class {
     }
   }
   appendOutput(entry, stream, bytes, head) {
-    const input = { k: stream, so: entry.streamBytes[stream], b: bytes.toString("base64") };
+    const input2 = { k: stream, so: entry.streamBytes[stream], b: bytes.toString("base64") };
     entry.streamBytes[stream] += bytes.length;
     if (head) {
       entry.headBytes[stream] += bytes.length;
-      this.appendKept(entry, input);
+      this.appendKept(entry, input2);
       return;
     }
-    const record = entry.log.append(input);
+    const record = entry.log.append(input2);
     const cost = bytes.length + RECORD_OVERHEAD;
     const last = entry.runs[entry.runs.length - 1];
     if (last && last.cost < RUN_COST) {
@@ -7720,8 +7341,8 @@ var ExecHost = class {
     }
   }
   /** Appends to the log AND to keep.jsonl (spawn, gap, exit, head output): records the quota never drops. */
-  appendKept(entry, input) {
-    const record = entry.log.append(input);
+  appendKept(entry, input2) {
+    const record = entry.log.append(input2);
     if (entry.keepFd === void 0) entry.keepFd = openSync2(path3.join(entry.dir, KEEP_FILE), "a", 384);
     writeAllSync(entry.keepFd, Buffer.from(`${JSON.stringify(record)}
 `));
@@ -7911,6 +7532,7 @@ var ExecHost = class {
     return {
       execId: meta.execId,
       label: meta.label,
+      ...meta.registrationId ? { registrationId: meta.registrationId } : {},
       ...meta.jobId ? { jobId: meta.jobId } : {},
       state: this.stateOf(entry),
       pid: meta.spawn?.pid ?? null,
@@ -8077,314 +7699,1097 @@ function messageOf(error) {
 
 // src/workstation/keepers/terminal/keeper.ts
 import { constants, promises as fs3 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
 
-// src/workstation/keepers/terminal/pty.ts
-var import_headless = __toESM(require_xterm_headless(), 1);
-var import_addon_serialize = __toESM(require_addon_serialize(), 1);
-import { execFile as execFile3 } from "node:child_process";
+// src/workstation/keepers/terminal/sessions.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { execFile as execFile4 } from "node:child_process";
 import { createRequire } from "node:module";
-import path4 from "node:path";
+import path5 from "node:path";
+
+// src/workstation/keepers/terminal/gridProtocol.ts
+var TERMINAL_GRID_LIMITS = {
+  minCols: 20,
+  maxCols: 300,
+  minRows: 5,
+  maxRows: 100,
+  maxSessions: 8,
+  maxAttachments: 16,
+  leaseMs: 15e3,
+  scrollbackLines: 1e4,
+  maxInputBytes: 64 * 1024,
+  maxRequestBytes: 128 * 1024,
+  maxResultBytes: 2 * 1024 * 1024,
+  maxCachedFrames: 8,
+  maxFrameCacheBytes: 8 * 1024 * 1024
+};
+var TERMINAL_STYLE_FLAGS = {
+  bold: 1,
+  dim: 2,
+  italic: 4,
+  underline: 8,
+  blink: 16,
+  inverse: 32,
+  invisible: 64,
+  strike: 128
+};
+var TERMINAL_RGB_COLOR_BASE = 16777216;
+
+// src/workstation/keepers/terminal/frames.ts
+var TerminalFrames = class {
+  cache = [];
+  bytes = 0;
+  /** A failed/oversized capture leaves both the revision and recovery cache untouched. */
+  publish(snapshot, session, geometry) {
+    validate(snapshot, session);
+    const previous = this.cache.at(-1)?.frame;
+    const sameSession = previous?.incarnation === session.incarnation && previous.id === session.id;
+    const nextGeometry = geometry ?? (sameSession ? previous.geometry + Number(previous.cols !== snapshot.cols || previous.rows !== snapshot.rows) : 1);
+    if (!Number.isSafeInteger(nextGeometry) || nextGeometry < 1 || sameSession && nextGeometry < previous.geometry) throw new Error("Invalid terminal geometry");
+    const next = structuredClone({
+      ...snapshot,
+      schema: 1,
+      id: session.id,
+      incarnation: session.incarnation,
+      revision: sameSession ? previous.revision + 1 : 1,
+      baseRevision: 0,
+      geometry: nextGeometry,
+      full: true,
+      session
+    });
+    if (sameSession && equalContent(previous, next)) return;
+    const bytes = resultBytes(next);
+    if (!sameSession) {
+      this.cache = [];
+      this.bytes = 0;
+    }
+    this.cache.push({ frame: next, bytes });
+    this.bytes += bytes;
+    while (this.cache.length > TERMINAL_GRID_LIMITS.maxCachedFrames || this.bytes > TERMINAL_GRID_LIMITS.maxFrameCacheBytes) this.bytes -= this.cache.shift().bytes;
+  }
+  poll(after) {
+    const current = this.cache.at(-1)?.frame;
+    if (!current) throw new Error("Terminal frame has not been captured");
+    if (after === current.revision) return structuredClone({ ...current, full: false, baseRevision: after, styles: [], changedRows: [] });
+    const base = after === 0 ? void 0 : this.cache.find((entry) => entry.frame.revision === after)?.frame;
+    if (!base || base.geometry !== current.geometry || base.buffer !== current.buffer || base.incarnation !== current.incarnation) return structuredClone(current);
+    const changedRows = current.changedRows.filter((row, index) => semanticRow(row, current) !== semanticRow(base.changedRows[index], base));
+    const delta = { ...current, full: false, baseRevision: after, changedRows };
+    resultBytes(delta);
+    return structuredClone(delta);
+  }
+  cacheStats() {
+    return { frames: this.cache.length, bytes: this.bytes };
+  }
+};
+function semanticRow(row, frame) {
+  return JSON.stringify([row.wrapped ?? false, row.runs.flatMap((run) => run.cells.map((cell) => [cell.text, cell.width, frame.styles[run.style]]))]);
+}
+function equalContent(a, b) {
+  const header = (frame) => JSON.stringify([
+    frame.geometry,
+    frame.cols,
+    frame.rows,
+    frame.buffer,
+    frame.viewport,
+    frame.cursor,
+    frame.modes,
+    frame.session
+  ]);
+  return header(a) === header(b) && a.changedRows.every((row, index) => semanticRow(row, a) === semanticRow(b.changedRows[index], b));
+}
+function resultBytes(frame) {
+  const bytes = Buffer.byteLength(JSON.stringify(frame));
+  if (bytes > TERMINAL_GRID_LIMITS.maxResultBytes - 1024) throw new KeeperMethodError("pty_snapshot_too_large", "Terminal frame exceeds result limit; resize to a smaller viewport");
+  return bytes;
+}
+function validate(snapshot, session) {
+  if (snapshot.cols < TERMINAL_GRID_LIMITS.minCols || snapshot.cols > TERMINAL_GRID_LIMITS.maxCols || snapshot.rows < TERMINAL_GRID_LIMITS.minRows || snapshot.rows > TERMINAL_GRID_LIMITS.maxRows || snapshot.cols !== session.cols || snapshot.rows !== session.rows || snapshot.changedRows.length !== snapshot.rows) throw new Error("Terminal snapshot must contain a complete matching grid");
+  for (const [index, row] of snapshot.changedRows.entries()) {
+    if (row.index !== index || row.runs.reduce((count, run) => count + run.cells.length, 0) !== snapshot.cols || row.runs.some((run) => !snapshot.styles[run.style] || run.cells.some((cell) => typeof cell.text !== "string" || ![0, 1, 2].includes(cell.width)))) throw new Error("Terminal snapshot must contain complete rows and styles");
+  }
+}
+
+// src/workstation/keepers/terminal/screen.ts
+var import_headless = __toESM(require_xterm_headless(), 1);
 var { Terminal } = import_headless.default;
-var { SerializeAddon } = import_addon_serialize.default;
-var darwinShellName = (pid) => new Promise((resolve) => {
-  execFile3("ps", ["-o", "ucomm=", "-p", String(pid)], { timeout: 1e3 }, (error, stdout) => resolve(error ? null : stdout.trim() || null));
-});
-var defaultShellProcessName = (pid) => process.platform === "darwin" ? darwinShellName(pid) : Promise.resolve(null);
-var bad = (message) => {
-  throw new KeeperMethodError(PtyErrorCode.badRequest, message);
+var mouseEncodings = { 1005: "utf8", 1006: "sgr", 1015: "urxvt", 1016: "sgr-pixels" };
+var TerminalScreen = class {
+  terminal;
+  settled = Promise.resolve();
+  resizeBarrier;
+  pending = /* @__PURE__ */ new Set();
+  closed = false;
+  normalRestoreTop;
+  alternateScroll = false;
+  mouseEncoding = "default";
+  constructor(cols, rows) {
+    this.terminal = new Terminal({ cols, rows, scrollback: TERMINAL_GRID_LIMITS.scrollbackLines, allowProposedApi: true });
+    for (const final of ["h", "l"]) this.terminal.parser.registerCsiHandler({ prefix: "?", final }, (params) => {
+      for (const param of params) {
+        if (param === 1007) this.alternateScroll = final === "h";
+        const encoding = typeof param === "number" ? mouseEncodings[param] : void 0;
+        if (encoding) this.mouseEncoding = final === "h" ? encoding : "default";
+      }
+      return false;
+    });
+    this.terminal.parser.registerEscHandler({ final: "c" }, () => {
+      this.alternateScroll = false;
+      this.mouseEncoding = "default";
+      return false;
+    });
+    this.terminal.buffer.onBufferChange((buffer) => {
+      const top = buffer.type === "normal" ? this.normalRestoreTop ?? buffer.viewportY : buffer.viewportY;
+      if (buffer.type === "normal") this.normalRestoreTop = void 0;
+      this.terminal.scrollToBottom();
+      this.terminal.scrollToLine(top);
+    });
+  }
+  write(data) {
+    if (this.closed) return Promise.reject(new Error("Terminal screen is disposed"));
+    const barrier = this.resizeBarrier;
+    const operation = new Promise((resolve, reject) => {
+      this.pending.add(reject);
+      const write = () => {
+        if (this.closed) return;
+        try {
+          this.terminal.write(data, () => {
+            this.pending.delete(reject);
+            resolve();
+          });
+        } catch (error) {
+          this.pending.delete(reject);
+          reject(error);
+        }
+      };
+      if (barrier) void barrier.then(write, (error) => {
+        this.pending.delete(reject);
+        reject(error);
+      });
+      else write();
+    });
+    this.settled = operation;
+    return operation;
+  }
+  resize(cols, rows) {
+    if (this.closed) return Promise.reject(new Error("Terminal screen is disposed"));
+    const previous = this.settled;
+    const operation = previous.then(() => {
+      if (this.closed) throw new Error("Terminal screen is disposed");
+      const normal = this.terminal.buffer.normal;
+      const anchor = this.anchor(normal);
+      const live = (this.normalRestoreTop ?? normal.viewportY) === normal.baseY;
+      this.terminal.resize(cols, rows);
+      const top = live ? normal.baseY : anchor ? this.anchorLine(anchor, normal) : 0;
+      if (this.terminal.buffer.active.type === "normal") {
+        this.terminal.scrollToBottom();
+        this.terminal.scrollToLine(top);
+      } else {
+        this.normalRestoreTop = Math.min(top, normal.baseY);
+      }
+      anchor?.marker.dispose();
+    });
+    this.resizeBarrier = operation;
+    this.settled = operation;
+    void operation.then(() => {
+      if (this.resizeBarrier === operation) this.resizeBarrier = void 0;
+    }, () => {
+      if (this.resizeBarrier === operation) this.resizeBarrier = void 0;
+    });
+    return operation;
+  }
+  scroll(lines) {
+    this.assertOpen();
+    this.terminal.scrollLines(lines);
+  }
+  /** Only settled state may be published; callers await write/resize before capture. */
+  capture() {
+    this.assertOpen();
+    if (this.pending.size || this.resizeBarrier) throw new Error("Terminal screen has pending writes or resize");
+    const terminal = this.terminal;
+    const buffer = terminal.buffer.active;
+    const core = terminal._core;
+    const styles = [];
+    const styleIndices = /* @__PURE__ */ new Map();
+    const changedRows = Array.from({ length: terminal.rows }, (_, index) => {
+      const line = buffer.getLine(buffer.viewportY + index);
+      const runs = [];
+      for (let x = 0; x < terminal.cols; x++) {
+        const cell = line.getCell(x);
+        const style = cellStyle(cell);
+        const key = `${style.fg},${style.bg},${style.flags}`;
+        let styleIndex = styleIndices.get(key);
+        if (styleIndex === void 0) {
+          styleIndex = styles.length;
+          styles.push(style);
+          styleIndices.set(key, styleIndex);
+        }
+        let run = runs[runs.length - 1];
+        if (!run || run.style !== styleIndex) {
+          run = { style: styleIndex, cells: [] };
+          runs.push(run);
+        }
+        run.cells.push({ text: cell.getChars(), width: cell.getWidth() });
+      }
+      return { index, runs, wrapped: line.isWrapped };
+    });
+    const y = buffer.baseY + buffer.cursorY - buffer.viewportY;
+    return {
+      cols: terminal.cols,
+      rows: terminal.rows,
+      buffer: buffer.type,
+      viewport: { top: buffer.viewportY, totalLines: buffer.length, live: buffer.viewportY === buffer.baseY },
+      cursor: {
+        x: Math.min(buffer.cursorX, terminal.cols - 1),
+        y,
+        visible: !core.coreService.isCursorHidden && y >= 0 && y < terminal.rows,
+        shape: core.coreService.decPrivateModes.cursorStyle ?? terminal.options.cursorStyle ?? "block",
+        blink: core.coreService.decPrivateModes.cursorBlink ?? terminal.options.cursorBlink ?? false
+      },
+      modes: this.state().modes,
+      styles,
+      changedRows
+    };
+  }
+  /** Cheap parsed state for input routing; never extracts viewport cells. */
+  state() {
+    this.assertOpen();
+    if (this.pending.size || this.resizeBarrier) throw new Error("Terminal screen has pending writes or resize");
+    const terminal = this.terminal;
+    const modes = terminal.modes;
+    return {
+      buffer: terminal.buffer.active.type,
+      modes: {
+        applicationCursor: modes.applicationCursorKeysMode,
+        applicationKeypad: modes.applicationKeypadMode,
+        bracketedPaste: modes.bracketedPasteMode,
+        alternateScroll: this.alternateScroll,
+        focusReporting: modes.sendFocusMode,
+        mouseTracking: modes.mouseTrackingMode,
+        mouseEncoding: this.mouseEncoding
+      }
+    };
+  }
+  onTitleChange(listener) {
+    return this.terminal.onTitleChange(listener);
+  }
+  onCwdChange(listener) {
+    return this.terminal.parser.registerOscHandler(7, (uri) => {
+      listener(uri);
+      return true;
+    });
+  }
+  onReply(listener) {
+    return this.terminal.onData(listener);
+  }
+  dispose() {
+    if (this.closed) return;
+    this.closed = true;
+    for (const reject of this.pending) reject(new Error("Terminal screen is disposed"));
+    this.pending.clear();
+    this.terminal.dispose();
+  }
+  assertOpen() {
+    if (this.closed) throw new Error("Terminal screen is disposed");
+  }
+  anchor(buffer) {
+    const top = this.normalRestoreTop ?? buffer.viewportY;
+    if (top === buffer.baseY) return void 0;
+    let end = top + 1;
+    while (buffer.getLine(end)?.isWrapped) end++;
+    let cellsFromEnd = this.trimmedLength(buffer, end - 1);
+    for (let line = top; line < end - 1; line++) cellsFromEnd += this.wrappedLength(buffer, line);
+    const marker = this.terminal.buffer.active.type === "normal" ? this.terminal.registerMarker(end - buffer.baseY - buffer.cursorY) : this.terminal._core.buffers.normal.addMarker(end);
+    return marker ? { marker, cellsFromEnd } : void 0;
+  }
+  anchorLine(anchor, buffer) {
+    if (anchor.marker.isDisposed) return 0;
+    let line = Math.min(anchor.marker.line, buffer.length) - 1;
+    if (line < 0) return 0;
+    let remaining = anchor.cellsFromEnd - this.trimmedLength(buffer, line);
+    while (remaining > 0 && line > 0 && buffer.getLine(line)?.isWrapped) {
+      line--;
+      remaining -= this.wrappedLength(buffer, line);
+    }
+    return line;
+  }
+  trimmedLength(buffer, line) {
+    const row = buffer.getLine(line);
+    for (let x = this.terminal.cols - 1; x >= 0; x--) {
+      const cell = row.getCell(x);
+      if (cell.getChars()) return x + cell.getWidth();
+    }
+    return 0;
+  }
+  wrappedLength(buffer, line) {
+    const last = buffer.getLine(line).getCell(this.terminal.cols - 1);
+    return this.terminal.cols - (last.getChars() === "" && last.getWidth() === 1 && buffer.getLine(line + 1)?.getCell(0)?.getWidth() === 2 ? 1 : 0);
+  }
 };
-function keys2(params, allowed) {
-  if (Object.keys(params).some((key) => !allowed.includes(key))) bad("Unexpected tool parameter");
+function cellStyle(cell) {
+  const flags = TERMINAL_STYLE_FLAGS;
+  return {
+    fg: cell.isFgDefault() ? -1 : cell.getFgColor() + (cell.isFgRGB() ? TERMINAL_RGB_COLOR_BASE : 0),
+    bg: cell.isBgDefault() ? -1 : cell.getBgColor() + (cell.isBgRGB() ? TERMINAL_RGB_COLOR_BASE : 0),
+    flags: (cell.isBold() ? flags.bold : 0) | (cell.isDim() ? flags.dim : 0) | (cell.isItalic() ? flags.italic : 0) | (cell.isUnderline() ? flags.underline : 0) | (cell.isBlink() ? flags.blink : 0) | (cell.isInverse() ? flags.inverse : 0) | (cell.isInvisible() ? flags.invisible : 0) | (cell.isStrikethrough() ? flags.strike : 0)
+  };
 }
-function identifier(params, name) {
-  const value = params[name];
-  if (typeof value !== "string" || !value.length || value.includes("\0") || value.length > 128 || !/^[A-Za-z0-9_.:-]+$/.test(value)) bad(`Invalid ${name}`);
-  return value;
+
+// src/workstation/keepers/terminal/input.ts
+var esc = "\x1B";
+var modifiers = (mask) => 1 + (mask & 1) + (mask & 2) + (mask & 4) + (mask & 8);
+var arrows = { 79: "C", 80: "D", 81: "B", 82: "A", 74: "H", 77: "F" };
+var tilde = { 73: 2, 76: 3, 75: 5, 78: 6, 62: 15, 63: 17, 64: 18, 65: 19, 66: 20, 67: 21, 68: 23, 69: 24 };
+var keypad = {
+  84: ["/", "o"],
+  85: ["*", "j"],
+  86: ["-", "m"],
+  87: ["+", "k"],
+  88: ["\r", "M"],
+  89: ["1", "q"],
+  90: ["2", "r"],
+  91: ["3", "s"],
+  92: ["4", "t"],
+  93: ["5", "u"],
+  94: ["6", "v"],
+  95: ["7", "w"],
+  96: ["8", "x"],
+  97: ["9", "y"],
+  98: ["0", "p"],
+  99: [".", "n"],
+  103: ["=", "X"]
+};
+var TerminalInputEncoder = class {
+  buttons = /* @__PURE__ */ new Set();
+  release() {
+    this.buttons.clear();
+  }
+  encode(event, screen) {
+    switch (event.kind) {
+      case "release":
+        this.release();
+        return "";
+      case "text":
+        return event.text;
+      case "paste":
+        return screen.modes.bracketedPaste ? `${esc}[200~${event.text}${esc}[201~` : event.text;
+      case "key":
+        return event.down ? encodeKey(event.usage, event.modifiers, screen.modes) : "";
+      case "button": {
+        if (event.down) this.buttons.add(event.button);
+        else this.buttons.delete(event.button);
+        if (screen.modes.mouseTracking === "none" || !event.down && screen.modes.mouseTracking === "x10") return "";
+        return mouse(event.button, event.x, event.y, event.modifiers, screen.modes, !event.down);
+      }
+      case "pointer": {
+        const tracking = screen.modes.mouseTracking;
+        if (tracking !== "any" && !(tracking === "drag" && this.buttons.size)) return "";
+        return mouse(32 + (this.buttons.values().next().value ?? 3), event.x, event.y, event.modifiers, screen.modes);
+      }
+    }
+  }
+};
+function createTerminalInput(screen) {
+  const clients = /* @__PURE__ */ new Map();
+  const encoder = (id) => {
+    let value = clients.get(id);
+    if (!value) {
+      value = new TerminalInputEncoder();
+      clients.set(id, value);
+    }
+    return value;
+  };
+  return {
+    input(event, clientId, context) {
+      return encoder(clientId).encode(event, context);
+    },
+    scroll(gesture, _clientId, context) {
+      if (!gesture.lines) return "";
+      const state = screen.state();
+      if (context.modes.mouseTracking === "x10") return "";
+      if (context.modes.mouseTracking !== "none") return repeat(mouse(gesture.lines < 0 ? 64 : 65, gesture.x, gesture.y, gesture.modifiers, context.modes), Math.abs(gesture.lines));
+      if (state.buffer === "normal") return void 0;
+      if (!context.modes.alternateScroll) return "";
+      return repeat(encodeKey(gesture.lines < 0 ? 82 : 81, gesture.modifiers, context.modes), Math.abs(gesture.lines));
+    },
+    release(clientId) {
+      clients.get(clientId)?.release();
+      clients.delete(clientId);
+    },
+    dispose() {
+      clients.clear();
+    }
+  };
 }
-function integer2(params, name, min, max, fallback) {
-  const value = params[name] === void 0 ? fallback : params[name];
-  if (!Number.isSafeInteger(value) || value < min || value > max) bad(`Invalid ${name}`);
-  return value;
+function repeat(bytes, count) {
+  if (!bytes) return "";
+  if (count > Math.floor(TERMINAL_GRID_LIMITS.maxInputBytes / Buffer.byteLength(bytes))) throw new KeeperMethodError("bad_request", "Terminal input exceeds limit");
+  if (typeof bytes === "string") return bytes.repeat(count);
+  return Buffer.concat(Array.from({ length: count }, () => bytes));
 }
-var processBasename = (name) => path4.basename(name.trim()).replace(/^-/, "");
-var CREATE_KEYS = ["id", "clientId", "name", "cwd", "cols", "rows"];
-var PtySessions = class {
-  constructor(options = {}) {
+function mouse(button, x, y, mask, modes, release = false) {
+  if (modes.mouseEncoding === "sgr-pixels") return "";
+  const mods = modes.mouseTracking === "x10" ? 0 : (mask & 1 ? 4 : 0) + (mask & 2 ? 8 : 0) + (mask & 4 ? 16 : 0);
+  if (modes.mouseEncoding === "sgr") return `${esc}[<${button + mods};${x + 1};${y + 1}${release ? "m" : "M"}`;
+  const code = (release ? 3 : button) + mods + 32;
+  if (modes.mouseEncoding === "urxvt") return `${esc}[${code};${x + 1};${y + 1}M`;
+  if (modes.mouseEncoding === "default" && (x > 222 || y > 222)) return "";
+  if (modes.mouseEncoding === "default") return Buffer.from([27, 91, 77, code, x + 33, y + 33]);
+  return `${esc}[M${String.fromCharCode(code, x + 33, y + 33)}`;
+}
+function encodeKey(usage, mask, modes) {
+  const mod = modifiers(mask);
+  if (arrows[usage]) return mod > 1 ? `${esc}[1;${mod}${arrows[usage]}` : `${esc}${modes.applicationCursor ? "O" : "["}${arrows[usage]}`;
+  if (tilde[usage]) return `${esc}[${tilde[usage]}${mod > 1 ? `;${mod}` : ""}~`;
+  if (usage >= 58 && usage <= 61) return mod > 1 ? `${esc}[1;${mod}${String.fromCharCode(80 + usage - 58)}` : `${esc}O${String.fromCharCode(80 + usage - 58)}`;
+  if (keypad[usage]) {
+    if (mask & 8 && usage !== 88) return "";
+    return modes.applicationKeypad ? mod > 1 ? `${esc}[1;${mod}${keypad[usage][1]}` : `${esc}O${keypad[usage][1]}` : prefixed(keypad[usage][0], mask);
+  }
+  if (usage === 40) return prefixed("\r", mask);
+  if (usage === 41) return esc;
+  if (usage === 42) return prefixed(mask & 4 ? "\b" : "\x7F", mask);
+  if (usage === 43) return mask & 1 ? `${esc}[Z` : prefixed("	", mask);
+  if (mask & 8) return "";
+  let text = "";
+  if (usage >= 4 && usage <= 29) text = String.fromCharCode((mask & 1 ? 65 : 97) + usage - 4);
+  else if (usage >= 30 && usage <= 39) text = (mask & 1 ? "!@#$%^&*()" : "1234567890")[usage - 30];
+  else {
+    const punctuation = { 44: [" ", " "], 45: ["-", "_"], 46: ["=", "+"], 47: ["[", "{"], 48: ["]", "}"], 49: ["\\", "|"], 50: ["#", "~"], 51: [";", ":"], 52: ["'", '"'], 53: ["`", "~"], 54: [",", "<"], 55: [".", ">"], 56: ["/", "?"] };
+    text = punctuation[usage]?.[mask & 1 ? 1 : 0] ?? "";
+  }
+  if (mask & 4) {
+    const upper = text.toUpperCase();
+    if (upper >= "@" && upper <= "_") text = String.fromCharCode(upper.charCodeAt(0) - 64);
+    else if (text === " " || text === "2" || text === "`") text = "\0";
+    else if (text === "3") text = esc;
+    else if (text === "4") text = "";
+    else if (text === "5") text = "";
+    else if (text === "6") text = "";
+    else if (text === "7" || text === "/") text = "";
+    else if (text === "8" || text === "?") text = "\x7F";
+  }
+  return prefixed(text, mask);
+}
+function prefixed(text, mask) {
+  return text && mask & 2 ? esc + text : text;
+}
+
+// src/workstation/keepers/terminal/metadata.ts
+import { execFile as execFile3 } from "node:child_process";
+import { readlink } from "node:fs/promises";
+import { hostname as localHostname } from "node:os";
+import path4 from "node:path";
+var clean = (value) => [...value.replace(/[\x00-\x1f\x7f-\x9f]/g, "").trim()].slice(0, 256).join("");
+var validCwd = (value) => value.startsWith("/") && !/[\x00-\x1f\x7f-\x9f]/.test(value);
+var TerminalMetadata = class {
+  constructor(options) {
     this.options = options;
+    this.cwd = options.cwd;
     this.now = options.now ?? Date.now;
-    try {
-      this.ptyModule = (options.loadPty ?? (() => createRequire(import.meta.url)("node-pty")))();
-    } catch {
-      this.error = PTY_UNAVAILABLE_ERROR;
-    }
+    this.hostname = (options.hostname ?? localHostname()).toLowerCase();
+    this.listeners = [options.screen.onTitleChange((title) => {
+      if (this.closed) return;
+      const previous = this.title;
+      this.explicitTitle = clean(title);
+      if (this.title !== previous) options.changed();
+    }), options.screen.onCwdChange((uri) => this.osc7(uri))];
   }
   options;
-  sessions = /* @__PURE__ */ new Map();
-  ptyModule;
-  error;
+  cwd;
+  cwdSource = "launch";
+  explicitTitle = "";
+  listeners;
   now;
-  get available() {
-    return !!this.ptyModule;
+  hostname;
+  lastLookup = -Infinity;
+  oscRevision = 0;
+  closed = false;
+  pending;
+  cancelLookup;
+  timer;
+  get title() {
+    return this.explicitTitle || clean(path4.posix.basename(this.cwd) || this.cwd) || "Terminal";
   }
-  descriptor(s) {
-    return { id: s.id, name: s.name, cwd: s.cwd, cols: s.cols, rows: s.rows, exited: s.exited, exitCode: s.exitCode, controllerId: s.controllerId };
-  }
-  control(s, clientId) {
-    if (s.controllerId !== clientId) throw new KeeperMethodError(PtyErrorCode.notController, "Terminal is controlled by another client; take control explicitly");
-  }
-  resize(s, p) {
-    const cols = integer2(p, "cols", 20, 300, s.cols);
-    const rows = integer2(p, "rows", 5, 100, s.rows);
-    if (cols !== s.cols || rows !== s.rows) {
-      if (!s.exited) s.pty.resize(cols, rows);
-      s.terminal.resize(cols, rows);
-      s.cols = cols;
-      s.rows = rows;
+  read() {
+    return { title: this.title, cwd: this.cwd, cwdSource: this.cwdSource };
+  }
+  /** Called once by the host factory, independently of output and attachments. */
+  start() {
+    if (this.closed || this.timer) return;
+    void this.refresh();
+    this.timer = setInterval(() => {
+      void this.refresh();
+    }, 2e3);
+    this.timer.unref();
+  }
+  refresh() {
+    if (this.closed || this.options.live?.() === false) return Promise.resolve();
+    if (this.pending) return this.pending;
+    if (this.now() - this.lastLookup < 2e3) return Promise.resolve();
+    this.lastLookup = this.now();
+    const revision = this.oscRevision;
+    let timeout;
+    const bounded = new Promise((resolve) => {
+      timeout = setTimeout(() => resolve(null), 1e3);
+      this.cancelLookup = () => resolve(null);
+      try {
+        void (this.options.lookup ?? lookupProcessCwd)(this.options.pid).then(resolve, () => resolve(null));
+      } catch {
+        resolve(null);
+      }
+    });
+    this.pending = bounded.then((cwd) => {
+      if (!this.closed && this.options.live?.() !== false && revision === this.oscRevision && cwd && validCwd(cwd)) this.updateCwd(cwd, "process");
+    }).finally(() => {
+      clearTimeout(timeout);
+      this.cancelLookup = void 0;
+      this.pending = void 0;
+    });
+    return this.pending;
+  }
+  dispose() {
+    if (this.closed) return;
+    this.closed = true;
+    clearInterval(this.timer);
+    this.timer = void 0;
+    this.cancelLookup?.();
+    for (const listener of this.listeners) listener.dispose();
+  }
+  osc7(uri) {
+    if (this.closed) return;
+    try {
+      if (/[\x00-\x1f\x7f-\x9f]/.test(uri)) return;
+      const url = new URL(uri);
+      if (url.protocol !== "file:" || url.username || url.password || url.port || uri.includes("?") || uri.includes("#")) return;
+      const host = url.hostname.toLowerCase();
+      if (host && host !== "localhost" && host !== this.hostname) return;
+      const cwd = decodeURIComponent(url.pathname);
+      if (!validCwd(cwd)) return;
+      this.oscRevision++;
+      this.updateCwd(cwd, "osc7");
+    } catch {
     }
   }
-  snapshot(s) {
-    for (let scrollback = PTY_SCROLLBACK; ; scrollback = Math.floor(scrollback / 2)) {
-      const snapshot = "\x1Bc" + s.serializer.serialize({ scrollback });
-      if (Buffer.byteLength(JSON.stringify({ snapshot })) < PTY_RESULT_BYTES - 8192) return snapshot;
-      if (!scrollback) throw new KeeperMethodError(PtyErrorCode.snapshotTooLarge, "Terminal screen exceeds snapshot limit; resize to a smaller viewport");
+  updateCwd(cwd, source) {
+    if (cwd === this.cwd && source === this.cwdSource) return;
+    this.cwd = cwd;
+    this.cwdSource = source;
+    this.options.changed();
+  }
+};
+async function lookupProcessCwd(pid, platform = process.platform) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+  if (platform === "linux") {
+    try {
+      return await readlink(`/proc/${pid}/cwd`);
+    } catch {
+      return null;
     }
   }
-  output(s, data) {
-    if (!data || s.closed) return;
-    const bytes = Buffer.byteLength(data);
-    s.pendingBytes += bytes;
-    if (s.pendingBytes > 256 * 1024) s.pty.pause();
-    s.rendered = new Promise((resolve) => {
-      s.terminal.write(data, () => {
-        s.seq += 1;
-        s.ring.push({ seq: s.seq, data, bytes });
-        s.ringBytes += bytes;
-        const limit = this.options.historyBytes ?? PTY_HISTORY_BYTES;
-        while (s.ringBytes > limit && s.ring.length) s.ringBytes -= s.ring.shift().bytes;
-        s.pendingBytes -= bytes;
-        if (s.pendingBytes < 64 * 1024 && !s.exited) s.pty.resume();
-        resolve();
-      });
+  if (platform !== "darwin") return null;
+  return new Promise((resolve) => {
+    execFile3("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], { timeout: 1e3, maxBuffer: 64 * 1024 }, (error, stdout) => {
+      resolve(error ? null : stdout.split("\n").find((line) => line.startsWith("n/"))?.slice(1) ?? null);
     });
+  });
+}
+function createTerminalMetadata(context) {
+  const initial = context.session();
+  const metadata = new TerminalMetadata({
+    screen: context.screen,
+    cwd: initial.cwd,
+    pid: context.pty.pid,
+    changed: context.changed,
+    live: () => !context.session().exited
+  });
+  metadata.start();
+  return metadata;
+}
+
+// src/workstation/keepers/terminal/sessions.ts
+var NATIVE_PTY_OPERATIONS = /* @__PURE__ */ new Set(["attach", "poll", "resize", "input", "scroll", "detach", "close"]);
+var bad = (message) => {
+  throw new KeeperMethodError("bad_request", message);
+};
+var fail = (code, message) => {
+  throw new KeeperMethodError(code, message);
+};
+var ok = { ok: true };
+var nativeScheduler = {
+  schedule(callback, delay) {
+    const timer = setTimeout(callback, delay);
+    timer.unref();
+    return { dispose: () => clearTimeout(timer) };
   }
-  unavailable() {
-    throw new KeeperMethodError(PtyErrorCode.unavailable, this.error ?? "Terminal unavailable");
-  }
-  list(p) {
-    keys2(p, []);
-    return { sessions: [...this.sessions.values()].map((s) => this.descriptor(s)) };
+};
+var basename = (name) => path5.basename(name.trim()).replace(/^-/, "");
+var NativePtySessions = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.scheduler = options.scheduler ?? nativeScheduler;
+    try {
+      this.module = (options.loadPty ?? (() => createRequire(import.meta.url)("node-pty")))();
+    } catch {
+      this.unavailable = "Terminal native dependency unavailable; reinstall CLI with optional node-pty support";
+    }
   }
-  /**
-   * Creates session `id`, or returns the existing one (idempotent). `allowedKeys` is the caller's parameter set; `launch`
-   * supplies cwd, shell and env and runs only when a session is really started (after the duplicate and limit checks,
-   * which are re-checked afterwards because `launch` may be asynchronous).
-   */
-  async create(p, allowedKeys, launch) {
-    if (!this.ptyModule) this.unavailable();
-    const id = identifier(p, "id");
-    const clientId = identifier(p, "clientId");
-    keys2(p, allowedKeys);
-    const cols = integer2(p, "cols", 20, 300, 100);
-    const rows = integer2(p, "rows", 5, 100, 30);
-    if (p.name !== void 0 && (typeof p.name !== "string" || !p.name.length || p.name.length > 128 || /[\x00-\x1f]/.test(p.name))) bad("Invalid terminal name");
-    const existing = () => {
-      const old2 = this.sessions.get(id);
-      return old2 && this.descriptor(old2);
-    };
-    const limit = () => {
-      if (this.sessions.size >= PTY_SESSION_LIMIT) throw new KeeperMethodError(PtyErrorCode.limit, "Terminal session limit exceeded");
-    };
-    let old = existing();
-    if (old) return old;
-    limit();
-    const { cwd, shell, env } = await launch();
-    old = existing();
-    if (old) return old;
-    limit();
-    const terminal = new Terminal({ cols, rows, scrollback: PTY_SCROLLBACK, allowProposedApi: true });
-    const serializer = new SerializeAddon();
-    terminal.loadAddon(serializer);
+  options;
+  sessions = /* @__PURE__ */ new Map();
+  now;
+  scheduler;
+  module;
+  unavailable;
+  disposed = false;
+  list() {
+    return { schema: 1, limits: { ...TERMINAL_GRID_LIMITS }, sessions: [...this.sessions.values()].map((s) => this.descriptor(s)) };
+  }
+  async create(params, launch) {
+    this.available();
+    request(params);
+    keys2(params, ["id", "cwd", "registrationId"]);
+    const id = identifier(params, "id");
+    if (params.registrationId !== void 0) identifier(params, "registrationId");
+    if (params.cwd !== void 0 && (typeof params.cwd !== "string" || params.cwd.includes("\0"))) bad("Invalid cwd");
+    const existing = this.sessions.get(id);
+    if (existing) return this.descriptor(existing);
+    this.checkLimit();
+    const resolved = await launch();
+    this.available();
+    const concurrent = this.sessions.get(id);
+    if (concurrent) return this.descriptor(concurrent);
+    this.checkLimit();
+    const cols = 100;
+    const rows = 30;
+    const screen = new TerminalScreen(cols, rows);
     let pty;
     try {
-      pty = this.ptyModule.spawn(shell, ["-l"], { name: "xterm-256color", cwd, cols, rows, env: { ...env, TERM: "xterm-256color", COLORTERM: "truecolor" } });
+      pty = this.module.spawn(resolved.shell, ["-l"], { name: "xterm-256color", cwd: resolved.cwd, cols, rows, env: { ...resolved.env, TERM: "xterm-256color", COLORTERM: "truecolor" } });
     } catch (error) {
-      terminal.dispose();
+      screen.dispose();
       throw error;
     }
-    const created = this.now();
-    const shellName = processBasename(shell);
-    const session = {
-      id,
-      name: p.name ?? "Terminal",
-      cwd,
-      cols,
-      rows,
-      exited: false,
-      exitCode: null,
-      controllerId: clientId,
+    const createdAt = this.now();
+    const shell = basename(resolved.shell);
+    const s = {
+      value: { id, ...typeof params.registrationId === "string" ? { registrationId: params.registrationId } : {}, incarnation: randomUUID3(), title: "Terminal", cwd: resolved.cwd, cwdSource: "launch", cols, rows, createdAt, exited: false, exitCode: null },
+      shell,
+      shellNames: /* @__PURE__ */ new Set([shell]),
+      shellNameStarted: false,
       pty,
+      screen,
+      frames: new TerminalFrames(),
+      attachments: /* @__PURE__ */ new Map(),
+      geometry: 1,
       closed: false,
-      terminal,
-      serializer,
-      seq: 0,
-      ring: [],
-      ringBytes: 0,
-      pendingBytes: 0,
+      queue: Promise.resolve(),
       rendered: Promise.resolve(),
-      shellName,
+      pendingBytes: 0,
+      dirty: true,
+      capturedAt: -Infinity,
+      listeners: [],
+      input: createTerminalInput(screen),
       exitedAt: 0,
-      shellNames: /* @__PURE__ */ new Set([shellName]),
-      observed: { label: shellName, state: "idle", since: created }
+      observed: { label: shell, state: "idle", since: createdAt }
     };
-    pty.onData((data) => this.output(session, data));
-    pty.onExit((event) => {
-      session.exited = true;
-      session.exitCode = event.exitCode;
-      session.exitedAt = this.now();
-    });
-    terminal.onData((data) => {
-      if (!session.exited) pty.write(data);
-    });
-    this.sessions.set(id, session);
-    const learn = setTimeout(() => {
-      void this.learnShellName(session);
-    }, this.options.shellNameDelayMs ?? 250);
-    learn.unref();
-    return this.descriptor(session);
-  }
-  /** attach / poll / write / resize / takeover / detach / close on an existing session. */
-  async operate(op, p) {
-    if (!this.ptyModule) this.unavailable();
-    const id = identifier(p, "id");
-    const clientId = identifier(p, "clientId");
+    const context = { pty, screen, session: () => this.descriptor(s), changed: () => this.dirty(s) };
+    try {
+      s.input = this.options.createInput?.(context) ?? s.input;
+      s.metadata = (this.options.createMetadata ?? createTerminalMetadata)(context);
+      this.capture(s, true);
+      s.listeners.push(disposable(pty.onData((data) => this.output(s, data))), disposable(pty.onExit((event) => {
+        if (s.closed) return;
+        s.shellNameTimer?.dispose();
+        s.shellNameTimer = void 0;
+        s.value.exited = true;
+        s.value.exitCode = event.exitCode;
+        s.exitedAt = this.now();
+        this.dirty(s);
+      })), screen.onReply((data) => {
+        if (!s.closed && !s.value.exited) {
+          try {
+            pty.write(data);
+          } catch (error) {
+            this.failed(s, error);
+          }
+        }
+      }));
+      this.sessions.set(id, s);
+    } catch (error) {
+      await this.close(s);
+      throw error;
+    }
+    return this.descriptor(s);
+  }
+  async operate(op, params) {
+    request(params);
+    const id = identifier(params, "id");
+    const incarnation = identifier(params, "incarnation");
     const s = this.sessions.get(id);
-    if (!s) throw new KeeperMethodError(PtyErrorCode.notFound, "Terminal session not found; keeper restart loses live PTYs");
-    switch (op) {
-      case "attach": {
-        keys2(p, ["id", "clientId", "cols", "rows"]);
-        integer2(p, "cols", 20, 300, s.cols);
-        integer2(p, "rows", 5, 100, s.rows);
-        await s.rendered;
-        if (s.controllerId === null) s.controllerId = clientId;
-        if (s.controllerId === clientId) this.resize(s, p);
-        return { session: this.descriptor(s), seq: s.seq, snapshot: this.snapshot(s), control: s.controllerId === clientId };
+    if (!s) {
+      if (op === "close" || op === "detach") return ok;
+      return fail("pty_not_found", "Terminal session not found; keeper restart loses live PTYs");
+    }
+    if (s.value.incarnation !== incarnation) return fail("pty_incarnation_mismatch", "Terminal incarnation no longer matches");
+    return this.ordered(s, async () => {
+      if (s.closed) {
+        if (op === "close" || op === "detach") return ok;
+        return fail("pty_not_found", "Terminal session is closed");
+      }
+      if (op === "close") {
+        keys2(params, ["id", "incarnation"]);
+        await this.close(s);
+        return ok;
       }
-      case "poll": {
-        keys2(p, ["id", "clientId", "after"]);
-        const after = integer2(p, "after", 0, Number.MAX_SAFE_INTEGER);
-        await s.rendered;
-        const common = { exited: s.exited, exitCode: s.exitCode, control: s.controllerId === clientId };
-        if (after > s.seq || after < (s.ring[0]?.seq ?? s.seq + 1) - 1) return { ...common, seq: s.seq, data: "", reset: true, snapshot: this.snapshot(s) };
-        let data = "";
-        let bytes = 0;
-        let seq = after;
-        for (const output of s.ring) {
-          if (output.seq <= after) continue;
-          if (bytes + output.bytes > PTY_MAX_POLL_BYTES) {
-            if (!bytes) return { ...common, seq: s.seq, data: "", reset: true, snapshot: this.snapshot(s) };
-            break;
-          }
-          data += output.data;
-          bytes += output.bytes;
-          seq = output.seq;
+      await this.expire(s);
+      const clientId = identifier(params, "clientId");
+      const ref = ["id", "incarnation", "clientId"];
+      if (op === "detach") {
+        keys2(params, ref);
+        this.release(s, clientId);
+        await this.capacity(s);
+        return ok;
+      }
+      if (op === "attach") {
+        keys2(params, [...ref, "cols", "rows"]);
+        const cols = integer2(params, "cols", TERMINAL_GRID_LIMITS.minCols, TERMINAL_GRID_LIMITS.maxCols);
+        const rows = integer2(params, "rows", TERMINAL_GRID_LIMITS.minRows, TERMINAL_GRID_LIMITS.maxRows);
+        if (!s.attachments.has(clientId) && s.attachments.size >= TERMINAL_GRID_LIMITS.maxAttachments) return fail("pty_limit", "Terminal attachment limit exceeded");
+        const previous = s.attachments.get(clientId);
+        s.attachments.set(clientId, { cols, rows, expires: this.now() + TERMINAL_GRID_LIMITS.leaseMs });
+        try {
+          await this.capacity(s);
+          await this.settle(s);
+          this.capture(s, true);
+        } catch (error) {
+          if (previous) s.attachments.set(clientId, previous);
+          else this.release(s, clientId);
+          try {
+            await this.capacity(s);
+          } catch (rollback) {
+            this.failed(s, rollback);
+          }
+          throw error;
         }
-        return { ...common, seq, data, reset: false };
+        this.scheduleLease(s);
+        return s.frames.poll(0);
       }
-      case "takeover":
-        keys2(p, ["id", "clientId"]);
-        s.controllerId = clientId;
-        return { ok: true };
-      case "detach":
-        keys2(p, ["id", "clientId"]);
-        if (s.controllerId === clientId) s.controllerId = null;
-        return { ok: true };
-      case "write":
-        keys2(p, ["id", "clientId", "data"]);
-        this.control(s, clientId);
-        if (s.exited) throw new KeeperMethodError(PtyErrorCode.exited, "Terminal has exited");
-        if (typeof p.data !== "string" || Buffer.byteLength(p.data) > PTY_INPUT_BYTES) bad("Invalid terminal input");
-        s.pty.write(p.data);
-        return { ok: true };
-      case "resize":
-        keys2(p, ["id", "clientId", "cols", "rows"]);
-        this.control(s, clientId);
-        integer2(p, "cols", 20, 300);
-        integer2(p, "rows", 5, 100);
-        await s.rendered;
-        this.resize(s, p);
-        return { ok: true };
-      case "close":
-        keys2(p, ["id", "clientId"]);
-        this.control(s, clientId);
-        this.sessions.delete(id);
-        s.closed = true;
-        if (!s.exited) s.pty.kill();
-        await s.rendered;
-        s.terminal.dispose();
-        return { ok: true };
-      default:
-        return bad("Unsupported terminal tool");
+      const attachment = s.attachments.get(clientId);
+      if (!attachment) return fail("pty_attachment_expired", "Terminal attachment expired; attach again");
+      if (op === "poll") {
+        keys2(params, [...ref, "after"]);
+        const after = integer2(params, "after", 0, Number.MAX_SAFE_INTEGER);
+        attachment.expires = this.now() + TERMINAL_GRID_LIMITS.leaseMs;
+        this.scheduleLease(s);
+        await this.captureDue(s);
+        return s.frames.poll(after);
+      }
+      if (op === "resize") {
+        keys2(params, [...ref, "cols", "rows"]);
+        const cols = integer2(params, "cols", TERMINAL_GRID_LIMITS.minCols, TERMINAL_GRID_LIMITS.maxCols);
+        const rows = integer2(params, "rows", TERMINAL_GRID_LIMITS.minRows, TERMINAL_GRID_LIMITS.maxRows);
+        const previous = { ...attachment };
+        attachment.cols = cols;
+        attachment.rows = rows;
+        try {
+          await this.capacity(s);
+        } catch (error) {
+          Object.assign(attachment, previous);
+          throw error;
+        }
+      } else if (op === "input") {
+        const event = input(params, ref);
+        await this.settle(s);
+        this.assertRunning(s);
+        if (event.kind === "pointer" || event.kind === "button") this.coordinates(s, event);
+        const data = s.input.input(event, clientId, this.inputContext(s));
+        if (data) s.pty.write(data);
+      } else if (op === "scroll") {
+        keys2(params, [...ref, "lines", "x", "y", "modifiers", "geometry"]);
+        const gesture = { lines: integer2(params, "lines", -Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER), ...position(params), modifiers: integer2(params, "modifiers", 0, 15) };
+        await this.settle(s);
+        this.coordinates(s, gesture);
+        const data = s.input.scroll(gesture, clientId, this.inputContext(s));
+        if (data) {
+          this.assertRunning(s);
+          s.pty.write(data);
+        } else if (data === void 0 && s.screen.state().buffer === "normal") {
+          s.screen.scroll(gesture.lines);
+          this.dirty(s);
+        }
+      } else return bad("Unsupported terminal operation");
+      attachment.expires = this.now() + TERMINAL_GRID_LIMITS.leaseMs;
+      this.scheduleLease(s);
+      return ok;
+    });
+  }
+  activity() {
+    const metrics = { ptyOpen: 0, ptyActive: 0, ptyExited: 0 };
+    const items = [...this.sessions.values()].map((s) => {
+      if (s.value.exited) {
+        metrics.ptyExited++;
+        return { type: "pty", id: s.value.id, label: s.shell.slice(0, 64), state: "exited", sinceEpochMs: s.exitedAt };
+      }
+      metrics.ptyOpen++;
+      let foreground = "";
+      try {
+        foreground = basename(s.pty.process);
+      } catch {
+      }
+      const active = foreground !== "" && !s.shellNames.has(foreground);
+      const label = (active ? foreground : s.shell).slice(0, 64);
+      const state = active ? "active" : "idle";
+      if (active) metrics.ptyActive++;
+      if (s.observed.label !== label || s.observed.state !== state) s.observed = { label, state, since: this.now() };
+      return { type: "pty", id: s.value.id, label, state, sinceEpochMs: s.observed.since };
+    });
+    return { metrics, items };
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    await Promise.all([...this.sessions.values()].map((s) => this.ordered(s, () => this.close(s))));
+  }
+  descriptor(s) {
+    return { ...s.value, ...s.metadata?.read() };
+  }
+  available() {
+    if (this.disposed) fail("pty_unavailable", "Terminal host is disposed");
+    if (!this.module) fail("pty_unavailable", this.unavailable ?? "Terminal native dependency unavailable");
+  }
+  checkLimit() {
+    if (this.sessions.size >= TERMINAL_GRID_LIMITS.maxSessions) fail("pty_limit", "Terminal session limit exceeded");
+  }
+  scheduleShellName(s, attempt = 0) {
+    const live = () => !s.closed && !s.value.exited && !this.disposed;
+    if (!live()) return;
+    s.shellNameTimer = this.scheduler.schedule(() => {
+      s.shellNameTimer = void 0;
+      if (!live()) return;
+      const retry = () => {
+        if (attempt < 2) this.scheduleShellName(s, attempt + 1);
+      };
+      void Promise.resolve().then(() => live() ? (this.options.shellProcessName ?? defaultShellProcessName)(s.pty.pid) : null).then((name) => {
+        if (!live()) return;
+        const shell = name && basename(name);
+        if (shell && shell !== "spawn-helper") s.shellNames.add(shell);
+        else retry();
+      }, retry);
+    }, this.options.shellNameDelayMs ?? 250);
+  }
+  ordered(s, action) {
+    const operation = s.queue.then(action);
+    s.queue = operation.catch(() => {
+    });
+    return operation;
+  }
+  async settle(s) {
+    for (; ; ) {
+      const rendered = s.rendered;
+      await rendered;
+      if (rendered === s.rendered) break;
     }
+    if (s.failure) throw s.failure;
   }
-  /** The tty's foreground process basename, '' when it cannot be read (node-pty falls back to the shell path itself). */
-  foreground(s) {
+  output(s, data) {
+    if (s.closed || !data || s.failure) return;
+    if (!s.shellNameStarted) {
+      s.shellNameStarted = true;
+      this.scheduleShellName(s);
+    }
+    const bytes = Buffer.byteLength(data);
+    s.pendingBytes += bytes;
     try {
-      return processBasename(String(s.pty.process ?? ""));
-    } catch {
-      return "";
+      if (s.pendingBytes > 256 * 1024) s.pty.pause();
+      s.metadata?.onData?.(data);
+      s.rendered = s.screen.write(data);
+      void s.rendered.then(() => {
+        s.pendingBytes -= bytes;
+        try {
+          if (!s.closed && !s.value.exited && s.pendingBytes < 64 * 1024) s.pty.resume();
+        } catch (error) {
+          this.failed(s, error);
+        }
+        this.dirty(s);
+      }, (error) => this.failed(s, error));
+      this.dirty(s);
+    } catch (error) {
+      this.failed(s, error);
     }
   }
-  /**
-   * Learns once per session, in the background shortly after spawn, what the tty calls the shell itself (macOS `p_comm`).
-   * Until it resolves (or when it fails) the configured basename is the only shell name: activity never waits on a subprocess.
-   */
-  async learnShellName(s) {
-    if (s.closed || s.exited) return;
-    try {
-      const name = await (this.options.shellProcessName ?? defaultShellProcessName)(s.pty.pid);
-      if (name) s.shellNames.add(processBasename(name));
-    } catch {
+  failed(s, error) {
+    if (!s.closed) {
+      s.failure = error;
+      s.captureTimer?.dispose();
+      s.captureTimer = void 0;
     }
   }
-  /**
-   * A live sample for `keeper.activity` (spec §3.5/§4.1): `ptyOpen` live sessions, `ptyActive` live sessions whose foreground
-   * process is not their shell, `ptyExited` exited sessions still listed. One item per session, labelled with the foreground
-   * process basename (never its arguments), `sinceEpochMs` = when this label/state was first observed.
-   */
-  activity() {
-    const now = this.now();
-    let open = 0;
-    let active = 0;
-    let exited = 0;
-    const items = [];
-    for (const s of this.sessions.values()) {
-      if (s.exited) {
-        exited += 1;
-        items.push({ type: "pty", id: s.id, label: s.shellName.slice(0, PTY_LABEL_CHARS), state: "exited", sinceEpochMs: s.exitedAt });
-        continue;
+  dirty(s) {
+    if (s.closed || s.failure) return;
+    s.dirty = true;
+    if (!s.captureTimer) s.captureTimer = this.scheduler.schedule(() => {
+      s.captureTimer = void 0;
+      void this.ordered(s, async () => {
+        if (s.closed) return;
+        await this.settle(s);
+        this.capture(s);
+      }).catch((error) => {
+        if (!(error instanceof KeeperMethodError && error.code === "pty_snapshot_too_large")) this.failed(s, error);
+      });
+    }, Math.max(0, 50 - (this.now() - s.capturedAt)));
+  }
+  async captureDue(s) {
+    if (s.dirty && this.now() - s.capturedAt < 50) {
+      s.captureTimer?.dispose();
+      s.captureTimer = void 0;
+      await new Promise((resolve) => this.scheduler.schedule(resolve, 50 - (this.now() - s.capturedAt)));
+    }
+    await this.settle(s);
+    this.capture(s, true);
+  }
+  capture(s, force = false) {
+    if (!s.dirty || !force && this.now() - s.capturedAt < 50) return;
+    s.frames.publish(s.screen.capture(), this.descriptor(s), s.geometry);
+    s.dirty = false;
+    s.capturedAt = this.now();
+    s.captureTimer?.dispose();
+    s.captureTimer = void 0;
+  }
+  async capacity(s) {
+    if (!s.attachments.size) return;
+    const cols = Math.min(...[...s.attachments.values()].map((a) => a.cols));
+    const rows = Math.min(...[...s.attachments.values()].map((a) => a.rows));
+    if (cols === s.value.cols && rows === s.value.rows) return;
+    await this.settle(s);
+    if (!s.value.exited) s.pty.resize(cols, rows);
+    try {
+      await s.screen.resize(cols, rows);
+      await this.settle(s);
+    } catch (error) {
+      this.failed(s, error);
+      try {
+        if (!s.value.exited) s.pty.resize(s.value.cols, s.value.rows);
+      } catch (rollback) {
+        this.failed(s, rollback);
       }
-      open += 1;
-      const fg = this.foreground(s);
-      const busy = fg !== "" && !s.shellNames.has(fg);
-      const label = (busy ? fg : s.shellName).slice(0, PTY_LABEL_CHARS);
-      const state = busy ? "active" : "idle";
-      if (s.observed.label !== label || s.observed.state !== state) s.observed = { label, state, since: now };
-      if (busy) active += 1;
-      items.push({ type: "pty", id: s.id, label, state, sinceEpochMs: s.observed.since });
+      throw error;
     }
-    return { metrics: { ptyOpen: open, ptyActive: active, ptyExited: exited }, items };
-  }
-  /** Kills every session (the keeper is stopping). */
-  async dispose() {
-    for (const session of this.sessions.values()) {
-      session.closed = true;
-      if (!session.exited) session.pty.kill();
-      await session.rendered;
-      session.terminal.dispose();
+    s.value.cols = cols;
+    s.value.rows = rows;
+    s.geometry++;
+    this.dirty(s);
+  }
+  inputContext(s) {
+    return { cols: s.value.cols, rows: s.value.rows, geometry: s.geometry, modes: s.screen.state().modes };
+  }
+  coordinates(s, event) {
+    if (event.geometry !== s.geometry) fail("pty_geometry_mismatch", "Terminal geometry changed");
+    if (event.x >= s.value.cols || event.y >= s.value.rows) bad("Terminal coordinates outside geometry");
+  }
+  assertRunning(s) {
+    if (s.value.exited) fail("pty_exited", "Terminal has exited");
+  }
+  release(s, clientId) {
+    if (s.attachments.delete(clientId)) s.input.release(clientId);
+    this.scheduleLease(s);
+  }
+  async expire(s) {
+    let changed = false;
+    for (const [id, attachment] of s.attachments) if (attachment.expires <= this.now()) {
+      this.release(s, id);
+      changed = true;
+    }
+    if (changed) await this.capacity(s);
+  }
+  scheduleLease(s) {
+    s.leaseTimer?.dispose();
+    s.leaseTimer = void 0;
+    if (s.closed || this.disposed || !s.attachments.size) return;
+    const expires = Math.min(...[...s.attachments.values()].map((attachment) => attachment.expires));
+    s.leaseTimer = this.scheduler.schedule(() => {
+      s.leaseTimer = void 0;
+      void this.ordered(s, () => this.expire(s)).catch((error) => this.failed(s, error)).finally(() => this.scheduleLease(s));
+    }, Math.max(0, expires - this.now()));
+  }
+  async close(s) {
+    if (s.closed) return;
+    s.closed = true;
+    if (this.sessions.get(s.value.id) === s) this.sessions.delete(s.value.id);
+    s.shellNameTimer?.dispose();
+    s.shellNameTimer = void 0;
+    s.captureTimer?.dispose();
+    s.captureTimer = void 0;
+    s.leaseTimer?.dispose();
+    s.leaseTimer = void 0;
+    for (const listener of s.listeners) listener.dispose();
+    for (const id of [...s.attachments.keys()]) this.release(s, id);
+    s.input.dispose();
+    s.metadata?.dispose?.();
+    try {
+      if (!s.value.exited) s.pty.kill();
+    } finally {
+      s.screen.dispose();
+      await s.rendered.catch(() => {
+      });
     }
-    this.sessions.clear();
   }
 };
+function disposable(value) {
+  return value && typeof value.dispose === "function" ? value : { dispose: () => {
+  } };
+}
+function request(params) {
+  if (Buffer.byteLength(JSON.stringify(params)) > TERMINAL_GRID_LIMITS.maxRequestBytes) bad("Terminal request exceeds limit");
+}
+function keys2(params, allowed) {
+  if (Object.keys(params).some((key) => !allowed.includes(key))) bad("Unexpected terminal parameter");
+}
+function identifier(params, name) {
+  const value = params[name];
+  if (typeof value !== "string" || !/^[A-Za-z0-9_.:-]{1,128}$/.test(value)) return bad(`Invalid ${name}`);
+  return value;
+}
+function integer2(params, name, min, max) {
+  const value = params[name];
+  if (!Number.isSafeInteger(value) || value < min || value > max) return bad(`Invalid ${name}`);
+  return value;
+}
+function position(params) {
+  return { x: integer2(params, "x", 0, TERMINAL_GRID_LIMITS.maxCols - 1), y: integer2(params, "y", 0, TERMINAL_GRID_LIMITS.maxRows - 1), geometry: integer2(params, "geometry", 1, Number.MAX_SAFE_INTEGER) };
+}
+function input(params, ref) {
+  switch (params.kind) {
+    case "text":
+    case "paste":
+      keys2(params, [...ref, "kind", "text"]);
+      if (typeof params.text !== "string" || Buffer.byteLength(params.text) > TERMINAL_GRID_LIMITS.maxInputBytes) return bad("Terminal input exceeds limit");
+      return { kind: params.kind, text: params.text };
+    case "key":
+      keys2(params, [...ref, "kind", "usage", "down", "modifiers"]);
+      if (typeof params.down !== "boolean") return bad("Invalid down");
+      return { kind: "key", usage: integer2(params, "usage", 0, 65535), down: params.down, modifiers: integer2(params, "modifiers", 0, 15) };
+    case "pointer":
+    case "button": {
+      keys2(params, [...ref, "kind", "x", "y", "geometry", "modifiers", ...params.kind === "button" ? ["button", "down"] : []]);
+      const point = { ...position(params), modifiers: integer2(params, "modifiers", 0, 15) };
+      if (params.kind === "pointer") return { kind: "pointer", ...point };
+      if (typeof params.down !== "boolean") return bad("Invalid down");
+      return { kind: "button", ...point, button: integer2(params, "button", 0, 2), down: params.down };
+    }
+    case "release":
+      keys2(params, [...ref, "kind"]);
+      return { kind: "release" };
+    default:
+      return bad("Invalid terminal input kind");
+  }
+}
+function defaultShellProcessName(pid) {
+  if (process.platform !== "darwin") return Promise.resolve(null);
+  return new Promise((resolve) => {
+    execFile4("ps", ["-o", "ucomm=", "-p", String(pid)], { timeout: 1e3 }, (error, stdout) => resolve(error ? null : stdout.trim() || null));
+  });
+}
 
 // src/workstation/keepers/terminal/keeper.ts
 async function launchOf(p) {
@@ -8397,18 +8802,29 @@ async function launchOf(p) {
   if (!executable) badRequest("Terminal shell is not an executable file");
   return { cwd, shell, env };
 }
-var KEEPER_CREATE_KEYS = [...CREATE_KEYS, "shell", "env"];
+var KEEPER_CREATE_KEYS = ["id", "cwd", "shell", "env", "registrationId"];
 function createTerminalKeeper(options = {}) {
-  const sessions = new PtySessions(options);
+  let available = false;
+  const sessions = new NativePtySessions({ ...options, loadPty: () => {
+    const module = (options.loadPty ?? (() => createRequire2(import.meta.url)("node-pty")))();
+    available = true;
+    return module;
+  } });
   const exec = options.exec;
   return {
     sessions,
     exec,
-    capabilities: [...sessions.available ? [PTY_CAPABILITY] : [], ...exec ? [EXEC_CAPABILITY] : []],
+    capabilities: [...available ? [PTY_CAPABILITY] : [], ...exec ? [EXEC_CAPABILITY] : []],
     install(server) {
-      server.register("pty.create", (params) => sessions.create(params, KEEPER_CREATE_KEYS, () => launchOf(params)), { startsWork: true });
-      server.register("pty.list", (params) => sessions.list(params));
-      for (const op of ["attach", "poll", "write", "resize", "takeover", "detach", "close"])
+      server.register("pty.create", (params) => {
+        if (Object.keys(params).some((key) => !KEEPER_CREATE_KEYS.includes(key))) badRequest("Unexpected tool parameter");
+        return sessions.create({ id: params.id, ...params.cwd !== void 0 ? { cwd: params.cwd } : {}, ...params.registrationId !== void 0 ? { registrationId: params.registrationId } : {} }, () => launchOf(params));
+      }, { startsWork: true });
+      server.register("pty.list", (params) => {
+        if (Object.keys(params).length) badRequest("Unexpected tool parameter");
+        return sessions.list();
+      });
+      for (const op of NATIVE_PTY_OPERATIONS)
         server.register(`pty.${op}`, (params) => sessions.operate(op, params));
       server.addActivitySampler(() => sessions.activity());
       if (!exec) return;
@@ -8438,9 +8854,9 @@ function createTerminalKeeper(options = {}) {
 }
 
 // src/workstation/keepers/terminal/main.ts
-var protocolVersion = 1;
+var protocolVersion = 2;
 function loadBundledPty(bundleDir) {
-  const load = createRequire2(import.meta.url);
+  const load = createRequire3(import.meta.url);
   const resolved = realpathSync(load.resolve("node-pty"));
   if (!resolved.startsWith(realpathSync(bundleDir) + sep)) throw new Error(`node-pty resolves outside the keeper bundle (${resolved})`);
   return load("node-pty");
@@ -8449,7 +8865,7 @@ await runKeeperMain({
   kind: "terminal",
   protocolVersion,
   create: async (config, { log }) => {
-    const exec = new ExecHost({ root: path5.join(config.dataDir, "exec"), owner: { pid: process.pid, gen: config.gen, bundleDir: config.bundleDir }, log });
+    const exec = new ExecHost({ root: path6.join(config.dataDir, "exec"), owner: { pid: process.pid, gen: config.gen, bundleDir: config.bundleDir }, log });
     await exec.open();
     return createTerminalKeeper({
       exec,