jsmdcui 0.7.0 → 0.8.0

package/src/plugins/js-bridge.js

@@ -752,6 +752,56 @@ function _findBlock(lines, selector) {
   return null;
 }
 
+export function findTuiBlockAtLine(lines, lineIndex) {
+  return findTuiBlockInIndex(buildTuiBlockIndex(lines), lineIndex);
+}
+
+export function buildTuiBlockIndex(lines, declarations = null) {
+  const blocks = [];
+  for (let start = 0; start < lines.length; start++) {
+    const header = _blockHeader(lines[start]);
+    if (!header) continue;
+    let end = lines.length;
+    for (let y = start + 1; y < lines.length; y++) {
+      const line = String(lines[y] ?? "");
+      const rest = line.startsWith(header.indent)
+        ? line.slice(header.indent.length)
+        : line;
+      if (header.kind === "fenced") {
+        const closing = rest.match(/^(`{3,})\s*$/);
+        if (!closing || closing[1].length < header.fenceLength) continue;
+      } else if (!/^(?:└─|╰─|\+-)\s*$/.test(rest)) {
+        continue;
+      }
+      end = y;
+      break;
+    }
+    const declaration = header.id ? declarations?.get(header.id) : null;
+    if (
+      declarations == null
+      || (
+        declaration?.tag === header.tag
+        && declaration.events?.size > 0
+      )
+    ) blocks.push({ start, end, header });
+    start = Math.max(start, end);
+  }
+  return blocks;
+}
+
+export function findTuiBlockInIndex(blocks, lineIndex) {
+  let low = 0;
+  let high = blocks.length - 1;
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const block = blocks[middle];
+    if (lineIndex <= block.start) high = middle - 1;
+    else if (lineIndex >= block.end) low = middle + 1;
+    else return block;
+  }
+  return null;
+}
+
 function _blockValue(lines, selector) {
   const block = _findBlock(lines, selector);
   if (!block) return undefined;
@@ -983,7 +1033,7 @@ function _mutateTuiHeadingList(buffer, heading, method, args) {
         buffer._mdcuiHeadingTaskListAnchors = new Map();
       buffer._mdcuiHeadingTaskListAnchors.set(heading.ordinal, { index: start, indent: list.indent });
     }
-    _spliceBufferLines(buffer, start, end - start, replacement.lines, {
+    spliceTuiBufferLines(buffer, start, end - start, replacement.lines, {
       styles: replacement.styles,
       ansi: replacement.ansi,
     });
@@ -1003,14 +1053,14 @@ function _mutateTuiHeadingList(buffer, heading, method, args) {
         indent: list.indent,
       });
     }
-    _spliceBufferLines(buffer, item.start, item.end - item.start, []);
+    spliceTuiBufferLines(buffer, item.start, item.end - item.start, []);
     return item.value;
   }
 
   const replacement = _tuiTaskItemReplacement(list.indent, args);
   if (replacement.lines.length === 0) return list.items.length;
   const start = method === "push" ? list.end : list.first;
-  _spliceBufferLines(buffer, start, 0, replacement.lines, {
+  spliceTuiBufferLines(buffer, start, 0, replacement.lines, {
     styles: replacement.styles,
     ansi: replacement.ansi,
   });
@@ -1018,8 +1068,10 @@ function _mutateTuiHeadingList(buffer, heading, method, args) {
   return list.items.length + replacement.lines.length;
 }
 
-function _spliceBufferLines(buffer, start, deleteCount, replacement, replacementMeta = {}) {
+export function spliceTuiBufferLines(buffer, start, deleteCount, replacement, replacementMeta = {}) {
   const oldCursor = buffer.cursor ? { ...buffer.cursor } : null;
+  buffer._mdcuiFenceBlockIndex = null;
+  buffer._mdcuiControlBlockIndex = null;
   buffer.lines.splice(start, deleteCount, ...replacement);
 
   if (Array.isArray(buffer._ansiStyleLines)) {
@@ -1065,24 +1117,70 @@ function _spliceBufferLines(buffer, start, deleteCount, replacement, replacement
   buffer.ensureCursor?.();
 }
 
+export function insertTuiTextareaNewline(buffer, block) {
+  if (!buffer || block?.header?.tag !== "textarea") return false;
+  const prefix = block.header.indent + block.header.bodyMarker + " ";
+  const line = String(buffer.lines?.[buffer.cursor.y] ?? "");
+  const left = line.slice(0, buffer.cursor.x);
+  const right = line.slice(buffer.cursor.x);
+  buffer.lines[buffer.cursor.y] = left;
+  spliceTuiBufferLines(buffer, buffer.cursor.y + 1, 0, [prefix + right]);
+  buffer.cursor.y++;
+  buffer.cursor.x = prefix.length;
+  buffer.ensureCursor?.();
+  return true;
+}
+
+export function mergeTuiTextareaBackward(buffer, block) {
+  if (!buffer || block?.header?.tag !== "textarea") return false;
+  const prefix = block.header.indent + block.header.bodyMarker + " ";
+  if (buffer.cursor.x > prefix.length || buffer.cursor.y <= block.start + 1) return false;
+  const previousY = buffer.cursor.y - 1;
+  const previousLength = String(buffer.lines?.[previousY] ?? "").length;
+  const line = String(buffer.lines?.[buffer.cursor.y] ?? "");
+  const body = line.startsWith(prefix) ? line.slice(prefix.length) : line;
+  buffer.lines[previousY] += body;
+  spliceTuiBufferLines(buffer, buffer.cursor.y, 1, []);
+  buffer.cursor.y = previousY;
+  buffer.cursor.x = previousLength;
+  buffer.ensureCursor?.();
+  return true;
+}
+
+export function mergeTuiTextareaForward(buffer, block) {
+  if (!buffer || block?.header?.tag !== "textarea") return false;
+  const line = String(buffer.lines?.[buffer.cursor.y] ?? "");
+  if (buffer.cursor.x < line.length || buffer.cursor.y >= block.end - 1) return false;
+  const prefix = block.header.indent + block.header.bodyMarker + " ";
+  const nextLine = String(buffer.lines?.[buffer.cursor.y + 1] ?? "");
+  const body = nextLine.startsWith(prefix) ? nextLine.slice(prefix.length) : nextLine;
+  buffer.lines[buffer.cursor.y] += body;
+  spliceTuiBufferLines(buffer, buffer.cursor.y + 1, 1, []);
+  buffer.ensureCursor?.();
+  return true;
+}
+
 function _setBlockValue(buffer, selector, value) {
   const lines = buffer.lines;
   const block = _findBlock(lines, selector);
   if (!block) return false;
 
-  const values = String(value ?? "").replace(/\r\n?/g, "\n").split("\n");
+  const normalizedValue = String(value ?? "").replace(/\r\n?/g, "\n");
+  if ((_blockValue(lines, selector) ?? "") === normalizedValue) return true;
+  buffer.pushUndo?.(true);
+  const values = normalizedValue.split("\n");
   const contentStart = block.start + 1;
   const capacity = Math.max(0, block.end - contentStart);
 
   if (block.header.kind === "fenced") {
     const replacement = values.map((line) => block.header.indent + line);
-    _spliceBufferLines(buffer, contentStart, capacity, replacement);
+    spliceTuiBufferLines(buffer, contentStart, capacity, replacement);
     return true;
   }
 
   const rowPrefix = block.header.indent + block.header.bodyMarker + " ";
   const replacement = values.map((line) => rowPrefix + line);
-  _spliceBufferLines(buffer, contentStart, capacity, replacement);
+  spliceTuiBufferLines(buffer, contentStart, capacity, replacement);
   return true;
 }
 
@@ -1229,7 +1327,12 @@ export function buildMicroGlobal(jsManager) {
     // ── Messaging ─────────────────────────────────────────────────
     Log:         (...args) => console.log(...args),
     TermMessage: (msg) => { const app = getApp(); if (app) { app.message = String(msg); if (app._started) app.render?.(); } },
-    alert: async (msg) => { const app = getApp(); if (app) await app.runAlert(msg); else console.log(String(msg)); },
+    alert: (msg) => { const app = getApp(); return app ? app.protectedAlert(msg) : console.log(String(msg)); },
+    confirm: (msg) => { const app = getApp(); return app ? app.protectedConfirm(msg) : false; },
+    prompt: (msg, defaultValue = "") => {
+      const app = getApp();
+      return app ? app.protectedPrompt(msg, defaultValue) : defaultValue;
+    },
 
     // ── Buffer line access (1-based line numbers; omit → cursor line) ─
 
@@ -1250,6 +1353,7 @@ export function buildMicroGlobal(jsManager) {
       const y = lineNumber != null ? Number(lineNumber) - 1 : buf.cursor.y;
       if (y < 0 || y >= buf.lines.length) return;
       buf.pushUndo?.();
+      buf._mdcuiFenceBlockIndex = null;
       const parts = String(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
       buf.lines.splice(y, 1, ...parts);
       buf.invalidateHighlightFrom?.(y, { force: parts.length > 1 });
@@ -1266,6 +1370,7 @@ export function buildMicroGlobal(jsManager) {
       const y = lineNumber != null ? Number(lineNumber) - 1 : buf.cursor.y;
       if (y < 0 || y >= buf.lines.length) return;
       buf.pushUndo?.();
+      buf._mdcuiFenceBlockIndex = null;
       if (buf.lines.length === 1) {
         buf.lines[0] = "";
       } else {
@@ -1306,6 +1411,7 @@ export function buildMicroGlobal(jsManager) {
       if (!app?.buffer) return;
       const buf = app.buffer;
       buf.pushUndo?.();
+      buf._mdcuiFenceBlockIndex = null;
       buf.lines = String(text).replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
       if (buf.lines.length === 0) buf.lines = [""];
       buf.invalidateHighlightFrom?.(0, { force: true });

package/tests/fence-events.test.js

@@ -0,0 +1,405 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fenceEventMap, inlineFenceEventCode, parseFenceDeclarations } from "../src/cui/fence-events.mjs";
+import { evalFront } from "../src/cui/rpc.mjs";
+import { buildTuiBlockIndex, createTuiSelector, findTuiBlockAtLine, findTuiBlockInIndex, insertTuiTextareaNewline, mergeTuiTextareaBackward, mergeTuiTextareaForward } from "../src/plugins/js-bridge.js";
+import { convertWuiTextareas } from "../runmd.mjs";
+
+const tui = join(import.meta.dir, "..", "tui");
+const bunBin = Bun.which("bun") || process.argv0;
+
+async function waitFor(check, timeout = 5000) {
+  const deadline = Date.now() + timeout;
+  while (Date.now() < deadline) {
+    if (check()) return;
+    await Bun.sleep(20);
+  }
+  throw new Error("timed out waiting for PTY output");
+}
+
+test("fenced text controls retain quoted inline keydown code after the identity", () => {
+  const markdown = '```text#myid.field @keydown="first(); second(event); show(\\"done\\")"\nvalue\n```\n';
+  const declarations = parseFenceDeclarations(markdown);
+  expect(declarations).toHaveLength(1);
+  expect(declarations[0]).toMatchObject({
+    tag: "text",
+    id: "myid",
+    classes: ["field"],
+  });
+  expect(declarations[0].events.get("keydown")).toEqual({
+    code: 'first(); second(event); show("done")',
+    modifiers: [],
+  });
+});
+
+test("prevent modifier prepends preventDefault to inline event code", () => {
+  const markdown = '```text#myid @keydown.prevent="submit(event)"\nvalue\n```\n';
+  const handler = fenceEventMap(markdown).get("myid").events.get("keydown");
+  expect(handler).toEqual({ code: "submit(event)", modifiers: ["prevent"] });
+  expect(inlineFenceEventCode(handler)).toBe("event.preventDefault();submit(event)");
+});
+
+test("WUI writes keyboard code as native inline handlers with a mobile beforeinput fallback", () => {
+  const markdown = '```text#myid.field @keydown.prevent="guard(event)"\nvalue\n```\n';
+  const html = convertWuiTextareas(Bun.markdown.html(markdown), fenceEventMap(markdown));
+  expect(html).toContain('id="myid"');
+  expect(html).toContain('const __mdcuiKeyCode=Number(event.keyCode||event.which||0);');
+  expect(html).toContain('if(event.key!==&quot;Unidentified&quot;){\nObject.defineProperty(event,&quot;toJSON&quot;');
+  expect(html).toContain('event.preventDefault();guard(event)\n}"');
+  expect(html).toContain('onbeforeinput="if(!this.__mdcuiIdentifiedKeydown&amp;&amp;event.data!=null');
+  expect(html).toContain('ctrlKey:{configurable:true,value:!!m.ctrlKey}');
+  expect(html).toContain('metaKey:{configurable:true,value:!!m.metaKey}');
+  expect(html).not.toContain("onkeyup=");
+  expect(html).not.toContain("addEventListener");
+});
+
+test("keyup declarations are unsupported in both interfaces", () => {
+  const markdown = '```text#myid @keyup="update(event)"\nvalue\n```\n';
+  const declarations = parseFenceDeclarations(markdown);
+  const html = convertWuiTextareas(Bun.markdown.html(markdown), fenceEventMap(markdown));
+  expect(declarations[0].events.size).toBe(0);
+  expect(fenceEventMap(markdown).has("myid")).toBeFalse();
+  expect(html).not.toContain("onkeyup=");
+  expect(html).not.toContain("onkeydown=");
+});
+
+test("WUI keeps a trailing line comment inside the generated keydown block", () => {
+  const markdown = '```text#myid @keydown="guard(event); // trailing comment"\nvalue\n```\n';
+  const html = convertWuiTextareas(Bun.markdown.html(markdown), fenceEventMap(markdown));
+  const code = (html.match(/onkeydown="([^"]*)"/)?.[1] ?? "")
+    .replaceAll("&quot;", '"')
+    .replaceAll("&gt;", ">")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&amp;", "&");
+  expect(() => new Function("event", "guard", code)).not.toThrow();
+});
+
+test("WUI restores modifier letters from keyCode or code during keydown", () => {
+  const markdown = '```text#myid @keydown.prevent="guard(event)"\nvalue\n```\n';
+  const html = convertWuiTextareas(Bun.markdown.html(markdown), fenceEventMap(markdown));
+  const decodeAttribute = (value) => value
+    .replaceAll("&quot;", '"')
+    .replaceAll("&gt;", ">")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&amp;", "&");
+  const keydownCode = decodeAttribute(html.match(/onkeydown="([^"]*)"/)?.[1] ?? "");
+  const beforeInputCode = decodeAttribute(html.match(/onbeforeinput="([^"]*)"/)?.[1] ?? "");
+  const seen = [];
+  const element = {};
+  const runKeydown = new Function("event", "guard", keydownCode);
+  element.onkeydown = (event) => runKeydown.call(element, event, (current) => seen.push({
+    key: current.key,
+    ctrlKey: current.ctrlKey,
+    shiftKey: current.shiftKey,
+    altKey: current.altKey,
+    metaKey: current.metaKey,
+    json: JSON.parse(JSON.stringify(current)),
+    toJSONEnumerable: Object.keys(current).includes("toJSON"),
+  }));
+
+  const unidentified = {
+    key: "ß",
+    keyCode: 0,
+    code: "KeyS",
+    ctrlKey: true,
+    shiftKey: false,
+    altKey: true,
+    metaKey: true,
+    defaultPrevented: false,
+    preventDefault() { this.defaultPrevented = true; },
+  };
+  element.onkeydown(unidentified);
+  expect(unidentified.defaultPrevented).toBeTrue();
+  expect(unidentified.key).toBe("s");
+
+  const beforeInput = {
+    data: "β",
+    defaultPrevented: false,
+    preventDefault() { this.defaultPrevented = true; },
+  };
+  new Function("event", beforeInputCode).call(element, beforeInput);
+  expect(seen).toEqual([{
+    key: "s",
+    ctrlKey: true,
+    shiftKey: false,
+    altKey: true,
+    metaKey: true,
+    json: {
+      type: "",
+      key: "s",
+      code: "KeyS",
+      raw: "",
+      ctrlKey: true,
+      shiftKey: false,
+      altKey: true,
+      metaKey: true,
+      repeat: false,
+      defaultPrevented: true,
+      target: { id: "", tagName: "", className: "", value: "" },
+    },
+    toJSONEnumerable: false,
+  }]);
+  expect(beforeInput.key).toBeUndefined();
+  expect(beforeInput.defaultPrevented).toBeFalse();
+  clearTimeout(element.__mdcuiKeydownReset);
+});
+
+test("WUI beforeinput keeps composed text for AltGraph and unmodified input", () => {
+  const markdown = '```text#myid @keydown="guard(event)"\nvalue\n```\n';
+  const html = convertWuiTextareas(Bun.markdown.html(markdown), fenceEventMap(markdown));
+  const decodeAttribute = (value) => value
+    .replaceAll("&quot;", '"')
+    .replaceAll("&gt;", ">")
+    .replaceAll("&lt;", "<")
+    .replaceAll("&amp;", "&");
+  const keydownCode = decodeAttribute(html.match(/onkeydown="([^"]*)"/)?.[1] ?? "");
+  const beforeInputCode = decodeAttribute(html.match(/onbeforeinput="([^"]*)"/)?.[1] ?? "");
+  const seen = [];
+  const element = {};
+  const runKeydown = new Function("event", "guard", keydownCode);
+  element.onkeydown = (event) => runKeydown.call(element, event, current => seen.push(current.key));
+  const retry = (keydown, data) => {
+    element.onkeydown({ key: "Unidentified", ...keydown });
+    new Function("event", beforeInputCode).call(element, { data });
+  };
+
+  retry({ keyCode: 83, altKey: true, getModifierState: name => name === "AltGraph" }, "β");
+  retry({ keyCode: 83 }, "絲");
+
+  expect(seen).toEqual(["β", "絲"]);
+  clearTimeout(element.__mdcuiKeydownReset);
+});
+
+test("TUI finds the event target only while the cursor is inside the framed body", () => {
+  const lines = ["┌─ text#myid.field", "│ value", "└─"];
+  expect(findTuiBlockAtLine(lines, 0)).toBeNull();
+  expect(findTuiBlockAtLine(lines, 1)?.header).toMatchObject({ tag: "text", id: "myid" });
+  expect(findTuiBlockAtLine(lines, 2)).toBeNull();
+});
+
+test("TUI textarea val changes participate in undo and redo", () => {
+  const buffer = {
+    lines: ["┌─ textarea#field", "│ old", "└─"],
+    cursor: { x: 2, y: 1 },
+    undoStack: [],
+    redoStack: [],
+    pushUndo(force) {
+      expect(force).toBeTrue();
+      this.undoStack.push(this.lines.slice());
+      this.redoStack = [];
+    },
+    undo() {
+      this.redoStack.push(this.lines.slice());
+      this.lines = this.undoStack.pop();
+    },
+    redo() {
+      this.undoStack.push(this.lines.slice());
+      this.lines = this.redoStack.pop();
+    },
+    invalidateHighlightFrom() {},
+    ensureCursor() {},
+  };
+  const $ = createTuiSelector(() => buffer);
+
+  $("textarea#field").val("new\nrow");
+  expect($("textarea#field").val()).toBe("new\nrow");
+  buffer.undo();
+  expect($("textarea#field").val()).toBe("old");
+  buffer.redo();
+  expect($("textarea#field").val()).toBe("new\nrow");
+});
+
+test("TUI textarea Enter splits a body row and Backspace joins it", () => {
+  const buffer = {
+    lines: ["┌─ textarea#field", "│ abcd", "└─", "after"],
+    cursor: { x: 4, y: 1 },
+    _mdcuiFenceBlockIndex: { stale: true },
+    invalidateHighlightFrom() {},
+    ensureCursor() {},
+  };
+  const block = findTuiBlockAtLine(buffer.lines, buffer.cursor.y);
+
+  expect(insertTuiTextareaNewline(buffer, block)).toBeTrue();
+  expect(buffer.lines).toEqual([
+    "┌─ textarea#field",
+    "│ ab",
+    "│ cd",
+    "└─",
+    "after",
+  ]);
+  expect(buffer.cursor).toEqual({ x: 2, y: 2 });
+  expect(buffer._mdcuiFenceBlockIndex).toBeNull();
+
+  expect(mergeTuiTextareaBackward(buffer, findTuiBlockAtLine(buffer.lines, buffer.cursor.y))).toBeTrue();
+  expect(buffer.lines).toEqual(["┌─ textarea#field", "│ abcd", "└─", "after"]);
+  expect(buffer.cursor).toEqual({ x: 4, y: 1 });
+});
+
+test("TUI textarea Delete at line end joins the next body row", () => {
+  const buffer = {
+    lines: ["┌─ textarea#field", "│ ab", "│ cd", "└─", "after"],
+    cursor: { x: 4, y: 1 },
+    _mdcuiFenceBlockIndex: { stale: true },
+    _mdcuiControlBlockIndex: { stale: true },
+    invalidateHighlightFrom() {},
+    ensureCursor() {},
+  };
+  const block = findTuiBlockAtLine(buffer.lines, buffer.cursor.y);
+
+  expect(mergeTuiTextareaForward(buffer, block)).toBeTrue();
+  expect(buffer.lines).toEqual(["┌─ textarea#field", "│ abcd", "└─", "after"]);
+  expect(buffer.cursor).toEqual({ x: 4, y: 1 });
+  expect(buffer._mdcuiFenceBlockIndex).toBeNull();
+  expect(buffer._mdcuiControlBlockIndex).toBeNull();
+  expect(mergeTuiTextareaForward(buffer, findTuiBlockAtLine(buffer.lines, buffer.cursor.y))).toBeFalse();
+});
+
+test("TUI keyboard lookup indexes event blocks once and uses binary lookup", () => {
+  const lines = [
+    "heading",
+    "┌─ text#plain",
+    "│ no event",
+    "└─",
+    ...Array.from({ length: 5_000 }, (_, index) => `line ${index}`),
+    "┌─ text#target",
+    "│ event body",
+    "└─",
+  ];
+  const declarations = new Map([
+    ["target", { tag: "text", events: new Map([["keydown", { code: "hit()" }]]) }],
+  ]);
+  const blocks = buildTuiBlockIndex(lines, declarations);
+
+  expect(blocks).toHaveLength(1);
+  expect(blocks[0].header).toMatchObject({ tag: "text", id: "target" });
+  expect(findTuiBlockInIndex(blocks, lines.length - 2)).toBe(blocks[0]);
+  expect(findTuiBlockInIndex(blocks, 2)).toBeNull();
+});
+
+test("front evaluation exposes the TUI event scope to inline statements", async () => {
+  const seen = [];
+  const event = { key: "Enter" };
+  const result = await evalFront(
+    { record(value) { seen.push(value); } },
+    "record(event.key)",
+    { event },
+  );
+  expect(result).toBeUndefined();
+  expect(seen).toEqual(["Enter"]);
+});
+
+test("TUI keydown.prevent runs before editing and blocks text input", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-keydown-"));
+  const markdownPath = join(dir, "app.md");
+  const markdown = [
+    '```text#field @keydown.prevent="record(event)"',
+    "a",
+    "```",
+    "",
+    "```text#status",
+    "waiting",
+    "```",
+    "",
+    "```js front",
+    "export function record(event) {",
+    "  const data = JSON.parse(JSON.stringify(event));",
+    "  $('#status').val(`${data.key}:${data.target.id}:${data.target.value}:${data.defaultPrevented}:${Object.keys(event).includes('toJSON')}`);",
+    "}",
+    "```",
+    "",
+  ].join("\n");
+  let output = "";
+  let proc;
+  let terminal;
+  try {
+    await writeFile(markdownPath, markdown);
+    terminal = new Bun.Terminal({
+      cols: 60,
+      rows: 16,
+      data(_terminal, data) {
+        output += Buffer.from(data).toString();
+      },
+    });
+    proc = Bun.spawn({
+      cmd: [bunBin, tui, "+2:4", markdownPath],
+      cwd: dir,
+      terminal,
+      env: { ...process.env, TERM: "xterm-256color", COLUMNS: "60", LINES: "16" },
+    });
+    await waitFor(() => Bun.stripANSI(output).includes("waiting"));
+    terminal.write("x");
+    await waitFor(() => Bun.stripANSI(output).includes("x:field:a:true:false"));
+    terminal.write("\x11");
+    await Promise.race([proc.exited, Bun.sleep(2000)]);
+    expect(Bun.stripANSI(output)).toContain("x:field:a:true:false");
+  } finally {
+    if (proc && proc.exitCode == null) proc.kill();
+    terminal?.close();
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 10000);
+
+test("TUI keydown alert releases and restores terminal input", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-keydown-alert-"));
+  const markdownPath = join(dir, "app.md");
+  const markdown = [
+    '```text#field @keydown.prevent="celebrate(event)"',
+    "focus here",
+    "```",
+    "",
+    "```text#status",
+    "waiting",
+    "```",
+    "",
+    "```js front",
+    "export function celebrate(event) {",
+    "  if (event.key === 'x') {",
+    "    alert('KEYDOWN ALERT');",
+    "    $('#status').val('alert closed');",
+    "    return;",
+    "  }",
+    "  $('#status').val(`second input: ${event.key}`);",
+    "}",
+    "```",
+    "",
+  ].join("\n");
+  let output = "";
+  let proc;
+  let terminal;
+  try {
+    await writeFile(markdownPath, markdown);
+    terminal = new Bun.Terminal({
+      cols: 60,
+      rows: 16,
+      data(_terminal, data) {
+        output += Buffer.from(data).toString();
+      },
+    });
+    proc = Bun.spawn({
+      cmd: [bunBin, tui, "+2:4", markdownPath],
+      cwd: dir,
+      terminal,
+      env: { ...process.env, TERM: "xterm-256color", COLUMNS: "60", LINES: "16" },
+    });
+    await waitFor(() => Bun.stripANSI(output).includes("waiting"));
+    terminal.write("x");
+    await waitFor(() => Bun.stripANSI(output).includes("KEYDOWN ALERT"));
+    terminal.write("\r");
+    await waitFor(() => Bun.stripANSI(output).includes("alert closed"));
+    terminal.write("z");
+    await waitFor(() => Bun.stripANSI(output).includes("second input:z"));
+    terminal.write("\x11");
+    const exitCode = await Promise.race([
+      proc.exited,
+      Bun.sleep(2000).then(() => null),
+    ]);
+    expect(exitCode).toBe(0);
+    expect(Bun.stripANSI(output)).toContain("second input:z");
+  } finally {
+    if (proc && proc.exitCode == null) proc.kill();
+    terminal?.close();
+    await rm(dir, { recursive: true, force: true });
+  }
+}, 10000);

package/tests/id-collision.test.js

@@ -43,6 +43,17 @@ test("--check reports heading/fenced-block collisions with line details", async
   expect(output.lastIndexOf("FAILED")).toBeGreaterThan(output.lastIndexOf("Suggested fix"));
 });
 
+test("--check keeps fenced IDs that are followed by inline event attributes", async () => {
+  const result = await runCheck(
+    '## Write Status\n\n```text#write-status @keydown="refresh(); validate(event)"\nwaiting\n```\n',
+  );
+  const output = Bun.stripANSI(result.stdout.toString());
+  expect(result.exitCode).toBe(1);
+  expect(output).toContain("ID #write-status");
+  expect(output).toContain("Type: text fenced block");
+  expect(output).toContain('Source: ```text#write-status @keydown="refresh(); validate(event)"');
+});
+
 test("--check reports duplicate fenced-block IDs", async () => {
   const result = await runCheck("```text#myid\na\n```\n\n```textarea#myid\nb\n```\n");
   expect(result.exitCode).toBe(1);

package/tests/js-plugin-prompts.test.js

@@ -0,0 +1,46 @@
+import { expect, test } from "bun:test";
+import { buildMicroGlobal } from "../src/plugins/js-bridge.js";
+
+test("micro prompt APIs delegate and return synchronously", () => {
+  const previousMicro = globalThis.micro;
+  const previousSelector = globalThis.$;
+  const calls = [];
+  const app = {
+    protectedAlert(message) {
+      calls.push(["alert", message]);
+      return undefined;
+    },
+    protectedConfirm(message) {
+      calls.push(["confirm", message]);
+      return true;
+    },
+    protectedPrompt(message, defaultValue) {
+      calls.push(["prompt", message, defaultValue]);
+      return "answer";
+    },
+  };
+
+  try {
+    const micro = buildMicroGlobal({ _app: app, _ctx: null, on() {} });
+    const alertResult = micro.alert("hello");
+    const confirmResult = micro.confirm("continue?");
+    const promptResult = micro.prompt("name", "Ada");
+
+    expect(alertResult).toBeUndefined();
+    expect(confirmResult).toBe(true);
+    expect(promptResult).toBe("answer");
+    expect(alertResult?.then).toBeUndefined();
+    expect(confirmResult?.then).toBeUndefined();
+    expect(promptResult?.then).toBeUndefined();
+    expect(calls).toEqual([
+      ["alert", "hello"],
+      ["confirm", "continue?"],
+      ["prompt", "name", "Ada"],
+    ]);
+  } finally {
+    if (previousMicro === undefined) delete globalThis.micro;
+    else globalThis.micro = previousMicro;
+    if (previousSelector === undefined) delete globalThis.$;
+    else globalThis.$ = previousSelector;
+  }
+});

package/tests/key-event.md

@@ -0,0 +1,10 @@
+```text#myid @keydown.prevent="handle(event)"
+hello
+```
+
+```js front
+export function handle(e)
+{
+  alert(JSON.stringify(e,null,1))
+}
+```