@vecteur/cli 0.8.0 → 0.9.0

package/src/folders.js

@@ -0,0 +1,270 @@
+import { createHash, randomUUID } from "node:crypto";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, relative, sep, parse } from "node:path";
+import { credentialsPath } from "./credentials.js";
+import { CliError } from "./errors.js";
+import { readStore, withStoreLock, writeStore } from "./store.js";
+
+export const UNSIGNED_ACCOUNT = "local:unsigned";
+
+const MAX_DRAFT_BYTES = 256 * 1024;
+const DRAFT_LIFETIME_MS = 30 * 24 * 60 * 60 * 1_000;
+const identity = path => {
+  const real = realpathSync(path);
+  const stat = statSync(real, { bigint: true });
+  if (!stat.isDirectory()) throw new CliError("folder_invalid", "The session needs a directory");
+  return { path: real, device: String(stat.dev), inode: String(stat.ino) };
+};
+export function broadRoot(path, home, { platform = process.platform, mounts, stat = statSync } = {}) {
+  const folder = realpathSync(path);
+  if (folder === realpathSync(home)) return "home";
+  if (folder === parse(folder).root) return "filesystem root";
+  if (platform === "linux") {
+    const text = mounts ?? readFileSync("/proc/self/mountinfo", "utf8");
+    const roots = text.split("\n").map(line => line.split(" ")[4]?.replace(/\\([0-7]{3})/g,
+      (_, octal) => String.fromCharCode(parseInt(octal, 8))));
+    if (roots.includes(folder)) return "mount root";
+  }
+  return stat(folder).dev !== stat(dirname(folder)).dev ? "mount root" : null;
+}
+
+const contains = (root, child) => {
+  const path = relative(root, child);
+  return path === "" || (!isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`));
+};
+
+function readRegistry(file) {
+  const value = readStore(file);
+  if (value === null) return { version: 1, folders: {} };
+  if (value.version !== 1) throw new CliError("store_version_unsupported",
+    "Folder registry version is unsupported; install the matching CLI. Existing bytes were preserved.");
+  if (!value.folders || typeof value.folders !== "object" || Array.isArray(value.folders)
+      || Object.values(value.folders).some(row => !row || typeof row !== "object"
+        || typeof row.origin !== "string" || typeof row.accountId !== "string"
+        || typeof row.folder?.path !== "string" || typeof row.folder?.device !== "string"
+        || typeof row.folder?.inode !== "string")
+      || (value.logins !== undefined && (!value.logins || typeof value.logins !== "object" || Array.isArray(value.logins)
+        || Object.entries(value.logins).some(([key, id]) => !/^[a-f0-9]{64}$/.test(key) || typeof id !== "string" || !id)))) {
+    throw new CliError("store_unreadable", "Folder registry is invalid; existing bytes were preserved");
+  }
+  for (const row of Object.values(value.folders)) {
+    row.drafts ??= {};
+    if (row.draft && row.draftAt > Date.now() - DRAFT_LIFETIME_MS) {
+      row.drafts.legacy ??= { text: row.draft, at: row.draftAt, revision: String(row.draftAt) };
+    }
+    delete row.draft; delete row.draftAt;
+    if (!row.drafts || typeof row.drafts !== "object" || Array.isArray(row.drafts)
+        || Object.values(row.drafts).some(draft => !draft || typeof draft.text !== "string"
+          || typeof draft.revision !== "string" || !Number.isFinite(draft.at))) {
+      throw new CliError("store_unreadable", "Saved drafts are invalid; existing bytes were preserved");
+    }
+    for (const [id, draft] of Object.entries(row.drafts)) {
+      if (!draft.text || draft.at <= Date.now() - DRAFT_LIFETIME_MS) delete row.drafts[id];
+    }
+  }
+  return value;
+}
+
+
+/** Metadata only: a Project binding is never a local filesystem grant. */
+export class FolderRegistry {
+  constructor({ origin, accountId, cwd = process.cwd(), env = process.env }) {
+    if (!origin || !accountId) throw new CliError("folder_identity_invalid", "Origin and account are required");
+    this.origin = origin;
+    this.accountId = accountId;
+    this.folder = identity(cwd);
+    this.home = env.HOME || homedir();
+    this.file = join(dirname(credentialsPath(env)), "folders.json");
+    this.key = createHash("sha256").update(JSON.stringify([origin, accountId, this.folder.path])).digest("hex");
+    this.lastDraft = ""; this.draftRef = null;
+    try {
+      const newest = this.state().drafts[0];
+      if (newest) this.selectDraft(newest.id);
+    } catch (error) { if (error.code !== "folder_replaced") throw error; }
+  }
+
+  static forCredential({ origin, token, env = process.env, cwd = process.cwd() }) {
+    const file = join(dirname(credentialsPath(env)), "folders.json");
+    const accountId = readRegistry(file).logins?.[createHash("sha256").update(JSON.stringify([origin, token])).digest("hex")];
+    return typeof accountId === "string" && accountId
+      ? new FolderRegistry({ origin, accountId, cwd, env }) : null;
+  }
+
+  requireAccount() {
+    if (this.accountId === UNSIGNED_ACCOUNT) throw new CliError("login_required", "Unsigned drafts cannot bind a Project or authorize work");
+  }
+
+  rememberLogin(token) {
+    this.requireAccount();
+    withStoreLock(this.file, () => {
+      const store = this.#read();
+      store.logins ??= {};
+      store.logins[createHash("sha256").update(JSON.stringify([this.origin, token])).digest("hex")] = this.accountId;
+      writeStore(this.file, store);
+    });
+  }
+
+  #read() { return readRegistry(this.file); }
+
+  #update(change) {
+    return withStoreLock(this.file, () => {
+      const store = this.#read();
+      const row = store.folders[this.key] ?? { origin: this.origin, accountId: this.accountId, folder: this.folder };
+      if (row.folder.device !== this.folder.device || row.folder.inode !== this.folder.inode) {
+        throw new CliError("folder_replaced", "This directory was replaced. Unlink its old identity before continuing.");
+      }
+      const result = change(row, store);
+      store.folders[this.key] = row;
+      writeStore(this.file, store);
+      return result;
+    });
+  }
+
+  binding() {
+    if (this.accountId === UNSIGNED_ACCOUNT) return null;
+    const entries = Object.values(this.#read().folders).filter(row =>
+      row.origin === this.origin && row.accountId === this.accountId && (row.projectId || row.unlinked)
+      && contains(row.folder.path, this.folder.path));
+    entries.sort((a, b) => b.folder.path.length - a.folder.path.length);
+    const row = entries[0];
+    if (!row || row.unlinked) return null;
+    let current;
+    try { current = identity(row.folder.path); } catch { return { ...row, state: "folder_missing" }; }
+    return { ...row, state: current.device === row.folder.device && current.inode === row.folder.inode
+      ? "bound" : "folder_replaced" };
+  }
+
+  broadRoot() { return broadRoot(this.folder.path, this.home); }
+
+  bind(projectId, { confirmHome = false, confirmBroad = confirmHome } = {}) {
+    this.requireAccount();
+    if (typeof projectId !== "string" || !projectId) throw new CliError("project_invalid", "Choose a Project first");
+    const broad = this.broadRoot();
+    if (broad && !confirmBroad) {
+      throw new CliError(broad === "home" ? "home_binding_confirmation" : "root_binding_confirmation",
+        `Linking this ${broad} applies to its descendants. Type ${this.folder.path} to confirm.`);
+    }
+    return this.#update(row => {
+      if (row.pendingCreate || row.pendingRun) {
+        throw new CliError("operation_unresolved", "Resolve the pending submission before relinking");
+      }
+      row.projectId = projectId;
+      delete row.unlinked;
+      delete row.pendingCreate;
+    });
+  }
+
+  unlink() {
+    return withStoreLock(this.file, () => {
+      const store = this.#read();
+      const row = store.folders[this.key];
+      if (row?.pendingCreate || row?.pendingRun) throw new CliError("operation_unresolved",
+        "Reconcile the pending submission before unlinking; its identity must survive");
+      store.folders[this.key] = { ...row, origin: this.origin, accountId: this.accountId, folder: this.folder, unlinked: true };
+      delete store.folders[this.key].projectId;
+      writeStore(this.file, store);
+    });
+  }
+
+  reserveCreation(name, workspaceId) {
+    this.requireAccount();
+    return this.#update(row => {
+      if (row.projectId) return { projectId: row.projectId };
+      // Both first senders share the already frozen payload, even if their asks differ.
+      row.pendingCreate ??= { key: randomUUID(), name, workspaceId };
+      return structuredClone(row.pendingCreate);
+    });
+  }
+
+  completeCreation(key, projectId) {
+    this.#update(row => {
+      if (row.projectId === projectId && !row.pendingCreate) return;
+      if (row.pendingCreate?.key !== key || typeof projectId !== "string" || !projectId) {
+        throw new CliError("creation_mismatch", "Project creation identity changed");
+      }
+      row.projectId = projectId;
+      delete row.unlinked;
+      delete row.pendingCreate;
+    });
+  }
+
+  state() {
+    const row = this.#read().folders[this.key];
+    if (row && (row.folder.device !== this.folder.device || row.folder.inode !== this.folder.inode)) {
+      throw new CliError("folder_replaced", "Directory identity changed; /unlink acknowledges the new folder. Pending submissions must be resolved from the original folder.");
+    }
+    const drafts = Object.entries(row?.drafts ?? {}).map(([id, value]) => ({ id, ...value }))
+      .sort((a, b) => b.at - a.at);
+    return { draft: this.lastDraft, drafts,
+      pendingCreate: row?.pendingCreate ?? null, pendingRun: row?.pendingRun ?? null };
+  }
+
+  transferDraftTo(destination, text) {
+    destination.requireAccount();
+    if (this.accountId !== UNSIGNED_ACCOUNT || destination.origin !== this.origin
+        || destination.folder.path !== this.folder.path) throw new CliError("draft_scope_invalid", "Draft transfer scope differs");
+    this.saveDraft(text);
+    destination.newDraft(); destination.saveDraft(text);
+    this.saveDraft(""); // Conditional revision consumption preserves a concurrent newer source edit.
+  }
+
+  newDraft() { this.draftRef = null; this.lastDraft = ""; }
+
+  selectDraft(id) {
+    const selected = this.state().drafts.find(row => row.id === id);
+    if (!selected) throw new CliError("draft_unavailable", "This saved draft changed; restart to reload it");
+    this.draftRef = { id, revision: selected.revision }; this.lastDraft = selected.text;
+    return selected.text;
+  }
+
+  saveDraft(text) {
+    if (typeof text !== "string" || Buffer.byteLength(text) > MAX_DRAFT_BYTES) {
+      throw new CliError("draft_too_large", `Draft exceeds ${MAX_DRAFT_BYTES} bytes; attach a file instead`);
+    }
+    if (text === this.lastDraft) return;
+    const next = this.#update(row => {
+      row.drafts ??= {};
+      const matches = this.draftRef && row.drafts[this.draftRef.id]?.revision === this.draftRef.revision;
+      if (!text) {
+        if (matches) delete row.drafts[this.draftRef.id];
+        return null;
+      }
+      if (!matches && Object.keys(row.drafts).length >= 20) throw new CliError("drafts_full",
+        "20 saved drafts already exist. Recover and clear an older draft before saving another.");
+      const id = matches ? this.draftRef.id : randomUUID(), revision = randomUUID();
+      row.drafts[id] = { text, revision, at: Date.now() };
+      return { id, revision };
+    });
+    this.draftRef = next; this.lastDraft = text;
+  }
+
+  reserveRun(projectId, body, draftRef = this.draftRef) {
+    this.requireAccount();
+    return this.#update(row => {
+      if (row.pendingRun) throw new CliError("submission_pending", "Another submission needs reconciliation before a new ask");
+      row.pendingRun = { key: randomUUID(), projectId, body: structuredClone(body), draftRef: structuredClone(draftRef) };
+      return structuredClone(row.pendingRun);
+    });
+  }
+
+  finishRunAdmission(key) {
+    this.#update(row => {
+      if (!row.pendingRun) return; // Another terminal may have persisted the same validated ACK.
+      if (row.pendingRun?.key !== key) throw new CliError("submission_mismatch", "Submission identity changed");
+      const ref = row.pendingRun.draftRef;
+      if (ref && row.drafts?.[ref.id]?.revision === ref.revision) delete row.drafts[ref.id];
+      if (ref && this.draftRef?.id === ref.id && this.draftRef.revision === ref.revision) {
+        this.lastDraft = ""; this.draftRef = null;
+      }
+      delete row.pendingRun;
+    });
+  }
+
+  rejectRunAdmission(key) {
+    this.#update(row => {
+      if (row.pendingRun?.key !== key) throw new CliError("submission_mismatch", "Submission identity changed");
+      delete row.pendingRun;
+    });
+  }
+}

package/src/format.js

@@ -4,6 +4,10 @@ import {
 } from "./contract.js";
 import { CliError } from "./errors.js";
 
+/** Terminal presentation only; exact copy and JSON paths retain the original bytes. */
+export const terminalText = value => String(value ?? "").replace(/[\x00-\x08\x0b\x0c\x0d\x0e-\x1f\x7f-\x9f]/g,
+  char => `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}`).replace(/\t/g, "    ");
+
 export function canonicalJson(value) {
   validateNumbers(value);
   return `${JSON.stringify(sortValue(value))}\n`;
@@ -241,11 +245,11 @@ export function assumptionLines(events) {
   });
 }
 
-function shellQuote(value) {
+export function shellQuote(value) {
   return `'${String(value).replaceAll("'", `'"'"'`)}'`;
 }
 
