jsmdcui 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -2,6 +2,133 @@
 
 All notable user-visible changes to jsmdcui are documented here.
 
+## [0.9.0] - 2026-07-21
+
+This update expands Chrome DevTools Protocol automation for the terminal UI,
+adds a complete maze-solving example, and makes the optional Bun single-file
+executable bootstrap easier to reuse and more reliable across platforms.
+
+### Added
+
+- Add CDP automation support for reading the rendered ANSI document, activating
+  a 1-based terminal-buffer cell, and sending keyboard input through the TUI's
+  normal input parser and event pipeline. Key presses support Alt, Ctrl, Meta,
+  Shift, navigation keys, editing keys, text, and auto-repeat without emitting
+  duplicate input for paired CDP `keyDown` and `char` events.
+- Add `micro.getAllAnsiText()` and `micro.clickBufferCell(x, y)` to the JS
+  plugin bridge. MDCUI cell clicks now activate the same callbacks as mouse
+  input, while clicks in ordinary buffers retain the previous `goto` behavior.
+- Add `cdp-maze.js` and `llm-maze.txt`, a documented Bun.WebView example that
+  reads the maze from the running TUI, solves it with breadth-first search, and
+  completes it by clicking controls and sending arrow-key events through CDP.
+- Add `--cdp-maze` to open the bundled maze, start a local CDP server on port
+  9222, and automatically import and run the maze solver after a three-second
+  delay. The completed result is returned to the main program and displayed in
+  the TUI status message.
+- Add `--export-cdp-maze` to write or overwrite `./cdp-maze.js` from the
+  bundled asset first, with a source-tree fallback, then exit. Include the
+  solver in the single-executable asset archive.
+- Add a dedicated CDP automation section to the README and bundled help,
+  covering command-line and command-prompt startup, bind-address safety,
+  connection methods, and the maze solver workflow.
+- Add a reusable single-file executable guide covering asset packing, embedded
+  and external resource fallbacks, build commands, cross-compilation, Node.js
+  compatibility, and adapting the bootstrap to another project.
+
+### Changed
+
+- Move responsibility for awaiting bundled assets into the Bun-only
+  `single-exe/entry.mjs` bootstrap, then dynamically import the regular main
+  module. This keeps the main module free of Bun-specific asset-loader state
+  and preserves its uncompiled Node.js execution path.
+- Detect Bun's compiled virtual paths on both POSIX (`/$bunfs/`) and Windows
+  (`B:/~BUN`) when resolving single-executable resources, and consolidate
+  compiled-runtime handling in `single-exe/compiled.js`.
+- When initially launched with Node.js, restart under Bun with inherited stdio
+  and propagate its exit status instead of replacing the current process with
+  `process.execve()`.
+- Display the maze completion message inside the game instead of opening a
+  blocking alert, and include reset instructions in the result.
+- Export the maze solver as a reusable `runCdpMaze()` function while retaining
+  direct `bun cdp-maze.js` execution. Suppress its console result while stdin
+  is in terminal raw mode so TUI rendering is not corrupted.
+- Replace the manual two-process maze automation instructions with the single
+  `--cdp-maze` workflow in the README and bundled help.
+- Update the homepage and Kitty test images to use the smaller current demo and
+  maze screenshots; exclude the maze screenshot from the npm package.
+- Document theme preview from the TUI command prompt and state Bun 1.3.12 as
+  the minimum required version.
+
+### Fixed
+
+- Make CDP `view.click()` activate MDCUI links and controls at the requested
+  buffer coordinate instead of only moving the cursor there.
+- Allow CDP input dispatch without an explicit session ID by selecting the
+  implicit target, matching other single-target CDP operations.
+- Wait until the embedded asset archive is ready before starting the compiled
+  application, preventing startup from racing bundled resource loading.
+
+## [0.8.0] - 2026-07-20
+
+This update adds portable inline keydown handling to Markdown text controls,
+including mobile software-keyboard fallback behavior, and makes interactive
+prompts safe across every TUI frontend action path.
+
+### Added
+
+- Add quoted `@keydown="..."` attributes to named `text` and `textarea`
+  fences. The TUI preserves source event metadata and evaluates it before key
+  handling; the WUI emits a native inline event attribute. Add `.prevent` to
+  apply `event.preventDefault()` before the handler runs. Keyup is intentionally
+  not exposed because traditional terminals do not report key releases
+  reliably.
+- In the WUI, automatically map `beforeinput.data` back through `onkeydown`
+  when a mobile software keyboard reports `event.key` as `Unidentified`.
+  Unidentified events are hidden from application handlers, while identified
+  desktop keydowns are marked briefly to prevent duplicate calls.
+- Add native multiline editing to TUI `textarea` controls. Enter splits a body
+  row and expands the frame; Backspace at the start of a later row and Delete
+  at the end of a row join adjacent body rows without exposing frame borders.
+- Add the `bun ./edit` launcher as a short equivalent of
+  `bun src/index.js --edit`, opening Markdown as ordinary editable UTF-8 source.
+- Add the automatically discovered `--demo-maze` example, demonstrating
+  portable `@keydown.prevent` controls with keyboard and arrow-key navigation;
+  add `Ctrl-R` as a keyboard shortcut for resetting the maze.
+
+### Changed
+
+- Install protected `alert`, `confirm`, and `prompt` globals once for the TUI
+  lifetime and share them across OSC 8 actions, fenced keyboard handlers, and
+  JS plugins. Restore Bun's original globals when the TUI stops.
+- Make `micro.alert()`, `micro.confirm()`, and `micro.prompt()` synchronous like
+  their native counterparts, and update the bundled JS plugin examples so they
+  do not `await` these calls.
+- Add TUI `.val(value)` replacements to Undo/Redo history, including multiline
+  layout, ANSI rendering metadata, image positions, and task-list anchors.
+
+### Fixed
+
+- Prevent `alert()` called from a keydown handler from competing with the TUI
+  for stdin by suspending raw mode and screen rendering around native prompts.
+- Restore the terminal's previous raw-mode and input-listener state after a
+  protected prompt, including setup, prompt, and cleanup error paths.
+- Index fenced keyboard-event regions once and use binary lookup for each key,
+  instead of rescanning the rendered Markdown document on every keypress.
+- Open Windows controlling-terminal input through read-only `CONIN$` when stdin
+  is redirected, so piped Markdown retains keyboard and protected-prompt input.
+- Preserve `ctrlKey`, `shiftKey`, `altKey`, and `metaKey` when the WUI maps an
+  unidentified mobile keydown through its `beforeinput` fallback.
+- Recover modified A-Z keys in the WUI from key codes 65-90 or physical
+  `KeyA`-`KeyZ` codes, including Android browsers that transform Alt-S into
+  `ß`; exclude AltGraph so international text composition remains intact.
+- Add matching non-enumerable `event.toJSON()` methods to TUI and WUI keydown
+  events, allowing `JSON.stringify(event)` to produce portable event details.
+- Keep fenced-block IDs visible to collision checking when the info string also
+  contains inline event attributes such as `@keydown="..."`.
+- When the WUI's default port 3000 is already in use, retry with port 0 so the
+  operating system selects an available port, and print that actual port in the
+  generated URL. Other server startup errors continue to fail normally.
+
 ## [0.7.0] - 2026-07-20
 
 This update adds native Kitty image rendering, turns heading task lists into

