jsmdcui 0.7.0 → 0.9.0

package/runtime/help/help.md

@@ -1,5 +1,10 @@
 ![Demo](https://raw.githubusercontent.com/jjtseng93/jsmdcui/main/demo.jpg)
 
+- Maze Game
+  * The TUI can be controlled through the Chrome DevTools Protocol (CDP). Codex successfully solved this maze using it.
+
+![Maze Game](https://raw.githubusercontent.com/jjtseng93/jsmdcui/main/maze.jpg)
+
 # Demo App
 ## My app
 
@@ -36,7 +41,8 @@ npx jsmdcui@latest README.md
 
 ## Quick start
 
-jsmdcui requires [Bun](https://bun.com). On Android, install it in Termux:
+jsmdcui requires [Bun ≥ 1.3.12](https://bun.com).
+ On Android, install it in Termux:
 
 ```sh
 npm install -g bun
@@ -89,6 +95,18 @@ npx jsmdcui --demo-imgtool
 npx jsmdcui --demo-imgtool-zh
 ```
 
+```sh
+# Maze game demo
+npx jsmdcui --demo-maze
+```
+
+To watch jsmdcui start the maze with a local CDP server and solve it
+automatically after three seconds, run:
+
+```sh
+npx jsmdcui --cdp-maze
+```
+
 ```sh
 # WUI(Web User Interface) Demo
 npx jsmdcui --wui
@@ -134,7 +152,7 @@ bun src/index.js --wui testapp.md
 | --- | --- |
 | `bun src/index.js app.md` | Render `app.md` as a read-only terminal UI and write five generated files beside it. |
 | `bun src/index.js --kitty app.md` | Display Markdown images with Kitty graphics and the jsgotty MIME extension. |
-| `bun src/index.js --kitty-compat app.md` | Display Markdown images with Kitty graphics without the non-standard MIME `U` field. |
+| `bun src/index.js --kitty-compat app.md` | Convert Markdown images to PNG with `Bun.Image` and display them using the standard Kitty graphics protocol without the non-standard MIME `U` field. |
 | `bun src/index.js --kitty --allow-url URL.md` | Download trusted HTTP(S) Markdown and its HTTP(S) images, then display supported images with Kitty graphics. |
 | `JSMDCUI_KITTY_DEBUG=1 bun src/index.js --kitty app.md` | Enable Kitty image placement logging to `kitty-placement.log`. |
 | `bun src/index.js --check app.md` | Check heading and fenced-block IDs for collisions, print line-by-line details, and exit. |
@@ -142,11 +160,13 @@ bun src/index.js --wui testapp.md
 | `bun src/index.js --cat app.md` | Render the terminal version to stdout, write five generated files beside it, and exit. |
 | `bun src/index.js --testapp.md` | Write the bundled `testapp.md` source to stdout and exit. |
 | `bun src/index.js --export-readme` | Write or overwrite `./README.md` with the bundled README source and exit. |
+| `bun src/index.js --export-cdp-maze` | Write or overwrite `./cdp-maze.js` with the bundled CDP maze solver and exit. |
 | `bun src/index.js --demo-list` | List `testapp.md` and every bundled `demos/*.md` example with its command-line option, then exit. |
 | `bun src/index.js --demo` | Use local `testapp.md` when present, otherwise write the bundled demo; open it in the terminal UI and write five generated files beside it. |
 | `bun src/index.js --demo-<filename>` | Load `demos/<filename>.md`; preserve an existing local copy or write the bundled copy, then open it and generate its five companion files. New files added under `demos/` work automatically. |
 | `bun src/index.js --demo-imgtool` | Compatibility alias for `--demo-image-processor`. |
 | `bun src/index.js --demo-imgtool-zh` | Compatibility alias for `--demo-image-processor.zh-TW`. |
+| `bun src/index.js --cdp-maze` | Load the maze demo, start CDP on `127.0.0.1:9222`, and run the bundled solver after three seconds. |
 | `bun src/index.js --allow-url URL.md` | Download HTTP(S) Markdown to the current directory and, with Kitty mode enabled, download its HTTP(S) images; write 5 generated files and allow embedded code to run. Only use trusted URLs. |
 | `bun src/index.js --wui` | Use local `testapp.md` when present, otherwise write the bundled demo; write five generated files in the current directory, then print and serve a random URL. |
 | `bun src/index.js --wui app.md` | Write five generated files beside `app.md`, then print and serve a random URL. |
@@ -239,12 +259,81 @@ native `<textarea>` with the declared ID and classes. Long text wraps
 automatically, and the field height is recalculated when the user types, the
 window is resized, or frontend code calls `.val(value)`.
 
+In the TUI, `text` remains a single-line control while `textarea` supports
+native multiline editing. Enter splits the current body row and grows the
+frame, Backspace at the start of a later row joins it to the previous row, and
+Delete at the end of a row joins the following row. When the expanded control
+does not fit on screen, the document viewport scrolls to keep the cursor
+visible. The closing border and following Markdown content move with the
+resized control.
+
+A named `text` or `textarea` block can run inline front-end code before it
+handles a key by placing a quoted HTML-style `@keydown` attribute after its
+identity:
+
+````md
+```text#command.field @keydown="handleCommand(event)"
+Initial value
+```
+
+```js front
+export function handleCommand(event) {
+  if (event.key !== 'Enter') return;
+  event.preventDefault();
+  alert(`Command: ${$('#command').val()}`);
+}
+```
+````
+
+The block must have a unique ID. In the WUI, jsmdcui writes the code directly
+to the generated textarea's native `onkeydown` attribute. Mobile browsers may
+report ordinary software-keyboard letters as `Unidentified`, so the WUI also
+generates an `onbeforeinput` fallback. The unidentified event is hidden from
+the handler; `beforeinput.data` becomes `event.key`, then the same keydown code
+runs once. The fallback also preserves `ctrlKey`, `shiftKey`, `altKey`, and
+`metaKey` from the unidentified keydown. A short zero-delay timer distinguishes
+it from the `beforeinput` that normally follows an already identified keydown,
+preventing duplicate calls.
+
+On Android browsers, `Alt-E`, `Alt-N`, `Alt-U`, and `Alt-I` may be consumed or
+transformed by the software keyboard and therefore cannot always be observed
+reliably by a keydown handler. Avoid relying on these combinations for portable
+WUI controls.
+
+In the TUI, the full source info string is kept in an event table before Bun
+renders it. The keydown statements run with a synthetic `event` before the
+text control handles the key. Both interfaces expose `event.key`, modifier
+flags, `event.target.id`, and `event.target.value`. Use `event`, the native
+inline-handler variable, rather than Vue's `$event` alias. Double quotes
+delimit the handler; use single-quoted JavaScript strings inside it or escape
+an embedded double quote as `\"`.
+
+Both interfaces add a non-enumerable `event.toJSON()` method with matching
+keyboard, modifier, prevention, and target fields. `JSON.stringify(event)`
+calls it automatically, so the resulting JSON is portable between the TUI and
+WUI.
+
+A keydown handler can call `event.preventDefault()` to stop text insertion or
+cursor movement. The `.prevent` modifier applies this automatically:
+
+````md
+```text#command @keydown.prevent="handleCommand(event)"
+```
+````
+
+`@keydown` is the only keyboard event exposed by jsmdcui. Traditional terminal
+input does not report physical key releases reliably, so jsmdcui does not
+provide or emulate `@keyup` in either interface.
+
 In the terminal TUI, only content after the protected `│ ` or `| ` prefix can
-be edited. The frame prefix cannot be deleted, Enter cannot insert a newline,
-Delete at the end of a row cannot join the next row, and multiline paste is
-blocked. Activate the lower-left frame corner to add a row. Activate the
-upper-left frame corner to remove the trailing row only when it is empty;
-non-empty content is never removed.
+be edited, and the frame prefix cannot be deleted. Multiline paste remains
+blocked. For single-line `text` controls, activate the lower-left frame corner
+to add a row. Activate the upper-left frame corner to remove the trailing row
+only when it is empty; non-empty content is never removed.
+
+TUI text-control changes made through `.val(value)` participate in the same
+history as direct editing. `Ctrl-Z` undoes the replacement and `Ctrl-Y` redoes
+it, including multiline frame resizing and its associated rendered metadata.
 
 ### Heading task lists and selector API
 
@@ -384,7 +473,7 @@ The available selector methods are:
 | Method | TUI | WUI |
 | --- | --- | --- |
 | `.val()` | Read text blocks or heading task-list values. | Read textareas/controls or heading task-list values. |
-| `.val(value)` | Replace text-block contents and resize multiline values. | Set textarea/control values and resize textareas. |
+| `.val(value)` | Replace text-block contents, resize multiline values, and record Undo/Redo history. | Set textarea/control values and resize textareas. |
 | `.html()` | Return a selected heading's inner HTML. | Return any successfully selected DOM element's `innerHTML`. |
 | `.line()` | Return a heading's current 1-based TUI row, or `0` if missing. | Not available. |
 | `.push(...items)` | Append unchecked strings or `{ value, checked }` task items; return the new direct-item count. | Same. |
@@ -397,16 +486,16 @@ The available selector methods are:
 TUI heading rows are recalculated after text-block rows are added, removed, or
 replaced with multiline `.val(value)` content.
 
-The three UI building blocks are:
+The 3 UI building blocks are:
 
-- Regular Markdown provides headings, text, lists, task checkboxes, code, and
+- 1. `Regular Markdown` provides headings, text, lists, task checkboxes, code, and
   links.
-- A `js front` block contains UI code. Exported functions can use
+- 2. `js front` block contains UI code. Exported functions can use
   `alert`, `confirm`, `prompt`, and the generated `rpc` client.
-- A front module may export `async function onMdcuiExit({ reason, path, $ })`.
-  The terminal UI awaits it before closing an `mdcui` buffer. Modified
-  `mdcui` buffers close without a save prompt.
-- A `js back` block exports trusted backend functions. In the browser WUI,
+  * A front module may export `async function onMdcuiExit({ reason, path, $ })`.
+  * The terminal UI awaits it before closing an `mdcui` buffer. 
+  * Modified `mdcui` buffers close without a save prompt.
+- 3. `js back` block exports trusted backend functions. In the browser WUI,
   `rpc` publishes only exported functions whose exported names do not start
   with `_`. Call a published function from the front end with
   `await rpc.functionName(arg1, arg2)`.
@@ -463,6 +552,10 @@ selection, search, and copy remain available.
 | `Alt-G` | Show or hide the shortcut bar. |
 | `Ctrl-Q` or `Alt-Q` | Close the current UI. |
 
+To preview another color theme, press `Ctrl-E` or click on `€`, type `theme `, then use `Tab`
+and the arrow keys to browse the available themes. Press `Enter` to switch to
+the selected theme, or `Esc` to cancel and restore the previous one.
+
 The terminal automatically reflows the Markdown when its width changes.
 Only `javascript:` links execute in the TUI; ordinary web links behave as
 normal links in the browser.
@@ -480,6 +573,63 @@ supported HTTP(S) images with Kitty graphics, combine the options:
 bun src/index.js --kitty --allow-url https://example.com/app.md
 ```
 
+### CDP control for TUI automation
+
+The terminal UI can expose a Chrome DevTools Protocol (CDP) server, so another
+Bun process can inspect the terminal buffer, click buffer coordinates, and send
+real keyboard events to the running TUI.
+
+Start CDP from the command line when launching jsmdcui:
+
+```sh
+bun src/index.js --remote-debugging-port=9222 demos/maze.md
+bun src/index.js --remote-debugging-port=9222 --remote-debugging-address=127.0.0.1 demos/maze.md
+```
+
+Or start it from inside the TUI editor command prompt(Ctrl-E or €):
+
+```text
+Ctrl-E  cdp
+Ctrl-E  cdp 9000
+Ctrl-E  cdp --address=127.0.0.1
+Ctrl-E  cdp 9000 --public
+```
+
+The default bind address is `127.0.0.1` and the default port is `9222`.
+Use `--public` or `--address=0.0.0.0` only on a trusted network.
+
+Once CDP is running, control the TUI with `Bun.WebView`. For more info, enter
+jsmdcui and use `Ctrl-E` or `€` → `help cdp`.
+
+The cli flag `--cdp-maze` is a combination of 
+  1. Start the demos/maze.md
+  2. Start a local CDP server
+  3. Wait three seconds
+  4. Run the solver cdp-maze.js automatically
+  
+The solver was
+generated from the `llm-maze.txt` instructions; it focuses the maze controls,
+resets the game, reads the maze from the TUI, solves it with breadth-first
+search, and sends arrow-key input until the maze is escaped:
+
+```sh
+npx jsmdcui@latest --cdp-maze
+```
+
+From the source tree, run:
+
+```sh
+bun src/index.js --cdp-maze
+```
+
+Useful automation methods used by `cdp-maze.js`:
+
+- `view.evaluate(js)`
+  - `view.evaluate("micro.getAllText()")`
+  - `view.evaluate("micro.getAllAnsiText()")`
+- `view.click(column, line)`
+- `view.press(key, options)`
+
 ## Browser interaction
 
 The WUI uses normal browser mouse and keyboard behavior. Clicking a
@@ -489,15 +639,35 @@ its associated text. `alert`, `confirm`, and `prompt` use the browser's built-in
 dialogs. Checkbox changes exist only in the current page: refreshing does not
 preserve them and does not update the Markdown file.
 
-The WUI uses port `3000` by default and accepts connections through the
-machine's available network interfaces. The printed `localhost` URL is for the
-same machine. From another device on the same network, replace `localhost` with
-the server machine's IP address and keep the same port and full path.
+The WUI first tries port `3000` and accepts connections through the machine's
+available network interfaces. If port `3000` is already in use, the operating
+system selects an available port instead; the printed URL always contains the
+actual port. Set `PORT` to request another fixed port. The printed `localhost`
+URL is for the same machine. From another device on the same network, replace
+`localhost` with the server machine's IP address and keep the printed port and
+full path.
 
 Each server start prints a new random path. The old URL stops working after the
 server is stopped or restarted. Keep the process running while using the page,
 and press `Ctrl-C` in its terminal to stop it.
 
+## Editing Markdown source
+
+From a cloned repository, use the `edit` launcher to open a Markdown file as
+ordinary editable UTF-8 source instead of rendering it as a Markdown UI:
+
+```sh
+bun ./edit app.md
+```
+
+This is equivalent to:
+
+```sh
+bun src/index.js --edit app.md
+```
+
+Additional file and cursor arguments are forwarded unchanged.
+
 ## Generated files
 
 Opening a local Markdown UI generates these files beside the source file:

package/runtime/jsplugins/cdp/cdp-server.js

@@ -554,8 +554,30 @@ async function dispatch(ctx, state, method, params, sessionId, emit) {
       return {};
     }
     case "Input.dispatchKeyEvent": {
-      if (params.type === "keyDown" || params.type === "char") {
-        await ctx.press?.(params.key ?? params.text, { modifiers: params.modifiers ?? 0 });
+      const target = getSessionTarget(state, sessionId);
+      const key = params.key ?? params.text ?? "";
+      const signature = `${params.code ?? key}:${params.modifiers ?? 0}`;
+      if (params.type === "rawKeyDown" || params.type === "keyDown") {
+        if (target.cdpKeyDown !== signature || params.autoRepeat) {
+          await ctx.press?.(key, {
+            modifiers: params.modifiers ?? 0,
+            text: params.text ?? "",
+            code: params.code ?? "",
+            repeat: !!params.autoRepeat,
+          });
+          target.cdpKeyDown = signature;
+        }
+      } else if (params.type === "char") {
+        if (!target.cdpKeyDown) {
+          await ctx.press?.(key, {
+            modifiers: params.modifiers ?? 0,
+            text: params.text ?? "",
+            code: params.code ?? "",
+            repeat: !!params.autoRepeat,
+          });
+        }
+      } else if (params.type === "keyUp") {
+        target.cdpKeyDown = null;
       }
       return {};
     }
@@ -695,6 +717,8 @@ function navigateTarget(state, target, url, emit, options = {}) {
 }
 
 function getSessionTarget(state, sessionId) {
+  if (!sessionId) return getImplicitTarget(state);
+
   const targetId = state.sessions.get(sessionId);
   const target = state.targets.get(targetId);
   if (!target) throw new Error(`No target for session: ${sessionId}`);

package/runtime/jsplugins/cdp/cdp.js

@@ -34,6 +34,8 @@ Flat buffer helpers (all 1-based line numbers, omit → cursor line):
   micro.getLine(n?)            micro.putLine(text, n?)     micro.delLine(n?)
   micro.getLines(from?, to?)   micro.getLinesCount()
   micro.getAllText()           — entire buffer as one string (lines joined by "\n")
+  micro.getAllAnsiText()       — rendered ANSI document, or plain text when unavailable
+  micro.clickBufferCell(x, y)  — activate a 1-based MDCUI cell, or goto in other buffers
   micro.putAllText(text)       — replace entire buffer content; pushes undo
   micro.getSelection()         micro.putSelection(text)
 
@@ -44,7 +46,10 @@ Other micro APIs:
                                  e.g. for command "js 1+1": args.raw = "js 1+1", args.raw.slice(3) = "1+1"
   micro.RegisterAction(name, fn) — register bindable action
   micro.TermMessage(msg)       — show msg in editor status row
-  micro.alert(msg)             — suspend editor, print msg, wait for Enter
+  micro.alert(msg)             — synchronous; suspend editor, print msg, wait for Enter
+                                 e.g. micro.alert("Done") (do not await)
+  micro.confirm(msg)           — synchronous boolean result
+  micro.prompt(msg, default?)  — synchronous string or null result
   micro.Log(...args)           — console.log passthrough
   micro.GetOption(name)        micro.SetOption(name, value)
   micro.cmd.save()             — call any editor command via proxy
@@ -79,7 +84,7 @@ micro.on("init", () => {
         },
         async click(x,y,opt){
           x=x||1 ; y=y||1 ;
-          await micro.cmd.goto(y+':'+x);
+          await micro.clickBufferCell(x, y);
         },
         async scroll(dx,dy){
           const pane = micro.CurPane();
@@ -108,54 +113,8 @@ micro.on("init", () => {
           bp.Insert(text);
         },
         async press(key, options){
-          const bp = micro.CurPane();
-          if (!bp) return;
-
-          // modifiers bitmask: Alt=1, Ctrl=2, Meta=4, Shift=8
-          const mod = options?.modifiers ?? 0;
-          const ctrl  = !!(mod & 2);
-          const shift = !!(mod & 8);
-
-          if (ctrl) {
-            const ctrlMap = {
-              a: () => micro.action.SelectAll(),
-              c: () => micro.action.Copy(),
-              x: () => micro.action.Cut(),
-              v: () => micro.action.Paste(),
-              z: () => micro.action.Undo(),
-              y: () => micro.action.Redo(),
-              s: () => micro.action.Save(),
-            };
-            const h = ctrlMap[key.toLowerCase()];
-            if (h) await h();
-            return;
-          }
-
-          const arrowAction = shift
-            ? { ArrowUp: 'SelectUp', ArrowDown: 'SelectDown', ArrowLeft: 'SelectLeft', ArrowRight: 'SelectRight' }
-            : { ArrowUp: 'CursorUp', ArrowDown: 'CursorDown', ArrowLeft: 'CursorLeft', ArrowRight: 'CursorRight' };
-
-          const keyMap = {
-            ...arrowAction,
-            Enter:     () => micro.action.InsertNewline(),
-            Backspace: () => micro.action.Backspace(),
-            Delete:    () => micro.action.Delete(),
-            Tab:       () => micro.action.InsertTab(),
-            Escape:    () => micro.action.Escape(),
-            Home:      () => shift ? micro.action.SelectToStartOfLine() : micro.action.StartOfLine(),
-            End:       () => shift ? micro.action.SelectToEndOfLine()   : micro.action.EndOfLine(),
-            PageUp:    () => shift ? micro.action.SelectPageUp()        : micro.action.CursorPageUp(),
-            PageDown:  () => shift ? micro.action.SelectPageDown()      : micro.action.CursorPageDown(),
-          };
-
-          const entry = keyMap[key];
-          if (typeof entry === 'string') {
-            await micro.action[entry]();
-          } else if (typeof entry === 'function') {
-            await entry();
-          } else if (key.length === 1) {
-            bp.Insert(key);
-          }
+          const raw = cdpKeyToTerminalInput(key, options);
+          if (raw) await micro._dispatchRawInput(raw);
         },
       }
     
@@ -169,7 +128,7 @@ micro.on("init", () => {
       const addr = isPublic ? `0.0.0.0:${port}` : `127.0.0.1:${port}`;
       micro.TermMessage(`CDP@${addr} server running 伺服器啟動了`)
 
-      //await micro.alert(CdpServer)
+      //micro.alert(CdpServer)
     }  //  server not running
     else
     {
@@ -190,3 +149,53 @@ function toInteger(value) {
   const number = Number(value);
   return Number.isFinite(number) ? Math.trunc(number) : 0;
 }
+
+function cdpKeyToTerminalInput(key, options = {}) {
+  const modifiers = Number(options.modifiers) || 0;
+  const alt = !!(modifiers & 1);
+  const ctrl = !!(modifiers & 2);
+  const meta = !!(modifiers & 4);
+  const shift = !!(modifiers & 8);
+  const modifierCode = 1 + (shift ? 1 : 0) + (alt || meta ? 2 : 0) + (ctrl ? 4 : 0);
+  const value = String(key ?? options.text ?? "");
+
+  const cursorFinal = {
+    ArrowUp: "A",
+    ArrowDown: "B",
+    ArrowRight: "C",
+    ArrowLeft: "D",
+    Home: "H",
+    End: "F",
+  }[value];
+  if (cursorFinal) {
+    return modifierCode === 1
+      ? `\x1b[${cursorFinal}`
+      : `\x1b[1;${modifierCode}${cursorFinal}`;
+  }
+
+  if (value === "PageUp" || value === "PageDown" || value === "Delete") {
+    const number = value === "PageUp" ? 5 : value === "PageDown" ? 6 : 3;
+    return modifierCode === 1
+      ? `\x1b[${number}~`
+      : `\x1b[${number};${modifierCode}~`;
+  }
+
+  if (value === "Tab") return shift ? "\x1b[Z" : "\t";
+  if (value === "Enter") return alt || meta ? "\x1b\r" : "\r";
+  if (value === "Backspace") return "\x7f";
+  if (value === "Escape") return "\x1b";
+
+  let text = typeof options.text === "string" && options.text
+    ? options.text
+    : value === "Space" ? " " : value;
+  if ([...text].length !== 1) return "";
+
+  if (ctrl) {
+    const code = text.toUpperCase().charCodeAt(0);
+    if (code >= 64 && code <= 95) text = String.fromCharCode(code & 31);
+  } else if (shift && /^[a-z]$/.test(text)) {
+    text = text.toUpperCase();
+  }
+
+  return alt || meta ? `\x1b${text}` : text;
+}

package/runtime/jsplugins/chapter/chapter.js

@@ -35,6 +35,8 @@ Flat buffer helpers (all 1-based line numbers, omit → cursor line):
   micro.getLine(n?)            micro.putLine(text, n?)     micro.delLine(n?)
   micro.getLines(from?, to?)   micro.getLinesCount()
   micro.getAllText()           — entire buffer as one string (lines joined by "\n")
+  micro.getAllAnsiText()       — rendered ANSI document, or plain text when unavailable
+  micro.clickBufferCell(x, y)  — activate a 1-based MDCUI cell, or goto in other buffers
   micro.putAllText(text)       — replace entire buffer content; pushes undo
   micro.getSelection()         micro.putSelection(text)
 
@@ -43,7 +45,10 @@ Other micro APIs:
   micro.MakeCommand(name, fn)  — register Ctrl+E command; fn(bp, args[])
   micro.RegisterAction(name, fn) — register bindable action
   micro.TermMessage(msg)       — show msg in editor status row
-  micro.alert(msg)             — suspend editor, print msg, wait for Enter
+  micro.alert(msg)             — synchronous; suspend editor, print msg, wait for Enter
+                                 e.g. micro.alert("Done") (do not await)
+  micro.confirm(msg)           — synchronous boolean result
+  micro.prompt(msg, default?)  — synchronous string or null result
   micro.Log(...args)           — console.log passthrough
   micro.GetOption(name)        micro.SetOption(name, value)
   micro.cmd.save()             — call any editor command via proxy
@@ -104,5 +109,3 @@ micro.on("init", () => {
   });
 
 });
-
-

package/runtime/jsplugins/example/example.js

@@ -35,6 +35,8 @@ Flat buffer helpers (all 1-based line numbers, omit → cursor line):
   micro.getLine(n?)            micro.putLine(text, n?)     micro.delLine(n?)
   micro.getLines(from?, to?)   micro.getLinesCount()
   micro.getAllText()           — entire buffer as one string (lines joined by "\n")
+  micro.getAllAnsiText()       — rendered ANSI document, or plain text when unavailable
+  micro.clickBufferCell(x, y)  — activate a 1-based MDCUI cell, or goto in other buffers
   micro.putAllText(text)       — replace entire buffer content; pushes undo
   micro.getSelection()         micro.putSelection(text)
 
@@ -45,7 +47,10 @@ Other micro APIs:
                                  e.g. for command "js 1+1": args.raw = "js 1+1", args.raw.slice(3) = "1+1"
   micro.RegisterAction(name, fn) — register bindable action
   micro.TermMessage(msg)       — show msg in editor status row
-  micro.alert(msg)             — suspend editor, print msg, wait for Enter
+  micro.alert(msg)             — synchronous; suspend editor, print msg, wait for Enter
+                                 e.g. micro.alert("Done") (do not await)
+  micro.confirm(msg)           — synchronous boolean result
+  micro.prompt(msg, default?)  — synchronous string or null result
   micro.Log(...args)           — console.log passthrough
   micro.GetOption(name)        micro.SetOption(name, value)
   micro.cmd.save()             — call any editor command via proxy
@@ -58,14 +63,14 @@ Other micro APIs:
 
 micro.on("init", () => {
   // Register a custom Ctrl+E command
-  micro.MakeCommand("showpath", async (bp, args) =>
+  micro.MakeCommand("showpath", (bp, args) =>
   {
     //micro.TermMessage("Hello from JS plugin! Args: " + args.join(", "));
 
-    //await micro.alert(micro.getLine())
+    //micro.alert(micro.getLine())
     const path = bp?.Buf?.Path || "(no path)";
     const loc = bp?.CursorLocation?.() || "+1.0:1";
-    await micro.alert(`${path}\n${loc}`)
+    micro.alert(`${path}\n${loc}`)
     
   });
   
@@ -75,12 +80,12 @@ micro.on("init", () => {
     // args.raw is the full original input string, e.g. "js console.log('hi')"
     // slice(3) skips the "js " prefix (2-char name + 1 space)
     const scriptText = args.raw?.slice(3) ?? args.join(" ");
-    await micro.alert(await eval(scriptText));
+    micro.alert(await eval(scriptText));
   });
   
 
   // greet: shows a message via micro.alert (leaves editor, shows text, Enter returns)
-  micro.MakeCommand("greet", async (bp, args) => 
+  micro.MakeCommand("greet", (bp, args) =>
   {
     const name = args.length ? 
                args.join(" ") : "world";
@@ -89,7 +94,7 @@ micro.on("init", () => {
       '# Hello\n- '+name
     );
     
-    await micro.alert(s);
+    micro.alert(s);
   });
 
   // Register a custom action (can be bound to a key in keybindings.json)

package/runtime/syntax/markdown.yaml

@@ -52,6 +52,7 @@ rules:
 # keywords
 # javascript alert confirm prompt rpc 
 # front back 
+# export function keydown 
 # console log error JSON stringify parse
 # async await Promise 
 # textarea text password search