-function safeArtifactName(artifact) {
+export function safeArtifactName(artifact) {
   const leaf = artifact.filename.replaceAll("\\", "/").split("/").at(-1);
   if (!leaf || leaf === "." || leaf === ".." || leaf.startsWith("-") || leaf.startsWith(".")) {
     return `artifact-${artifact.cas_ref.slice("sha256:".length, "sha256:".length + 12)}`;
@@ -345,7 +349,8 @@ export function currentTransferTables(events) {
   });
 }
 
-export function humanRun(value, { projectId, cost, currentTransferIds } = {}) {
+/** One projection of a Run record; plain text and the rich terminal both render these sections. */
+export function runSections(value, { projectId, currentTransferIds } = {}) {
   const terminal = value.terminal === "" ? null : terminalPresentation(value);
   const origins = value.events.flatMap(event => event.kind === "step_finished"
     ? inputLines(event.payload?.step?.inputs ?? event.payload?.inputs) : []);
@@ -353,42 +358,47 @@ export function humanRun(value, { projectId, cost, currentTransferIds } = {}) {
   if (!artifacts.every(validateArtifact)) {
     throw new CliError("artifact_invalid", "Run carries malformed artifact metadata");
   }
-  const tasks = taskLines(value.events);
-  const assumptions = assumptionLines(value.events);
-  const currentTables = currentTransferTables(value.events).filter(projection =>
-    currentTransferIds?.has(projection.projection_id));
-  const lines = [];
-  if (terminal?.answer !== undefined) lines.push(terminal.answer, "");
-  if (tasks.length) lines.push("Steps:", ...tasks, "");
-  if (origins.length) lines.push("Inputs and origins:", ...origins, "");
-  if (assumptions.length) lines.push("Assumptions:", ...assumptions, "");
-  for (const projection of currentTables) {
+  const project = projectId ? ` --project ${shellQuote(projectId)}` : "";
+  const tables = currentTransferTables(value.events).filter(projection =>
+    currentTransferIds?.has(projection.projection_id)).map(projection => {
     if (typeof projection.search_status !== "string" || projection.origin !== "unattributed"
         || typeof projection.validation_status !== "string" || typeof projection.withheld !== "boolean") {
       throw new CliError("projection_invalid", "Transfer table metadata is malformed");
     }
-    lines.push(`Transfer table: ${plainLine(projection.search_status)} · input origins ${projection.origin}`
+    return [`Transfer table: ${plainLine(projection.search_status)} · input origins ${projection.origin}`
       + ` · validation ${plainLine(projection.validation_status)}`
-      + ` · path ${projection.withheld ? "withheld" : "shown"}`);
-    const project = projectId ? ` --project ${shellQuote(projectId)}` : "";
-    lines.push(`  vecteur projection get ${shellQuote(value.run_id)} ${shellQuote(projection.projection_id)}`
-      + ` --output ${shellQuote("transfer-table.json")}${project}`, "");
+      + ` · path ${projection.withheld ? "withheld" : "shown"}`,
+    `  vecteur projection get ${shellQuote(value.run_id)} ${shellQuote(projection.projection_id)}`
+      + ` --output ${shellQuote("transfer-table.json")}${project}`];
+  });
+  const tail = [`Run: ${plainLine(value.run_id)}`];
+  if (terminal) {
+    tail.push(`Terminal: ${terminal.state}`);
+    if (terminal.defect !== undefined) tail.push(`Cause: ${terminal.defect}`);
+    tail.push(...terminal.recovery.map(recoveryLine));
   }
-  if (artifacts.length) {
+  return { answer: terminal?.answer, state: terminal?.state ?? "", tasks: taskLines(value.events), origins,
+    assumptions: assumptionLines(value.events), tables, artifacts: artifacts.map(artifact => ({ artifact,
+      command: `vecteur artifact get ${shellQuote(artifact.cas_ref)} --output ${shellQuote(safeArtifactName(artifact))}${project}` })),
+    tail };
+}
+
+export function humanRun(value, { projectId, cost, currentTransferIds } = {}) {
+  const run = runSections(value, { projectId, currentTransferIds });
+  const lines = [];
+  if (run.answer !== undefined) lines.push(run.answer, "");
+  if (run.tasks.length) lines.push("Steps:", ...run.tasks, "");
+  if (run.origins.length) lines.push("Inputs and origins:", ...run.origins, "");
+  if (run.assumptions.length) lines.push("Assumptions:", ...run.assumptions, "");
+  for (const table of run.tables) lines.push(...table, "");
+  if (run.artifacts.length) {
     lines.push("Artifacts:");
-    for (const artifact of artifacts) {
-      lines.push(`  ${artifact.filename} (${artifact.kind}, ${artifact.id})`);
-      const project = projectId ? ` --project ${shellQuote(projectId)}` : "";
-      lines.push(`    vecteur artifact get ${shellQuote(artifact.cas_ref)} --output ${shellQuote(safeArtifactName(artifact))}${project}`);
+    for (const { artifact, command } of run.artifacts) {
+      lines.push(`  ${artifact.filename} (${artifact.kind}, ${artifact.id})`, `    ${command}`);
     }
     lines.push("");
   }
-  lines.push(`Run: ${plainLine(value.run_id)}`);
-  if (terminal) {
-    lines.push(`Terminal: ${terminal.state}`);
-    if (terminal.defect !== undefined) lines.push(`Cause: ${terminal.defect}`);
-    lines.push(...terminal.recovery.map(recoveryLine));
-  }
+  lines.push(...run.tail);
   if (cost) lines.push("", humanCost(cost).trimEnd());
   return `${lines.join("\n")}\n`;
 }

package/src/input.js

@@ -0,0 +1,148 @@
+import { EventEmitter } from "node:events";
+import { StringDecoder } from "node:string_decoder";
+
+const START = "\x1b[200~", END = "\x1b[201~";
+const MAX_BYTES = 256 * 1024;
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/** Stream decoder shared by both terminal views; paste is always one edit, never a send. */
+export class ComposerInput extends EventEmitter {
+  constructor() {
+    super(); this.text = ""; this.cursor = 0; this.pending = ""; this.pasting = false;
+    this.decoder = new StringDecoder("utf8"); this.pasted = "";
+    this.undo = []; this.killed = ""; this.focusEpoch = 0;
+  }
+  set(text) { this.text = text; this.cursor = text.length; this.emit("change", this.text); }
+  checkpoint() {
+    if (this.undo.at(-1)?.text === this.text) return;
+    this.undo.push({ text: this.text, cursor: this.cursor });
+    if (this.undo.length > 12) this.undo.shift();
+  }
+  restore() {
+    const previous = this.undo.pop();
+    if (previous) { Object.assign(this, previous); this.emit("change", this.text); }
+  }
+  lineStart() { return this.cursor === 0 ? 0 : this.text.lastIndexOf("\n", this.cursor - 1) + 1; }
+  lineEnd() { const end = this.text.indexOf("\n", this.cursor); return end < 0 ? this.text.length : end; }
+  replace(from, to, value = "", cut = false) {
+    this.checkpoint(); if (cut) this.killed = this.text.slice(from, to);
+    this.text = this.text.slice(0, from) + value + this.text.slice(to); this.cursor = from + value.length;
+    this.emit("change", this.text);
+  }
+  word(direction) {
+    if (direction < 0) return this.text.slice(0, this.cursor).search(/[^\s]*\s*$/u);
+    return this.cursor + (/^\s*\S*/u.exec(this.text.slice(this.cursor))?.[0].length ?? 0);
+  }
+  vertical(direction) {
+    const start = this.lineStart(), end = this.lineEnd(), column = this.cursor - start;
+    if (direction < 0 && start > 0) {
+      const previous = this.text.lastIndexOf("\n", start - 2) + 1;
+      this.cursor = Math.min(start - 1, previous + column);
+    } else if (direction > 0 && end < this.text.length) {
+      const nextEnd = this.text.indexOf("\n", end + 1);
+      this.cursor = Math.min(nextEnd < 0 ? this.text.length : nextEnd, end + 1 + column);
+    } else { this.emit("history", direction); return; }
+    // Clamp vertical movement to a grapheme boundary, never inside a surrogate/emoji.
+    const boundary = [...[...graphemes.segment(this.text)].map(row => row.index), this.text.length].findLast(index => index <= this.cursor);
+    this.cursor = boundary ?? 0;
+  }
+  boundary(direction) {
+    if (this.segmentedText !== this.text) {
+      this.segmentedText = this.text;
+      this.boundaries = [...graphemes.segment(this.text)].map(item => item.index);
+      this.boundaries.push(this.text.length);
+    }
+    if (direction < 0) return this.boundaries.findLast(index => index < this.cursor) ?? 0;
+    return this.boundaries.find(index => index > this.cursor) ?? this.text.length;
+  }
+  insert(text) {
+    const value = this.text.slice(0, this.cursor) + text + this.text.slice(this.cursor);
+    if (Buffer.byteLength(value) > MAX_BYTES) { this.emit("notice", "Draft is too large; attach a file instead."); return; }
+    this.checkpoint();
+    this.text = value; this.cursor += text.length; this.emit("change", this.text);
+  }
+  feed(bytes) {
+    clearTimeout(this.escapeTimer);
+    const epoch = this.focusEpoch;
+    this.pending += typeof bytes === "string" ? bytes : this.decoder.write(bytes);
+    while (this.pending) {
+      if (this.pasting) {
+        const end = this.pending.indexOf(END);
+        if (end < 0) {
+          const take = Math.max(0, this.pending.length - END.length + 1);
+          this.pasted += this.pending.slice(0, take); this.pending = this.pending.slice(take);
+          if (Buffer.byteLength(this.pasted) > MAX_BYTES) { this.pasted = ""; this.pasteOverflow = true; }
+          return;
+        }
+        this.pasted += this.pending.slice(0, end); this.pending = this.pending.slice(end + END.length);
+        if (!this.pasteOverflow) this.insert(this.pasted.replace(/\r\n?/g, "\n"));
+        else this.emit("notice", "Paste exceeds the draft limit; attach the file instead.");
+        this.pasted = ""; this.pasting = false; this.pasteOverflow = false; continue;
+      }
+      if (this.pending.startsWith(START)) { this.pasting = true; this.pending = this.pending.slice(START.length); continue; }
+      if (this.pending.startsWith("\x1b")) {
+        if (this.pending.startsWith("\x1b\x1b")) {
+          // Escape followed by an arrow/Alt-Enter keeps that encoded key intact.
+          const encodedTail = /^\x1b\x1b(?:\[|\r|\n)/.test(this.pending);
+          this.pending = this.pending.slice(encodedTail ? 1 : 2);
+          if (epoch === this.focusEpoch) {
+            this.emit("cancel"); if (!encodedTail && epoch === this.focusEpoch) this.emit("cancel");
+          }
+          continue;
+        }
+        if (this.pending.startsWith("\x1b\r") || this.pending.startsWith("\x1b\n")) {
+          this.pending = this.pending.slice(2); this.insert("\n"); continue;
+        }
+        if (/^\x1b[bf]/.test(this.pending)) {
+          const direction = this.pending[1] === "b" ? -1 : 1;
+          this.pending = this.pending.slice(2); this.cursor = this.word(direction); this.emit("change", this.text); continue;
+        }
+        const escape = /^\x1b\[[0-?]*[ -/]*[@-~]/.exec(this.pending)?.[0];
+        if (escape) {
+          this.pending = this.pending.slice(escape.length);
+          if (this.handleKey?.(escape)) continue;
+          if (escape === "\x1b[D") this.cursor = this.boundary(-1);
+          else if (escape === "\x1b[C") this.cursor = this.boundary(1);
+          else if (["\x1b[H", "\x1b[1~"].includes(escape)) this.cursor = this.lineStart();
+          else if (["\x1b[F", "\x1b[4~"].includes(escape)) this.cursor = this.lineEnd();
+          else if (escape === "\x1b[3~") this.replace(this.cursor, this.boundary(1));
+          else if (escape === "\x1b[A") this.vertical(-1);
+          else if (escape === "\x1b[B") this.vertical(1);
+          else if (escape === "\x1b[13;2u" || escape === "\x1b[27;2;13~") this.insert("\n");
+          this.emit("change", this.text); continue;
+        }
+        this.escapeTimer = setTimeout(() => {
+          if (this.pending === "\x1b") { this.pending = ""; if (epoch === this.focusEpoch) this.emit("cancel"); }
+          else { this.pending = ""; this.emit("notice", "Unsupported terminal key sequence"); }
+        }, 40);
+        return;
+      }
+      const char = String.fromCodePoint(this.pending.codePointAt(0)); this.pending = this.pending.slice(char.length);
+      if (epoch !== this.focusEpoch && /[\r\x03\x04]/.test(char)) continue;
+      if (this.handleKey?.(char)) continue;
+      if (char === "\r") {
+        if (this.text[this.cursor - 1] === "\\") this.replace(this.cursor - 1, this.cursor, "\n");
+        else this.emit("submit", this.text);
+      }
+      else if (char === "\n") this.insert("\n");
+      else if (char === "\x03") this.emit("interrupt");
+      else if (char === "\x04") { if (!this.text) this.emit("exit"); else this.replace(this.cursor, this.boundary(1)); }
+      else if (char === "\x0f") this.emit("details");
+      else if (char === "\x15") this.replace(this.lineStart(), this.cursor, "", true);
+      else if (char === "\x0b") this.replace(this.cursor, this.lineEnd(), "", true);
+      else if (char === "\x17") this.replace(this.word(-1), this.cursor, "", true);
+      else if (char === "\x19") this.insert(this.killed);
+      else if (char === "\x1f") this.restore();
+      else if (char === "\x12") this.emit("search");
+      else if (char === "\x0c") this.emit("redraw");
+      else if (char === "\x01") { this.cursor = this.lineStart(); this.emit("change", this.text); }
+      else if (char === "\x05") { this.cursor = this.lineEnd(); this.emit("change", this.text); }
+      else if (char === "\x7f" || char === "\b") {
+        const next = this.boundary(-1);
+        this.replace(next, this.cursor);
+      } else if (char === "\t") { if (this.listenerCount("complete")) this.emit("complete"); else this.insert("  "); }
+      else if (char >= " " && char !== "\x7f") this.insert(char);
+    }
+  }
+  close() { clearTimeout(this.escapeTimer); }
+}