jsmdcui 0.7.0 → 0.8.0

package/src/index.js

@@ -93,12 +93,13 @@ function printProfileReport() {
 }
 
 import child_process from "node:child_process"
-import { accessSync, constants, existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { accessSync, closeSync, constants, existsSync, openSync, readSync, readdirSync, statSync, unlinkSync } from "node:fs";
 import { mkdir } from "node:fs/promises";
 import { dirname, basename, join, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import process from "node:process";
 import { toggleTaskCheckboxBeforeColumn, updateAnsiTaskCheckbox } from "./cui/task-checkbox.mjs";
+import { fenceEventMap, inlineFenceEventCode } from "./cui/fence-events.mjs";
 import { checkMarkdownIdCollisions, formatMarkdownIdCheckAnsi } from "./cui/id-collision.mjs";
 import { fitKittyImageToWidth, prepareKittyImages } from "./cui/kitty-images.mjs";
 import { logKittyPlacement } from "./cui/kitty-debug.mjs";
@@ -108,7 +109,7 @@ import { cleanConfig } from "./config/clean.js";
 import { RuntimeRegistry, RTColorscheme, RTHelp } from "./runtime/registry.js";
 import { assetPath, hasInternalAssets, listInternalAssetDirs, listInternalAssetPaths, readInternalAssetText } from "./runtime/assets.js";
 //import { PluginManager } from "./plugins/manager.js";
-import { JsPluginManager, buildMicroGlobal, runAction, listActions } from "./plugins/js-bridge.js";
+import { JsPluginManager, buildMicroGlobal, buildTuiBlockIndex, findTuiBlockInIndex, insertTuiTextareaNewline, mergeTuiTextareaBackward, mergeTuiTextareaForward, runAction, listActions } from "./plugins/js-bridge.js";
 import { Colorscheme } from "./config/colorscheme.js";
 import { detectSyntax, loadSyntaxDefinitions } from "./highlight/parser.js";
 import { Highlighter } from "./highlight/highlighter.js";
@@ -117,6 +118,7 @@ import { Screen } from "./screen/screen.js";
 import { VT100 } from "./screen/vt100.js";
 import { ClipboardManager, probeOSC52, osc52Clipboard } from "./platform/clipboard.js";
 import { platformId, run as runCommand, runSync, fetchHttpBytes, detectHttpBackend } from "./platform/commands.js";
+import { controllingTerminalInputPath } from "./platform/terminal.js";
 import { shellSplit } from "./shell/shell.js";
 import { styleToAnsi } from "./display/ansi-style.js";
 import { encodeBinaryToBuffer, decodeBinaryBytes } from "./buffer/fixed3-codec.js";
@@ -368,6 +370,7 @@ async function renderMdcui(markdown, width = process.stdout.columns || 80, mdpat
     ? { rendered: tui, images: [] }
     : await prepareKittyImages(tui, resolvedImageBasePath, width, {
       allowUrl: allowRemoteKittyImages,
+      kittyMode: kittyImageMode,
     });
   return {
     rendered: prepared.rendered,
@@ -668,6 +671,21 @@ function canEditMdcuiSelection(buf, selection) {
   return first.y === last.y && prefixLength > 0 && first.x >= prefixLength;
 }
 
+function mdcuiTextareaAtCursor(buf) {
+  if (!isMdcuiEncoding(buf?.encoding)) return null;
+  let cache = buf._mdcuiControlBlockIndex;
+  if (!cache || cache.lines !== buf.lines || cache.lineCount !== buf.lines.length) {
+    cache = {
+      lines: buf.lines,
+      lineCount: buf.lines.length,
+      blocks: buildTuiBlockIndex(buf.lines),
+    };
+    buf._mdcuiControlBlockIndex = cache;
+  }
+  const block = findTuiBlockInIndex(cache.blocks, buf.cursor.y);
+  return block?.header?.tag === "textarea" ? block : null;
+}
+
 function isEditLockedBuffer(buf) {
   return isMdcuiEncoding(buf?.encoding ?? buf?.Settings?.encoding);
 }
@@ -970,6 +988,100 @@ function takeDisplay(text, maxWidth) {
   return out;
 }
 
+function keyboardEventJson(event) {
+  const target = event?.target;
+  return {
+    type: String(event?.type ?? ""),
+    key: String(event?.key ?? ""),
+    code: String(event?.code ?? ""),
+    raw: String(event?.raw ?? ""),
+    ctrlKey: Boolean(event?.ctrlKey),
+    shiftKey: Boolean(event?.shiftKey),
+    altKey: Boolean(event?.altKey),
+    metaKey: Boolean(event?.metaKey),
+    repeat: Boolean(event?.repeat),
+    defaultPrevented: Boolean(event?.defaultPrevented),
+    target: {
+      id: String(target?.id ?? ""),
+      tagName: String(target?.tagName ?? ""),
+      className: String(target?.className ?? ""),
+      value: String(target?.value ?? ""),
+    },
+  };
+}
+
+function tuiKeyEventForFront(event, target, type) {
+  const sequence = String(event?.key ?? "");
+  const parts = sequence.split("-");
+  const aliases = {
+    enter: "Enter",
+    escape: "Escape",
+    tab: "Tab",
+    backtab: "Tab",
+    backspace: "Backspace",
+    delete: "Delete",
+    left: "ArrowLeft",
+    right: "ArrowRight",
+    up: "ArrowUp",
+    down: "ArrowDown",
+    home: "Home",
+    end: "End",
+    pageup: "PageUp",
+    pagedown: "PageDown",
+    space: " ",
+  };
+  let base = parts.at(-1) || sequence;
+  if (sequence === "backtab") base = "tab";
+  const raw = String(event?.raw ?? "");
+  const key = aliases[base] ?? (sequence === raw && [...raw].length === 1 ? raw : base);
+  let defaultPrevented = false;
+  let propagationStopped = false;
+  const result = {
+    type,
+    key,
+    raw,
+    ctrlKey: parts.includes("ctrl"),
+    altKey: parts.includes("alt"),
+    shiftKey: sequence === "backtab" || parts.includes("shift"),
+    metaKey: parts.includes("meta"),
+    repeat: false,
+    target,
+    currentTarget: target,
+    get defaultPrevented() { return defaultPrevented; },
+    get propagationStopped() { return propagationStopped; },
+    preventDefault() { defaultPrevented = true; },
+    stopPropagation() { propagationStopped = true; },
+  };
+  Object.defineProperty(result, "toJSON", {
+    configurable: true,
+    value() { return keyboardEventJson(this); },
+  });
+  return result;
+}
+
+function indexedMdcuiFenceBlockAtLine(buffer, lineIndex) {
+  const declarations = buffer?._mdcuiFenceEvents;
+  if (!isMdcuiEncoding(buffer?.encoding) || declarations?.size === 0) return null;
+  let cache = buffer._mdcuiFenceBlockIndex;
+  // Render/reopen replaces the lines array; structural selector edits explicitly
+  // clear this cache. Ordinary character edits leave block boundaries unchanged.
+  if (
+    !cache
+    || cache.lines !== buffer.lines
+    || cache.lineCount !== buffer.lines.length
+    || cache.declarations !== declarations
+  ) {
+    cache = {
+      lines: buffer.lines,
+      lineCount: buffer.lines.length,
+      declarations,
+      blocks: buildTuiBlockIndex(buffer.lines, declarations),
+    };
+    buffer._mdcuiFenceBlockIndex = cache;
+  }
+  return findTuiBlockInIndex(cache.blocks, lineIndex);
+}
+
 function parseArgs(argv) {
   const flags = {
     version: false,
@@ -1207,6 +1319,7 @@ class BufferModel {
     this._mdcuiAnsiText = isMdcuiEncoding(this.encoding) ? String(ansiText ?? "") : null;
     this._mdcuiSourceText = isMdcuiEncoding(this.encoding) ? String(sourceText ?? text) : null;
     this._mdcuiTuiSourceText = isMdcuiEncoding(this.encoding) ? String(tuiSourceText ?? sourceText ?? text) : null;
+    this._mdcuiFenceEvents = isMdcuiEncoding(this.encoding) ? fenceEventMap(sourceText ?? tuiSourceText ?? text) : new Map();
     this._mdcuiImages = isMdcuiEncoding(this.encoding) ? (mdcuiImages ?? []) : [];
     this._mdcuiRenderWidth = Math.trunc(Number(mdcuiRenderWidth) || 0);
     this.cursor = { x: 0, y: 0 };
@@ -1565,9 +1678,39 @@ class BufferModel {
     this.cursor.x = x;
   }
 
+  _historyState() {
+    return {
+      lines: this.lines.slice(),
+      cursor: { ...this.cursor },
+      serial: this._undoSerial,
+      ansiStyleLines: Array.isArray(this._ansiStyleLines)
+        ? this._ansiStyleLines.map((line) => Array.isArray(line) ? line.slice() : line)
+        : this._ansiStyleLines,
+      mdcuiAnsiText: this._mdcuiAnsiText,
+      mdcuiImages: Array.isArray(this._mdcuiImages)
+        ? this._mdcuiImages.map((image) => ({ ...image }))
+        : this._mdcuiImages,
+      headingTaskListAnchors: this._mdcuiHeadingTaskListAnchors instanceof Map
+        ? new Map([...this._mdcuiHeadingTaskListAnchors].map(([key, value]) => [key, { ...value }]))
+        : this._mdcuiHeadingTaskListAnchors,
+    };
+  }
+
+  _restoreHistoryState(state) {
+    this.lines = state.lines;
+    this.cursor = { ...state.cursor };
+    this._undoSerial = state.serial ?? 0;
+    this._ansiStyleLines = state.ansiStyleLines;
+    this._mdcuiAnsiText = state.mdcuiAnsiText;
+    this._mdcuiImages = state.mdcuiImages;
+    this._mdcuiHeadingTaskListAnchors = state.headingTaskListAnchors;
+    this._mdcuiFenceBlockIndex = null;
+    this._mdcuiControlBlockIndex = null;
+  }
+
   pushUndo(force = false) {
     if (!force && this.isEditLocked() && !canEditMdcuiAtCursor(this)) return;
-    this.undoStack.push({ lines: this.lines.slice(), cursor: { ...this.cursor }, serial: this._undoSerial });
+    this.undoStack.push(this._historyState());
     this._undoSerial = (this._undoSerial ?? 0) + 1;
     if (this.undoStack.length > 500) this.undoStack.shift();
     this.redoStack = [];
@@ -1576,12 +1719,10 @@ class BufferModel {
   undo() {
     if (this.isEditLocked() && !isMdcuiEncoding(this.encoding)) return false;
     if (!this.undoStack.length) return false;
-    this.redoStack.push({ lines: this.lines.slice(), cursor: { ...this.cursor }, serial: this._undoSerial });
+    this.redoStack.push(this._historyState());
     const s = this.undoStack.pop();
-    this.lines = s.lines;
+    this._restoreHistoryState(s);
     this.invalidateHighlightFrom(0, { force: true });
-    this.cursor = { ...s.cursor };
-    this._undoSerial = s.serial ?? 0;
     this.modified = this._undoSerial !== this._savedSerial;
     return true;
   }
@@ -1589,12 +1730,10 @@ class BufferModel {
   redo() {
     if (this.isEditLocked() && !isMdcuiEncoding(this.encoding)) return false;
     if (!this.redoStack.length) return false;
-    this.undoStack.push({ lines: this.lines.slice(), cursor: { ...this.cursor }, serial: this._undoSerial });
+    this.undoStack.push(this._historyState());
     const s = this.redoStack.pop();
-    this.lines = s.lines;
+    this._restoreHistoryState(s);
     this.invalidateHighlightFrom(0, { force: true });
-    this.cursor = { ...s.cursor };
-    this._undoSerial = s.serial ?? 0;
     this.modified = this._undoSerial !== this._savedSerial;
     return true;
   }
@@ -1725,6 +1864,7 @@ class BufferModel {
       this._mdcuiAnsiText = isMdcuiEncoding(this.encoding) ? String(decoded.ansiText ?? "") : null;
       this._mdcuiSourceText = isMdcuiEncoding(this.encoding) ? String(decoded.sourceText ?? text) : null;
       this._mdcuiTuiSourceText = isMdcuiEncoding(this.encoding) ? String(decoded.tuiSourceText ?? decoded.sourceText ?? text) : null;
+      this._mdcuiFenceEvents = isMdcuiEncoding(this.encoding) ? fenceEventMap(decoded.sourceText ?? decoded.tuiSourceText ?? text) : new Map();
       this._mdcuiRenderWidth = decoded.mdcuiRenderWidth ?? 0;
       this._mdcuiImages = decoded.mdcuiImages ?? [];
       const readonly = isMdcuiEncoding(this.encoding);
@@ -1758,6 +1898,7 @@ class BufferModel {
     this._mdcuiAnsiText = isMdcuiEncoding(this.encoding) ? String(decoded.ansiText ?? "") : null;
     this._mdcuiSourceText = isMdcuiEncoding(this.encoding) ? String(decoded.sourceText ?? text) : null;
     this._mdcuiTuiSourceText = isMdcuiEncoding(this.encoding) ? String(decoded.tuiSourceText ?? decoded.sourceText ?? text) : null;
+    this._mdcuiFenceEvents = isMdcuiEncoding(this.encoding) ? fenceEventMap(decoded.sourceText ?? decoded.tuiSourceText ?? text) : new Map();
     this._mdcuiRenderWidth = decoded.mdcuiRenderWidth ?? 0;
     this._mdcuiImages = decoded.mdcuiImages ?? [];
     this.fileformat = detectFileFormat(text, this.Settings.fileformat ?? DEFAULT_SETTINGS.fileformat);
@@ -2503,16 +2644,14 @@ class App {
   }
 
   async start() {
-    this._started = true;
+    this.installProtectedPrompts();
     // When stdin was a pipe (content already consumed in loadBuffers), open the
     // controlling terminal directly so the event loop has a live handle and
-    // keyboard input works.  Unix: /dev/tty  Windows: \\.\CON
+    // keyboard input works. Unix: /dev/tty; Windows: CONIN$.
     if (!process.stdin.isTTY) {
       try {
-        const { openSync } = await import("node:fs");
         const { ReadStream } = await import("node:tty");
-        const ttyPath = process.platform === "win32" ? "\\\\.\\CON" : "/dev/tty";
-        const fd = openSync(ttyPath, "r+");
+        const fd = openSync(controllingTerminalInputPath(), "r");
         this._ttyStream = new ReadStream(fd);
       } catch {
         this._ttyStream = process.stdin;
@@ -2542,6 +2681,7 @@ class App {
     });
     process.on("SIGINT", () => {}); // Ctrl+C is handled as copy in handleEvent
     this.screen.init();
+    this._started = true;
     // Update backup prompt to screen-aware version now that TUI is running.
     if (this.context._termPrompt) {
       this.context._termPrompt = async (msg) => {
@@ -2626,6 +2766,8 @@ class App {
         if (p.type === "term") p.terminal?.close();
     (this._ttyStream ?? process.stdin).setRawMode?.(false);
     this.screen.fini();
+    this._started = false;
+    this.restoreProtectedPrompts();
 
     if (this.context?.config?.getGlobalOption("savehistory") !== false) {
       try { await saveHistory(this.context.config.configDir); } catch {}
@@ -2644,6 +2786,157 @@ class App {
     process.exit(code);
   }
 
+  installProtectedPrompts() {
+    if (this._protectedPrompts) return;
+    const saved = {
+      alert: {
+        had: Object.prototype.hasOwnProperty.call(globalThis, "alert"),
+        value: globalThis.alert,
+      },
+      confirm: {
+        had: Object.prototype.hasOwnProperty.call(globalThis, "confirm"),
+        value: globalThis.confirm,
+      },
+      prompt: {
+        had: Object.prototype.hasOwnProperty.call(globalThis, "prompt"),
+        value: globalThis.prompt,
+      },
+    };
+    this._protectedPrompts = saved;
+    this._protectedPromptGlobals = {
+      alert: this.protectedAlert.bind(this),
+      confirm: this.protectedConfirm.bind(this),
+      prompt: this.protectedPrompt.bind(this),
+    };
+    Object.assign(globalThis, this._protectedPromptGlobals);
+  }
+
+  runProtectedPrompt(name, fallback, args) {
+    const nativeFn = this._protectedPrompts?.[name]?.value;
+    const tty = this._ttyStream ?? process.stdin;
+    const wasRaw = typeof tty?.isRaw === "boolean" ? tty.isRaw : true;
+    if (
+      !this._started
+      || this.shellRunning
+      || this._alertRunning
+      || !wasRaw
+      || typeof nativeFn !== "function"
+    ) {
+      this.message = String(args[0] ?? "");
+      return fallback;
+    }
+
+    const inputHandler = this._inputHandler;
+    const listenerAttached = Boolean(
+      inputHandler && tty.listeners?.("data").includes(inputHandler),
+    );
+    const wasPaused = tty.isPaused?.() ?? false;
+    let value;
+    let failed = false;
+    let failure;
+    const cleanupFailures = [];
+    const cleanup = (fn) => {
+      try { fn(); } catch (error) { cleanupFailures.push(error); }
+    };
+
+    try {
+      this._alertRunning = true;
+      // Do not let the editor's flowing-mode data listener race the blocking
+      // prompt for bytes from the same terminal.
+      if (listenerAttached) tty.removeListener("data", inputHandler);
+      tty.pause?.();
+      tty.setRawMode?.(false);
+      this.screen.fini();
+      this.screen.previous = null;
+      // Bun's native prompts always read fd 0. If Markdown itself came from a
+      // pipe, read synchronously from the controlling terminal instead.
+      value = tty !== process.stdin
+        ? this.runProtectedTtyPrompt(name, fallback, args)
+        : Reflect.apply(nativeFn, globalThis, args);
+    } catch (error) {
+      failed = true;
+      failure = error;
+    } finally {
+      cleanup(() => tty.setRawMode?.(wasRaw));
+      cleanup(() => { this.screen.previous = null; });
+      cleanup(() => this.screen.init());
+      cleanup(() => { this._alertRunning = false; });
+      cleanup(() => {
+        if (listenerAttached) tty.on("data", inputHandler);
+      });
+      cleanup(() => {
+        if (!wasPaused) tty.resume?.();
+      });
+      cleanup(() => this.render());
+    }
+    if (failed) throw failure;
+    if (cleanupFailures.length > 0) throw cleanupFailures[0];
+    return value;
+  }
+
+  runProtectedTtyPrompt(name, fallback, args) {
+    const message = String(args[0] ?? "");
+    const defaultValue = String(args[1] ?? "");
+    const fd = openSync(controllingTerminalInputPath(), "r");
+    try {
+      if (name === "alert") {
+        process.stdout.write(`${message}\n\nPress ENTER to continue...`);
+        this.readProtectedPromptLine(fd);
+        return undefined;
+      }
+      const suffix = name === "confirm"
+        ? " [y/N] "
+        : defaultValue ? ` (${defaultValue}) ` : " ";
+      process.stdout.write(message + suffix);
+      const answer = this.readProtectedPromptLine(fd);
+      if (answer == null) return fallback;
+      if (name === "confirm") return /^(?:y|yes)$/i.test(answer.trim());
+      return answer === "" ? defaultValue : answer;
+    } finally {
+      closeSync(fd);
+    }
+  }
+
+  readProtectedPromptLine(fd) {
+    const chunks = [];
+    const chunk = Buffer.allocUnsafe(1024);
+    while (true) {
+      const length = readSync(fd, chunk, 0, chunk.length, null);
+      if (length === 0) return chunks.length > 0 ? Buffer.concat(chunks).toString() : null;
+      const bytes = chunk.subarray(0, length);
+      const newline = bytes.findIndex((byte) => byte === 0x0a || byte === 0x0d);
+      chunks.push(Buffer.from(newline < 0 ? bytes : bytes.subarray(0, newline)));
+      if (newline >= 0) return Buffer.concat(chunks).toString();
+    }
+  }
+
+  protectedAlert(msg = "") {
+    return this.runProtectedPrompt("alert", undefined, [String(msg)]);
+  }
+
+  protectedConfirm(msg = "") {
+    return this.runProtectedPrompt("confirm", false, [String(msg)]);
+  }
+
+  protectedPrompt(msg = "", defaultValue = "") {
+    return this.runProtectedPrompt(
+      "prompt",
+      defaultValue,
+      [String(msg), String(defaultValue)],
+    );
+  }
+
+  restoreProtectedPrompts() {
+    const saved = this._protectedPrompts;
+    if (!saved) return;
+    for (const name of ["alert", "confirm", "prompt"]) {
+      if (saved[name].had) globalThis[name] = saved[name].value;
+      else delete globalThis[name];
+    }
+    this._protectedPrompts = null;
+    this._protectedPromptGlobals = null;
+  }
+
   layoutEditorArea() {
     const promptHeight = this.prompt ? 1 : 0;
     const tabBarHeight = this.tabs.length > 1 ? 1 : 0;
@@ -3754,6 +4047,7 @@ class App {
 
     const text = event.raw;
     const seq = event.key;
+    const keydownBlock = indexedMdcuiFenceBlockAtLine(buf, buf?.cursor.y);
     if (buf) buf.allowCursorOffscreen = false;
 
     if (this._rawMode) {
@@ -3764,6 +4058,12 @@ class App {
       return;
     }
 
+    const keydownEvent = await this.dispatchMdcuiFenceEvent(buf, keydownBlock, event, "keydown");
+    if (keydownEvent?.defaultPrevented && !["ctrl-q", "alt-q", "escape"].includes(seq)) {
+      this.render();
+      return;
+    }
+
     // Reset undo insert chain on any non-printable-char key
     if (!(seq === text && text.length === 1 && text >= " ")) this._undoInsertChain = false;
 
@@ -3952,15 +4252,28 @@ class App {
       case "backspace":
         buf.pushUndo();
         if (this.pane?.selection) deleteSelection(buf, this.pane);
-        else if (await this.runPluginBool("preBackspace")) buf.backspace();
+        else if (await this.runPluginBool("preBackspace")) {
+          const textarea = mdcuiTextareaAtCursor(buf);
+          if (!mergeTuiTextareaBackward(buf, textarea)) buf.backspace();
+        }
         break;
       case "delete":
         buf.pushUndo();
         if (this.pane?.selection) deleteSelection(buf, this.pane);
-        else buf.deleteForward();
+        else {
+          const textarea = mdcuiTextareaAtCursor(buf);
+          if (!mergeTuiTextareaForward(buf, textarea)) buf.deleteForward();
+        }
         break;
       case "enter":
         if (isMdcuiEncoding(buf?.encoding)) {
+          const textarea = mdcuiTextareaAtCursor(buf);
+          if (textarea && canEditMdcuiAtCursor(buf)) {
+            buf.pushUndo();
+            if (this.pane?.selection) deleteSelection(buf, this.pane);
+            insertTuiTextareaNewline(buf, textarea);
+            break;
+          }
           await this.handleMdcuiCellCallback(buf, buf.cursor.y, buf.cursor.x, "enter");
           break;
         }
@@ -4136,6 +4449,48 @@ class App {
     this.render();
   }
 
+  async dispatchMdcuiFenceEvent(buf, block, inputEvent, eventName) {
+    const id = block?.header?.id;
+    const declaration = id ? buf?._mdcuiFenceEvents?.get(id) : null;
+    const handler = declaration?.events?.get(eventName);
+    const code = inlineFenceEventCode(handler);
+    if (
+      !code
+      || declaration.tag !== block?.header?.tag
+      || !buf?.path
+      || isHttpUrl(buf.path)
+    ) return false;
+
+    const frontPath = `${buf.path}.front.js`;
+    if (!existsSync(frontPath)) return false;
+    try {
+      const selection = globalThis.$?.(`${declaration.tag}#${id}`);
+      const target = {
+        id,
+        tagName: declaration.tag.toUpperCase(),
+        className: declaration.classes.join(" "),
+      };
+      Object.defineProperty(target, "value", {
+        enumerable: true,
+        get: () => selection?.val?.() ?? "",
+        set: (value) => selection?.val?.(value),
+      });
+      const event = tuiKeyEventForFront(inputEvent, target, eventName);
+      const [{ evalFront }, frontMod] = await Promise.all([
+        import("./cui/rpc.mjs"),
+        import(localModuleUrl(frontPath)),
+      ]);
+      const result = await evalFront(frontMod, code, { event });
+      if (result && typeof result === "object" && result.ok === false) {
+        this.message = `mdcui ${eventName}: ${String(result.error ?? "Unknown error")}`;
+      }
+      return event;
+    } catch (error) {
+      this.message = `mdcui ${eventName}: ${String(error?.message || error)}`;
+      return null;
+    }
+  }
+
   async handleMdcuiCellCallback(buf, y = buf?.cursor?.y ?? 0, x = buf?.cursor?.x ?? 0, trigger = "unknown") {
     const payload = mdcuiCellPayload(buf, y, x, trigger);
     if (!payload) return false;
@@ -4162,50 +4517,11 @@ class App {
             import("./cui/rpc.mjs"),
             import(localModuleUrl(`${buf.path}.front.js`)),
           ]);
-          const hadAlert = Object.prototype.hasOwnProperty.call(globalThis, "alert");
-          const prevAlert = globalThis.alert;
-          const hadConfirm = Object.prototype.hasOwnProperty.call(globalThis, "confirm");
-          const prevConfirm = globalThis.confirm;
-          const hadPrompt = Object.prototype.hasOwnProperty.call(globalThis, "prompt");
-          const prevPrompt = globalThis.prompt;
-          const nativeAlert = typeof prevAlert === "function" ? prevAlert : null;
-          const withNativePrompt = (nativeFn, fallback, args) => {
-            if (!this._started || typeof nativeFn !== "function") {
-              this.message = String(args[0] ?? "");
-              return fallback;
-            }
-            const tty = this._ttyStream ?? process.stdin;
-            this._alertRunning = true;
-            tty.setRawMode?.(false);
-            this.screen.fini();
-            this.screen.previous = null;
-            try {
-              return nativeFn(...args);
-            } finally {
-              tty.setRawMode?.(true);
-              this.screen.previous = null;
-              this.screen.init();
-              this._alertRunning = false;
-              this.render();
-            }
-          };
-          globalThis.alert = (msg = "") => withNativePrompt(nativeAlert, undefined, [String(msg)]);
-          globalThis.confirm = (msg = "") => withNativePrompt(prevConfirm, false, [String(msg)]);
-          globalThis.prompt = (msg = "", defaultValue = "") => withNativePrompt(prevPrompt, defaultValue, [String(msg), String(defaultValue)]);
-          try {
-            const result = await evalFront(frontMod, payload.link);
-            if (result && typeof result === "object" && result.ok === false) {
-              globalThis.alert(String(result.error ?? "Unknown error"));
-            } else if (result != null) {
-              this.message = String(result);
-            }
-          } finally {
-            if (hadAlert) globalThis.alert = prevAlert;
-            else delete globalThis.alert;
-            if (hadConfirm) globalThis.confirm = prevConfirm;
-            else delete globalThis.confirm;
-            if (hadPrompt) globalThis.prompt = prevPrompt;
-            else delete globalThis.prompt;
+          const result = await evalFront(frontMod, payload.link);
+          if (result && typeof result === "object" && result.ok === false) {
+            this.protectedAlert(String(result.error ?? "Unknown error"));
+          } else if (result != null) {
+            this.message = String(result);
           }
           return true;
         } catch (error) {
@@ -8033,6 +8349,7 @@ async function main() {
   addCheckpoint("App Instantiation");
   const app = new App(buffers, context);
   jsPlugins.setApp(app);
+  app.installProtectedPrompts();
   // if (plugins && !pluginErr && app.buffer) plugins.curPaneAdapter = makePaneAdapter(app.buffer, app);
   // Dispatch all JS plugin lifecycle hooks after setApp so TermMessage,
   // CurPane, cmd/action proxies, and buffer APIs all work correctly.

package/src/platform/terminal.js

@@ -0,0 +1,5 @@
+import process from "node:process";
+
+export function controllingTerminalInputPath(platform = process.platform) {
+  return platform === "win32" ? "CONIN$" : "/dev/tty";
+}