package/README.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/cdp-maze.js

@@ -0,0 +1,141 @@
+#!/usr/bin/env bun
+
+// Generated from llm-maze.txt instructions.
+// Start the maze TUI first:
+//   bun src/index.js --remote-debugging-port=9222 demos/maze.md
+// Then run:
+//   bun cdp-maze.js
+
+const DEFAULT_CDP_URL = "ws://127.0.0.1:9222/devtools/browser/cdp-server";
+
+const dirs = [
+  [1, 0, "ArrowDown"],
+  [-1, 0, "ArrowUp"],
+  [0, 1, "ArrowRight"],
+  [0, -1, "ArrowLeft"],
+];
+
+function parseMaze(text) {
+  return text.trimEnd().split("\n").map(line => {
+    const cells = [];
+
+    for (let i = 0; i < line.length;) {
+      const ch = String.fromCodePoint(line.codePointAt(i));
+
+      if (ch === "🧱" || ch === "😀") {
+        cells.push(ch);
+        i += ch.length;
+      } else if (line[i] === " ") {
+        cells.push(" ");
+        i += 2;
+      } else {
+        cells.push(ch);
+        i += ch.length;
+      }
+    }
+
+    return cells;
+  });
+}
+
+function solveMaze(grid) {
+  let start;
+
+  for (let row = 0; row < grid.length; row++) {
+    for (let col = 0; col < grid[row].length; col++) {
+      if (grid[row][col] === "😀") start = [row, col];
+    }
+  }
+
+  if (!start) throw new Error("Maze start not found");
+
+  const queue = [{ row: start[0], col: start[1], path: [] }];
+  const seen = new Set([start.join(",")]);
+
+  while (queue.length) {
+    const { row, col, path } = queue.shift();
+
+    for (const [dr, dc, key] of dirs) {
+      const nextRow = row + dr;
+      const nextCol = col + dc;
+
+      if (
+        nextRow < 0 ||
+        nextRow >= grid.length ||
+        nextCol < 0 ||
+        nextCol >= grid[row].length
+      ) {
+        if (path.length > 0) return path.concat(key);
+        continue;
+      }
+
+      if (nextCol >= grid[nextRow].length) continue;
+      if (grid[nextRow][nextCol] === "🧱") continue;
+
+      const id = `${nextRow},${nextCol}`;
+      if (seen.has(id)) continue;
+
+      seen.add(id);
+      queue.push({
+        row: nextRow,
+        col: nextCol,
+        path: path.concat(key),
+      });
+    }
+  }
+
+  throw new Error("No path found");
+}
+
+export async function runCdpMaze(cdpUrl = DEFAULT_CDP_URL) {
+  const view = new Bun.WebView({
+    backend: {
+      type: "chrome",
+      url: cdpUrl,
+    },
+  });
+
+  try {
+    const control = await view.evaluate(`
+    (() => {
+      const lines = micro.getAllText().split("\\n");
+      const y = lines.findIndex(line =>
+        line.includes("Put the cursor here")
+      );
+
+      return {
+        x: lines[y].indexOf("Put the cursor here") + 1,
+        y: y + 1,
+      };
+    })()
+  `);
+
+    await view.click(control.x, control.y);
+    await view.press("r", { modifiers: ["Control"] });
+    await Bun.sleep(100);
+
+    const mazeText = await view.evaluate(`$("#character").val()`);
+    const path = solveMaze(parseMaze(mazeText));
+
+    for (const key of path) {
+      await view.press(key);
+      await Bun.sleep(100);
+
+      const status = await view.evaluate(`$("#last-key").val()`);
+      if (status.includes("Escaped the maze")) break;
+      if (status.includes("Wall")) {
+        throw new Error(`Hit a wall after ${key}: ${status}`);
+      }
+    }
+
+    const result = await view.evaluate(`$("#last-key").val()`);
+    if (!process.stdin.isRaw) console.log(result);
+    return result;
+  } finally {
+    view.close();
+  }
+}
+
+if (import.meta.main) {
+  await runCdpMaze(Bun.argv[2] ?? DEFAULT_CDP_URL);
+}