terminal-pilot 0.0.17 → 0.0.19

package/dist/commands/close-session.js

@@ -3,8 +3,8 @@ import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // ../toolcraft/src/user-error.ts
 var UserError = class extends Error {
-  constructor(message) {
-    super(message);
+  constructor(message, options) {
+    super(message, options);
     this.name = "UserError";
   }
 };
@@ -40,13 +40,20 @@ function Json() {
 }
 
 // ../toolcraft-schema/src/oneof.ts
-function assertValidBranches(branches) {
+function assertValidBranches(branches, discriminator) {
   if (Object.keys(branches).length === 0) {
     throw new Error("OneOf schema requires at least one branch");
   }
+  for (const [branchName, branch] of Object.entries(branches)) {
+    if (Object.prototype.hasOwnProperty.call(branch.shape, discriminator)) {
+      throw new Error(
+        `OneOf branch "${branchName}" must not declare discriminator field "${discriminator}".`
+      );
+    }
+  }
 }
 function OneOf(config) {
-  assertValidBranches(config.branches);
+  assertValidBranches(config.branches, config.discriminator);
   return {
     kind: "oneOf",
     discriminator: config.discriminator,
@@ -66,22 +73,37 @@ function Record(value) {
 function isOptionalSchema(schema) {
   return schema.kind === "optional";
 }
-function getRequiredKeyFingerprint(schema) {
-  const requiredKeys = Object.keys(schema.shape).filter((key) => !isOptionalSchema(schema.shape[key])).sort();
-  return JSON.stringify(requiredKeys);
+function getRequiredKeys(schema) {
+  return Object.keys(schema.shape).filter((key) => !isOptionalSchema(schema.shape[key])).sort();
+}
+function assertUniqueRequiredKeyFingerprints(branches) {
+  const fingerprints = /* @__PURE__ */ new Map();
+  branches.forEach((branch, index) => {
+    const requiredKeys = getRequiredKeys(branch);
+    const fingerprint = JSON.stringify(requiredKeys);
+    const existing = fingerprints.get(fingerprint);
+    if (existing === void 0) {
+      fingerprints.set(fingerprint, {
+        display: requiredKeys.join("+"),
+        indices: [index]
+      });
+      return;
+    }
+    existing.indices.push(index);
+  });
+  for (const { display, indices } of fingerprints.values()) {
+    if (indices.length > 1) {
+      throw new Error(
+        `Union branches [${indices.join(", ")}] share required-key fingerprint "${display}". Each branch must require a distinct set of keys.`
+      );
+    }
+  }
 }
 function assertValidBranches2(branches) {
   if (branches.length === 0) {
     throw new Error("Union schema requires at least one branch");
   }
-  const fingerprints = /* @__PURE__ */ new Set();
-  for (const branch of branches) {
-    const fingerprint = getRequiredKeyFingerprint(branch);
-    if (fingerprints.has(fingerprint)) {
-      throw new Error("Union schema branches must have unique required-key fingerprints");
-    }
-    fingerprints.add(fingerprint);
-  }
+  assertUniqueRequiredKeyFingerprints(branches);
 }
 function Union(branches) {
   assertValidBranches2(branches);
@@ -100,15 +122,47 @@ function assertValidEnumValues(values) {
   if (uniqueValues.size !== values.length) {
     throw new Error("Enum schema values must be unique");
   }
+  if (values.some((value) => typeof value === "number" && !Number.isFinite(value))) {
+    throw new Error("Enum schema numeric values must be finite");
+  }
+}
+function assertNonNegativeInteger(value, name) {
+  if (value !== void 0 && (!Number.isInteger(value) || value < 0)) {
+    throw new Error(`${name} must be a non-negative integer`);
+  }
+}
+function assertFiniteNumber(value, name) {
+  if (value !== void 0 && !Number.isFinite(value)) {
+    throw new Error(`${name} must be finite`);
+  }
+}
+function assertPattern(pattern) {
+  if (pattern === void 0) {
+    return;
+  }
+  try {
+    new RegExp(pattern);
+  } catch {
+    throw new Error("pattern must be a valid regular expression");
+  }
 }
 var S = {
   String(options = {}) {
+    assertNonNegativeInteger(options.minLength, "minLength");
+    assertNonNegativeInteger(options.maxLength, "maxLength");
+    assertPattern(options.pattern);
     return {
       kind: "string",
       ...options
     };
   },
   Number(options = {}) {
+    assertFiniteNumber(options.minimum, "minimum");
+    assertFiniteNumber(options.maximum, "maximum");
+    assertFiniteNumber(options.default, "default");
+    if (options.jsonType === "integer" && options.default !== void 0 && !Number.isInteger(options.default)) {
+      throw new Error("default must be an integer");
+    }
     return {
       kind: "number",
       ...options
@@ -122,6 +176,9 @@ var S = {
   },
   Enum(values, options = {}) {
     assertValidEnumValues(values);
+    if (options.jsonType === "integer" && values.some((value) => typeof value !== "number" || !Number.isInteger(value))) {
+      throw new Error("Integer enum values must be integers");
+    }
     return {
       kind: "enum",
       values,
@@ -129,6 +186,8 @@ var S = {
     };
   },
   Array(item, options = {}) {
+    assertNonNegativeInteger(options.minItems, "minItems");
+    assertNonNegativeInteger(options.maxItems, "maxItems");
     return {
       kind: "array",
       item,
@@ -341,12 +400,15 @@ function materializeCommand(command, inherited) {
 }
 function defineCommand(config) {
   validateHumanInLoopOnDefine(config);
-  return materializeCommand(createBaseCommand(config), {
-    scope: void 0,
-    humanInLoop: void 0,
-    secrets: {},
-    requires: void 0
-  });
+  return materializeCommand(
+    createBaseCommand(config),
+    {
+      scope: void 0,
+      humanInLoop: void 0,
+      secrets: {},
+      requires: void 0
+    }
+  );
 }
 
 // src/terminal-pilot.ts
@@ -434,27 +496,53 @@ function consumeTerminatedString(input, index, allowBellTerminator) {
 
 // src/terminal-buffer.ts
 var RESET_SGR = "\x1B[0m";
+var DEC_SPECIAL_GRAPHICS = {
+  j: "\u2518",
+  k: "\u2510",
+  l: "\u250C",
+  m: "\u2514",
+  n: "\u253C",
+  q: "\u2500",
+  t: "\u251C",
+  u: "\u2524",
+  v: "\u2534",
+  w: "\u252C",
+  x: "\u2502"
+};
 var TerminalBuffer = class {
   _cols;
   _rows;
   _screen;
+  _primaryScreen = null;
   _cursorX = 0;
   _cursorY = 0;
-  _savedCursor = { x: 0, y: 0 };
+  _savedCursor;
   _scrollTop = 0;
   _scrollBottom;
   _state = 0 /* Normal */;
   _csiParams = "";
   _csiPrivate = "";
   _autoWrap = true;
+  _pendingWrap = false;
+  _originMode = false;
+  _insertMode = false;
+  _tabStops;
+  _lastPrintedChar = null;
   _style = createDefaultStyleState();
   _styleSequence = "";
+  _stringState = 0 /* Normal */;
+  _charsetTarget = null;
+  _g0Charset = "ascii";
+  _g1Charset = "ascii";
+  _shiftOut = false;
   displayBuffer;
   constructor(cols, rows) {
     this._cols = cols;
     this._rows = rows;
     this._scrollBottom = rows - 1;
     this._screen = this._makeScreen(cols, rows);
+    this._tabStops = this._createDefaultTabStops(cols);
+    this._savedCursor = this._createSavedCursorState();
     this.displayBuffer = Object.defineProperties(
       {},
       {
@@ -510,8 +598,12 @@ var TerminalBuffer = class {
     }
     this._cols = cols;
     this._rows = rows;
-    this._scrollTop = 0;
-    this._scrollBottom = rows - 1;
+    this._scrollTop = this._clamp(this._scrollTop, 0, rows - 1);
+    this._scrollBottom = this._clamp(this._scrollBottom, 0, rows - 1);
+    if (this._scrollTop >= this._scrollBottom) {
+      this._scrollTop = 0;
+      this._scrollBottom = rows - 1;
+    }
     this._cursorX = this._clamp(this._cursorX, 0, cols - 1);
     this._cursorY = this._clamp(this._cursorY, 0, rows - 1);
   }
@@ -521,13 +613,96 @@ var TerminalBuffer = class {
   _makeRow(cols) {
     return Array(cols).fill(null);
   }
+  _createDefaultTabStops(cols) {
+    const tabStops = /* @__PURE__ */ new Set();
+    for (let column = 8; column < cols; column += 8) {
+      tabStops.add(column);
+    }
+    return tabStops;
+  }
   _clamp(value, min, max) {
     return Math.max(min, Math.min(max, value));
   }
+  _createSavedCursorState() {
+    return {
+      x: this._cursorX,
+      y: this._cursorY,
+      autoWrap: this._autoWrap,
+      style: { ...this._style, fg: this._style.fg?.slice(), bg: this._style.bg?.slice() },
+      styleSequence: this._styleSequence
+    };
+  }
+  _saveCursor() {
+    this._savedCursor = this._createSavedCursorState();
+  }
+  _restoreCursor() {
+    this._cursorX = this._clamp(this._savedCursor.x, 0, this._cols - 1);
+    this._cursorY = this._clamp(this._savedCursor.y, 0, this._rows - 1);
+    this._autoWrap = this._savedCursor.autoWrap;
+    this._style = {
+      ...this._savedCursor.style,
+      fg: this._savedCursor.style.fg?.slice(),
+      bg: this._savedCursor.style.bg?.slice()
+    };
+    this._styleSequence = this._savedCursor.styleSequence;
+  }
+  _resetModes() {
+    this._autoWrap = true;
+    this._originMode = false;
+    this._insertMode = false;
+    this._pendingWrap = false;
+    this._tabStops = this._createDefaultTabStops(this._cols);
+    this._g0Charset = "ascii";
+    this._g1Charset = "ascii";
+    this._shiftOut = false;
+    this._resetStyle();
+  }
+  _writePrintable(ch) {
+    const width = this._cellWidth(ch);
+    if (this._autoWrap && this._pendingWrap) {
+      this._cursorX = 0;
+      this._newline();
+    } else if (this._autoWrap && this._cursorX + width > this._cols) {
+      this._cursorX = 0;
+      this._newline();
+    }
+    if (this._insertMode) {
+      const row = this._screen[this._cursorY];
+      if (row) {
+        row.splice(this._cursorX, 0, ...Array(width).fill(null));
+        row.splice(this._cols);
+      }
+    }
+    this._setChar(this._cursorY, this._cursorX, ch);
+    for (let column = 1; column < width && this._cursorX + column < this._cols; column += 1) {
+      const row = this._screen[this._cursorY];
+      if (row) row[this._cursorX + column] = null;
+    }
+    this._lastPrintedChar = ch;
+    if (!this._autoWrap) {
+      this._cursorX = Math.min(this._cursorX + width, this._cols - 1);
+      this._pendingWrap = false;
+    } else if (this._cursorX + width >= this._cols) {
+      this._cursorX = this._cols - 1;
+      this._pendingWrap = true;
+    } else {
+      this._cursorX += width;
+      this._pendingWrap = false;
+    }
+  }
+  _cellWidth(ch) {
+    const codePoint = ch.codePointAt(0);
+    if (codePoint === void 0) return 0;
+    if (codePoint >= 4352 && codePoint <= 4447 || codePoint === 9001 || codePoint === 9002 || codePoint >= 11904 && codePoint <= 12350 || codePoint >= 12353 && codePoint <= 13247 || codePoint >= 13312 && codePoint <= 19903 || codePoint >= 19968 && codePoint <= 42191 || codePoint >= 44032 && codePoint <= 55215 || codePoint >= 63744 && codePoint <= 64255 || codePoint >= 65040 && codePoint <= 65049 || codePoint >= 65072 && codePoint <= 65135 || codePoint >= 65280 && codePoint <= 65376 || codePoint >= 65504 && codePoint <= 65510 || codePoint >= 127488 && codePoint <= 131069 || codePoint >= 131072 && codePoint <= 262141) {
+      return Math.min(2, this._cols);
+    }
+    return 1;
+  }
   _setChar(y, x, ch) {
     const row = this._screen[y];
     if (row && x >= 0 && x < this._cols) {
-      const cell = [ch.charCodeAt(0), ch];
+      const renderedChar = this._style.conceal ? " " : ch;
+      const cell = [renderedChar.charCodeAt(0), renderedChar];
       if (this._styleSequence.length > 0) {
         Object.defineProperty(cell, "style", {
           value: this._styleSequence,
@@ -558,6 +733,7 @@ var TerminalBuffer = class {
     }
   }
   _newline() {
+    this._pendingWrap = false;
     if (this._cursorY === this._scrollBottom) {
       this._scrollUp(1);
     } else {
@@ -566,7 +742,11 @@ var TerminalBuffer = class {
   }
   _parseCsiParams() {
     if (!this._csiParams) return [];
-    return this._csiParams.split(";").map((s) => s === "" ? 0 : parseInt(s, 10));
+    const values = this._csiParams.split(";").flatMap((segment) => segment.split(":")).map((segment) => segment === "" ? 0 : parseInt(segment, 10));
+    if ((values[0] === 38 || values[0] === 48) && values[1] === 2 && values[2] === 0) {
+      values.splice(2, 1);
+    }
+    return values;
   }
   _execCsi(final) {
     const params2 = this._parseCsiParams();
@@ -577,21 +757,45 @@ var TerminalBuffer = class {
         if (params2.includes(7)) {
           this._autoWrap = final === "h";
         }
+        if (params2.includes(6)) {
+          this._originMode = final === "h";
+          this._cursorX = 0;
+          this._cursorY = this._originMode ? this._scrollTop : 0;
+        }
         if (params2.includes(1049)) {
           if (final === "h") {
+            this._primaryScreen = {
+              screen: this._screen,
+              cursorX: this._cursorX,
+              cursorY: this._cursorY,
+              pendingWrap: this._pendingWrap,
+              style: { ...this._style, fg: this._style.fg?.slice(), bg: this._style.bg?.slice() },
+              styleSequence: this._styleSequence
+            };
             this._screen = this._makeScreen(this._cols, this._rows);
             this._cursorX = 0;
             this._cursorY = 0;
+            this._pendingWrap = false;
           } else {
-            this._screen = this._makeScreen(this._cols, this._rows);
-            this._cursorX = 0;
-            this._cursorY = 0;
+            if (this._primaryScreen !== null) {
+              this._screen = this._primaryScreen.screen;
+              this._cursorX = this._primaryScreen.cursorX;
+              this._cursorY = this._primaryScreen.cursorY;
+              this._pendingWrap = this._primaryScreen.pendingWrap;
+              this._style = this._primaryScreen.style;
+              this._styleSequence = this._primaryScreen.styleSequence;
+              this._primaryScreen = null;
+            }
           }
-          this._resetStyle();
+          if (final === "h") this._resetStyle();
         }
       }
       return;
     }
+    if ((final === "h" || final === "l") && params2.includes(4)) {
+      this._insertMode = final === "h";
+      return;
+    }
     switch (final) {
       case "A":
         this._cursorY = this._clamp(this._cursorY - Math.max(1, p0), 0, this._rows - 1);
@@ -623,7 +827,7 @@ var TerminalBuffer = class {
       case "H":
       // cursor position
       case "f":
-        this._cursorY = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
+        this._cursorY = this._originMode ? this._clamp(this._scrollTop + Math.max(1, p0) - 1, this._scrollTop, this._scrollBottom) : this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
         this._cursorX = this._clamp(Math.max(1, p1) - 1, 0, this._cols - 1);
         break;
       case "I":
@@ -638,7 +842,7 @@ var TerminalBuffer = class {
         } else if (p0 === 1) {
           for (let y = 0; y < this._cursorY; y++) this._eraseLine(y, 0, this._cols - 1);
           this._eraseLine(this._cursorY, 0, this._cursorX);
-        } else if (p0 === 2 || p0 === 3) {
+        } else if (p0 === 2) {
           for (let y = 0; y < this._rows; y++) this._eraseLine(y, 0, this._cols - 1);
         }
         break;
@@ -651,6 +855,9 @@ var TerminalBuffer = class {
         this._eraseLine(this._cursorY, this._cursorX, this._cursorX + Math.max(1, p0) - 1);
         break;
       case "L": {
+        if (this._cursorY < this._scrollTop || this._cursorY > this._scrollBottom) {
+          break;
+        }
         const n = Math.max(1, p0);
         for (let i = 0; i < n; i++) {
           this._screen.splice(this._scrollBottom, 1);
@@ -659,6 +866,9 @@ var TerminalBuffer = class {
         break;
       }
       case "M": {
+        if (this._cursorY < this._scrollTop || this._cursorY > this._scrollBottom) {
+          break;
+        }
         const n = Math.max(1, p0);
         for (let i = 0; i < n; i++) {
           this._screen.splice(this._cursorY, 1);
@@ -697,6 +907,13 @@ var TerminalBuffer = class {
         }
         break;
       }
+      case "b":
+        if (this._lastPrintedChar !== null) {
+          for (let index = 0; index < Math.max(1, p0); index += 1) {
+            this._writePrintable(this._lastPrintedChar);
+          }
+        }
+        break;
       case "d":
         this._cursorY = this._clamp(Math.max(1, p0) - 1, 0, this._rows - 1);
         break;
@@ -711,15 +928,19 @@ var TerminalBuffer = class {
           this._scrollBottom = bottom;
         }
         this._cursorX = 0;
-        this._cursorY = 0;
+        this._cursorY = this._originMode ? this._scrollTop : 0;
         break;
       }
       case "s":
-        this._savedCursor = { x: this._cursorX, y: this._cursorY };
+        this._saveCursor();
         break;
       case "u":
-        this._cursorX = this._clamp(this._savedCursor.x, 0, this._cols - 1);
-        this._cursorY = this._clamp(this._savedCursor.y, 0, this._rows - 1);
+        this._restoreCursor();
+        break;
+      case "p":
+        if (this._csiPrivate === "!") {
+          this._resetModes();
+        }
         break;
       case "m":
         this._applySgr(params2);
@@ -730,6 +951,14 @@ var TerminalBuffer = class {
   }
   _feed(ch) {
     const code = ch.charCodeAt(0);
+    if (this._state !== 0 /* Normal */ && (code === 24 || code === 26)) {
+      this._state = 0 /* Normal */;
+      return;
+    }
+    if (this._state === 2 /* Csi */ && code === 27) {
+      this._state = 1 /* Escape */;
+      return;
+    }
     switch (this._state) {
       case 0 /* Normal */:
         this._feedNormal(ch, code);
@@ -744,20 +973,37 @@ var TerminalBuffer = class {
         if (code === 7 || code === 156) {
           this._state = 0 /* Normal */;
         } else if (code === 27) {
-          this._state = 0 /* Normal */;
+          this._stringState = 3 /* Osc */;
+          this._state = 5 /* StringEscape */;
         }
         break;
       case 4 /* Str */:
-        if (code === 156 || code === 7) {
+        if (code === 156) {
           this._state = 0 /* Normal */;
         } else if (code === 27) {
-          this._state = 0 /* Normal */;
+          this._stringState = 4 /* Str */;
+          this._state = 5 /* StringEscape */;
         }
         break;
-      case 5 /* EscCharset */:
+      case 5 /* StringEscape */:
+        this._state = ch === "\\" ? 0 /* Normal */ : this._stringState;
+        break;
+      case 6 /* EscCharset */:
+        if (this._charsetTarget === "g0") this._g0Charset = ch === "0" ? "graphics" : "ascii";
+        if (this._charsetTarget === "g1") this._g1Charset = ch === "0" ? "graphics" : "ascii";
+        this._charsetTarget = null;
         this._state = 0 /* Normal */;
         break;
-      case 6 /* EscHash */:
+      case 7 /* EscHash */:
+        if (ch === "8") {
+          for (let row = 0; row < this._rows; row += 1) {
+            for (let column = 0; column < this._cols; column += 1) {
+              this._setChar(row, column, "E");
+            }
+          }
+          this._cursorX = 0;
+          this._cursorY = 0;
+        }
         this._state = 0 /* Normal */;
         break;
     }
@@ -773,32 +1019,28 @@ var TerminalBuffer = class {
       this._state = 3 /* Osc */;
     } else if (code === 144 || code === 152 || code === 158 || code === 159) {
       this._state = 4 /* Str */;
+    } else if (code === 133) {
+      this._cursorX = 0;
+      this._newline();
+    } else if (code === 156) {
     } else if (code === 7 || code === 5 || code === 6) {
     } else if (code === 8) {
+      this._pendingWrap = false;
       if (this._cursorX > 0) this._cursorX--;
     } else if (code === 127) {
-      if (this._cursorX > 0) {
-        this._cursorX--;
-        this._setChar(this._cursorY, this._cursorX, " ");
-      }
     } else if (code === 9) {
-      this._cursorX = Math.min(this._cols - 1, (Math.floor(this._cursorX / 8) + 1) * 8);
+      const nextTabStop = [...this._tabStops].sort((left, right) => left - right).find((tabStop) => tabStop > this._cursorX);
+      this._cursorX = nextTabStop ?? this._cols - 1;
     } else if (code === 10 || code === 11 || code === 12) {
       this._newline();
     } else if (code === 13) {
+      this._pendingWrap = false;
       this._cursorX = 0;
     } else if (code === 14 || code === 15) {
+      this._shiftOut = code === 14;
     } else if (code >= 32 && code !== 127) {
-      this._setChar(this._cursorY, this._cursorX, ch);
-      this._cursorX++;
-      if (!this._autoWrap) {
-        this._cursorX = Math.min(this._cursorX, this._cols - 1);
-        return;
-      }
-      if (this._cursorX >= this._cols) {
-        this._cursorX = 0;
-        this._newline();
-      }
+      const charset = this._shiftOut ? this._g1Charset : this._g0Charset;
+      this._writePrintable(charset === "graphics" ? DEC_SPECIAL_GRAPHICS[ch] ?? ch : ch);
     }
   }
   _feedEscape(ch, code) {
@@ -812,14 +1054,14 @@ var TerminalBuffer = class {
     } else if (code === 80 || code === 88 || code === 94 || code === 95) {
       this._state = 4 /* Str */;
     } else if (code === 40 || code === 41 || code === 42 || code === 43 || code === 45 || code === 46) {
-      this._state = 5 /* EscCharset */;
+      this._charsetTarget = code === 40 ? "g0" : code === 41 ? "g1" : null;
+      this._state = 6 /* EscCharset */;
     } else if (code === 35) {
-      this._state = 6 /* EscHash */;
+      this._state = 7 /* EscHash */;
     } else if (code === 55) {
-      this._savedCursor = { x: this._cursorX, y: this._cursorY };
+      this._saveCursor();
     } else if (code === 56) {
-      this._cursorX = this._clamp(this._savedCursor.x, 0, this._cols - 1);
-      this._cursorY = this._clamp(this._savedCursor.y, 0, this._rows - 1);
+      this._restoreCursor();
     } else if (code === 68) {
       this._newline();
     } else if (code === 69) {
@@ -832,14 +1074,15 @@ var TerminalBuffer = class {
         this._cursorY = Math.max(0, this._cursorY - 1);
       }
     } else if (code === 72) {
+      this._tabStops.add(this._cursorX);
     } else if (code === 99) {
       this._screen = this._makeScreen(this._cols, this._rows);
       this._cursorX = 0;
       this._cursorY = 0;
-      this._savedCursor = { x: 0, y: 0 };
       this._scrollTop = 0;
       this._scrollBottom = this._rows - 1;
-      this._resetStyle();
+      this._resetModes();
+      this._savedCursor = this._createSavedCursorState();
     }
   }
   _feedCsi(ch, code) {
@@ -848,7 +1091,7 @@ var TerminalBuffer = class {
       this._state = 0 /* Normal */;
     } else if (code === 63 || code === 33 || code === 62 || code === 32) {
       this._csiPrivate = ch;
-    } else if (code >= 48 && code <= 57 || code === 59) {
+    } else if (code >= 48 && code <= 57 || code === 59 || code === 58) {
       this._csiParams += ch;
     }
   }
@@ -879,6 +1122,9 @@ var TerminalBuffer = class {
         case 7:
           this._style.inverse = true;
           break;
+        case 8:
+          this._style.conceal = true;
+          break;
         case 9:
           this._style.strikethrough = true;
           break;
@@ -896,6 +1142,9 @@ var TerminalBuffer = class {
         case 27:
           this._style.inverse = false;
           break;
+        case 28:
+          this._style.conceal = false;
+          break;
         case 29:
           this._style.strikethrough = false;
           break;
@@ -950,6 +1199,7 @@ function createDefaultStyleState() {
     italic: false,
     underline: false,
     inverse: false,
+    conceal: false,
     strikethrough: false
   };
 }
@@ -970,6 +1220,9 @@ function serializeStyleState(state) {
   if (state.inverse) {
     codes.push(7);
   }
+  if (state.conceal) {
+    codes.push(8);
+  }
   if (state.strikethrough) {
     codes.push(9);
   }
@@ -1088,6 +1341,7 @@ var WAIT_FOR_POLL_MS = 10;
 var TYPE_DELAY_MS = 15;
 var CLOSE_AFTER_SIGNAL_GRACE_MS = 250;
 var CLOSE_AFTER_SIGTERM_MS = 1e3;
+var CLOSE_AFTER_SIGKILL_MS = 1e3;
 var TerminalSession = class {
   id;
   command;
@@ -1101,8 +1355,7 @@ var TerminalSession = class {
   lastDataAt = Date.now();
   currentCols;
   currentRows;
-  closeRequested = false;
-  signalRequested = false;
+  closePromise = null;
   constructor({
     id,
     command,
@@ -1113,6 +1366,7 @@ var TerminalSession = class {
     rows = DEFAULT_ROWS,
     observe = false
   }) {
+    assertTerminalGeometry(cols, rows);
     this.id = id;
     this.command = command;
     this.currentCols = cols;
@@ -1157,7 +1411,7 @@ var TerminalSession = class {
   }
   async send(raw) {
     if (this.exitCode !== null) {
-      return;
+      throw new Error(`Terminal session "${this.id}" has already exited.`);
     }
     this.pty.write(raw);
   }
@@ -1165,22 +1419,26 @@ var TerminalSession = class {
     if (this.exitCode !== null) {
       return;
     }
-    this.signalRequested = true;
     this.pty.kill(sig);
   }
   async waitFor(pattern, opts) {
     const timeout = opts?.timeout ?? DEFAULT_TIMEOUT_MS;
+    assertTimeout(timeout);
     const startedAt = Date.now();
     while (Date.now() - startedAt <= timeout) {
       const matched = matchPattern(this.rawBuffer, pattern);
       if (matched !== null) {
         return matched;
       }
+      if (this.exitCode !== null) {
+        throw new Error(`Terminal session "${this.id}" exited before matching pattern: ${String(pattern)}`);
+      }
       await sleep(WAIT_FOR_POLL_MS);
     }
     throw new Error(`Timed out waiting for pattern after ${timeout}ms: ${String(pattern)}`);
   }
   async waitForQuiet(ms) {
+    assertQuietPeriod(ms);
     while (true) {
       const remaining = ms - (Date.now() - this.lastDataAt);
       if (remaining <= 0) {
@@ -1213,10 +1471,14 @@ var TerminalSession = class {
     if (opts?.last === void 0) {
       return lines;
     }
+    if (!Number.isInteger(opts.last) || opts.last < 0) {
+      throw new Error("History last must be a non-negative integer.");
+    }
     const start = Math.max(0, lines.length - opts.last);
     return lines.slice(start);
   }
   async resize(cols, rows) {
+    assertTerminalGeometry(cols, rows);
     this.currentCols = cols;
     this.currentRows = rows;
     if (this.exitCode === null) {
@@ -1225,6 +1487,9 @@ var TerminalSession = class {
     this.terminal.resize(cols, rows);
   }
   async waitForExit(opts) {
+    if (opts?.timeout !== void 0) {
+      assertTimeout(opts.timeout);
+    }
     if (this.exitCode !== null) {
       return this.exitCode;
     }
@@ -1241,32 +1506,52 @@ var TerminalSession = class {
     if (this.exitCode !== null) {
       return this.exitCode;
     }
-    if (!this.closeRequested) {
-      this.closeRequested = true;
-      const gracefulExitCode = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGNAL_GRACE_MS);
-      if (gracefulExitCode !== null) {
-        return gracefulExitCode;
-      }
-      if (this.signalRequested) {
-        return this.exitPromise;
-      }
-      if (this.exitCode === null) {
-        this.pty.kill("SIGTERM");
-        const afterSigterm = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGTERM_MS);
-        if (afterSigterm !== null) {
-          return afterSigterm;
-        }
+    this.closePromise ??= this.closeProcess().catch((error) => {
+      this.closePromise = null;
+      throw error;
+    });
+    return this.closePromise;
+  }
+  async closeProcess() {
+    const gracefulExitCode = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGNAL_GRACE_MS);
+    if (gracefulExitCode !== null) {
+      return gracefulExitCode;
+    }
+    if (this.exitCode === null) {
+      this.pty.kill("SIGTERM");
+      const afterSigterm = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGTERM_MS);
+      if (afterSigterm !== null) {
+        return afterSigterm;
       }
-      if (this.exitCode === null) {
-        this.pty.kill("SIGKILL");
+    }
+    if (this.exitCode === null) {
+      this.pty.kill("SIGKILL");
+      const afterSigkill = await waitForExit(this.exitPromise, CLOSE_AFTER_SIGKILL_MS);
+      if (afterSigkill !== null) {
+        return afterSigkill;
       }
     }
-    return this.exitPromise;
+    throw new Error("Timed out waiting for process to exit after SIGKILL.");
   }
   on(event, cb) {
     this.emitter.on(event, cb);
   }
 };
+function assertTerminalGeometry(cols, rows) {
+  if (!Number.isInteger(cols) || cols <= 0 || !Number.isInteger(rows) || rows <= 0) {
+    throw new Error("Terminal columns and rows must be positive integers.");
+  }
+}
+function assertTimeout(timeout) {
+  if (!Number.isFinite(timeout) || timeout < 0) {
+    throw new Error("Timeout must be a finite non-negative number.");
+  }
+}
+function assertQuietPeriod(duration) {
+  if (!Number.isFinite(duration) || duration < 0) {
+    throw new Error("Quiet period must be a finite non-negative number.");
+  }
+}
 function createPtyProcess({
   command,
   args,
@@ -1343,13 +1628,28 @@ function splitHistoryLines(input) {
 }
 function normalizeHistoryBuffer(input) {
   let output = "";
+  let line = "";
+  let cursor = 0;
   for (const character of input) {
-    if (character === "\r" || character === "\b") {
+    if (character === "\r") {
+      cursor = 0;
       continue;
     }
-    output += character;
+    if (character === "\b") {
+      cursor = Math.max(0, cursor - 1);
+      continue;
+    }
+    if (character === "\n") {
+      output += `${line}
+`;
+      line = "";
+      cursor = 0;
+      continue;
+    }
+    line = `${line.slice(0, cursor)}${character}${line.slice(cursor + 1)}`;
+    cursor += 1;
   }
-  return output;
+  return output + line;
 }
 function sleep(ms) {
   return new Promise((resolve) => {
@@ -1414,11 +1714,12 @@ var TerminalPilot = class _TerminalPilot {
   }
   async close() {
     const sessions = [...this.sessionMap.values()];
-    try {
-      await Promise.all(sessions.map((session) => session.close()));
-    } finally {
-      this.sessionMap.clear();
-    }
+    await Promise.all(
+      sessions.map(async (session) => {
+        await session.close();
+        this.sessionMap.delete(session.id);
+      })
+    );
   }
 };
 
@@ -1436,6 +1737,7 @@ function createTerminalPilotRuntime(options = {}) {
   const launchPilot = options.launchPilot ?? TerminalPilot.launch;
   const nameToId = /* @__PURE__ */ new Map();
   const idToName = /* @__PURE__ */ new Map();
+  const pendingNames = /* @__PURE__ */ new Set();
   let pilotPromise;
   function getRequestedName(name, env) {
     return name ?? env?.get(SESSION_ENV_VAR);
@@ -1446,7 +1748,7 @@ function createTerminalPilotRuntime(options = {}) {
   }
   function nextSessionName() {
     let index = 1;
-    while (nameToId.has(`s${index}`)) {
+    while (nameToId.has(`s${index}`) || pendingNames.has(`s${index}`)) {
       index += 1;
     }
     return `s${index}`;
@@ -1457,8 +1759,12 @@ function createTerminalPilotRuntime(options = {}) {
     return { name, session };
   }
   function forgetSession(name, sessionId) {
-    nameToId.delete(name);
-    idToName.delete(sessionId);
+    if (nameToId.get(name) === sessionId) {
+      nameToId.delete(name);
+    }
+    if (idToName.get(sessionId) === name) {
+      idToName.delete(sessionId);
+    }
   }
   function formatAvailableSessions(names) {
     if (names.length === 0) {
@@ -1491,22 +1797,44 @@ function createTerminalPilotRuntime(options = {}) {
       return [{ name, session }];
     });
   }
+  async function discardExitedSessionName(name) {
+    const sessionId = nameToId.get(name);
+    if (sessionId === void 0) {
+      return;
+    }
+    const pilot = await getPilot();
+    try {
+      const session = pilot.getSession(sessionId);
+      if (session.exitCode === null) {
+        return;
+      }
+      pilot.deleteSession(sessionId);
+    } catch {
+    }
+    forgetSession(name, sessionId);
+  }
   return {
     async createSession(params2, env) {
       const requestedName = getRequestedName(params2.session, env) ?? nextSessionName();
-      if (nameToId.has(requestedName)) {
+      await discardExitedSessionName(requestedName);
+      if (nameToId.has(requestedName) || pendingNames.has(requestedName)) {
         throw new UserError(`Session "${requestedName}" already exists.`);
       }
-      const pilot = await getPilot();
-      const session = await pilot.newSession({
-        command: params2.command,
-        args: params2.args,
-        cwd: params2.cwd,
-        cols: params2.cols,
-        rows: params2.rows,
-        observe: params2.observe
-      });
-      return rememberSession(requestedName, session);
+      pendingNames.add(requestedName);
+      try {
+        const pilot = await getPilot();
+        const session = await pilot.newSession({
+          command: params2.command,
+          args: params2.args,
+          cwd: params2.cwd,
+          cols: params2.cols,
+          rows: params2.rows,
+          observe: params2.observe
+        });
+        return rememberSession(requestedName, session);
+      } finally {
+        pendingNames.delete(requestedName);
+      }
     },
     async resolveSession(name, env) {
       const requestedName = getRequestedName(name, env);
@@ -1545,6 +1873,7 @@ function createTerminalPilotRuntime(options = {}) {
       pilotPromise = void 0;
       nameToId.clear();
       idToName.clear();
+      pendingNames.clear();
     }
   };
 }