jsmdcui 0.4.0 → 0.6.3

package/src/plugins/js-bridge.js

@@ -685,11 +685,293 @@ function _deleteSel(buf, pane) {
   buf.ensureCursor?.();
 }
 
+// ── mdcui block selector ────────────────────────────────────────────────────
+
+function _parseBlockIdentity(input, { selector = false } = {}) {
+  const text = String(input ?? "").trim();
+  const match = text.match(/^([A-Za-z_][\w:-]*)?(?:#([A-Za-z_][\w:-]*))?((?:\.[A-Za-z_][\w:-]*)*)$/);
+  if (!match || (!match[1] && !match[2] && !match[3])) return null;
+  if (!selector && !match[1]) return null;
+  return {
+    tag: match[1] || null,
+    id: match[2] || null,
+    classes: match[3] ? match[3].slice(1).split(".") : [],
+  };
+}
+
+function _blockHeader(line) {
+  const text = String(line ?? "");
+  const framed = text.match(/^(\s*)(┌─|╭─|\+-)\s*(\S+)\s*$/);
+  if (framed) {
+    const identity = _parseBlockIdentity(framed[3]);
+    return identity
+      ? { kind: "framed", indent: framed[1], bodyMarker: framed[2] === "+-" ? "|" : "│", ...identity }
+      : null;
+  }
+
+  const fenced = text.match(/^(\s*)(`{3,})\s*(\S+)\s*$/);
+  if (fenced) {
+    const identity = _parseBlockIdentity(fenced[3]);
+    return identity
+      ? { kind: "fenced", indent: fenced[1], fenceLength: fenced[2].length, ...identity }
+      : null;
+  }
+
+  return null;
+}
+
+function _matchesBlock(header, selector) {
+  if (selector.tag && header.tag !== selector.tag) return false;
+  if (selector.id && header.id !== selector.id) return false;
+  return selector.classes.every((name) => header.classes.includes(name));
+}
+
+function _findBlock(lines, selector) {
+  for (let start = 0; start < lines.length; start++) {
+    const header = _blockHeader(lines[start]);
+    if (!header || !_matchesBlock(header, selector)) continue;
+
+    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)
+          return { start, end: y, header };
+        continue;
+      }
+
+      if (/^(?:└─|╰─|\+-)\s*$/.test(rest))
+        return { start, end: y, header };
+    }
+    return { start, end: lines.length, header };
+  }
+  return null;
+}
+
+function _blockValue(lines, selector) {
+  const block = _findBlock(lines, selector);
+  if (!block) return undefined;
+  const value = [];
+  for (let y = block.start + 1; y < block.end; y++) {
+    const line = String(lines[y] ?? "");
+    const rest = line.startsWith(block.header.indent)
+      ? line.slice(block.header.indent.length)
+      : line;
+    if (block.header.kind === "fenced") value.push(rest);
+    else {
+      const body = rest.match(/^(?:│|\|)(?: ?)(.*)$/);
+      value.push(body ? body[1] : rest);
+    }
+  }
+  return value.join("\n");
+}
+
+function _headingSelectorId(input) {
+  const match = String(input ?? "").trim().match(/^#([^\s]+)$/);
+  return match?.[1] ?? null;
+}
+
+function _findHeading(buffer, selector) {
+  const id = _headingSelectorId(selector);
+  const markdown = buffer?._mdcuiTuiSourceText;
+  if (!id || markdown == null || typeof Bun?.markdown?.html !== "function") return undefined;
+
+  const html = String(Bun.markdown.html(markdown, { headings: { ids: true } }));
+  const headings = /<h([1-6])\b([^>]*)>([^]*?)<\/h\1\s*>/gi;
+  let match;
+  let ordinal = 0;
+  while ((match = headings.exec(html)) !== null) {
+    const headingId = match[2].match(/\bid="([^"]*)"/i)?.[1];
+    if (headingId === id) {
+      return {
+        html: match[3],
+        level: Number(match[1]),
+        ordinal,
+      };
+    }
+    ordinal++;
+  }
+  return undefined;
+}
+
+let _headingAnsiPrefixes;
+function _tuiHeadingAnsiPrefixes() {
+  if (_headingAnsiPrefixes) return _headingAnsiPrefixes;
+  const marker = "MDCUI_HEADING_LINE_PROBE";
+  _headingAnsiPrefixes = new Map();
+  for (let level = 1; level <= 6; level++) {
+    const rendered = String(Bun.markdown.ansi(
+      `${"#".repeat(level)} ${marker}`,
+      { hyperlinks: true, columns: 80 },
+    ));
+    const line = rendered.split("\n").find((item) => item.includes(marker));
+    if (line) _headingAnsiPrefixes.set(level, line.slice(0, line.indexOf(marker)));
+  }
+  return _headingAnsiPrefixes;
+}
+
+function _headingTuiLine(buffer, heading) {
+  const ansiText = buffer?._mdcuiAnsiText;
+  if (!heading || typeof ansiText !== "string") return 0;
+  const tuiHeadings = _tuiHeadingLines(buffer);
+  const exact = tuiHeadings[heading.ordinal];
+  if (exact?.level === heading.level) return exact.line;
+  return 0;
+}
+
+function _tuiHeadingLines(buffer) {
+  const ansiText = buffer?._mdcuiAnsiText;
+  if (typeof ansiText !== "string") return [];
+  const prefixes = _tuiHeadingAnsiPrefixes();
+  const tuiHeadings = [];
+  for (const [lineIndex, line] of ansiText.split("\n").entries()) {
+    for (const [level, prefix] of prefixes) {
+      if (line.startsWith(prefix)) {
+        tuiHeadings.push({ level, line: lineIndex + 1 });
+        break;
+      }
+    }
+  }
+  return tuiHeadings;
+}
+
+function _headingCheckboxValue(buffer, heading, id) {
+  const headingLine = _headingTuiLine(buffer, heading);
+  if (!headingLine || !Array.isArray(buffer?.lines))
+    return id.startsWith("select") ? null : [];
+
+  const tuiHeadings = _tuiHeadingLines(buffer);
+  const nextHeading = tuiHeadings[heading.ordinal + 1];
+  const endLine = nextHeading?.line ?? buffer.lines.length + 1;
+
+  let optionIndent = null;
+  const selected = [];
+  for (let lineNumber = headingLine + 1; lineNumber < endLine; lineNumber++) {
+    const line = String(buffer.lines[lineNumber - 1] ?? "");
+    const checkbox = line.match(/^(\s*)([☐☒])(?:\s+|$)(.*)$/);
+    if (!checkbox) continue;
+    const indent = checkbox[1].length;
+    if (optionIndent == null) optionIndent = indent;
+    if (indent !== optionIndent || checkbox[2] !== "☒") continue;
+    const value = checkbox[3].trim();
+    if (id.startsWith("select")) return value;
+    selected.push(value);
+  }
+  return id.startsWith("select") ? null : selected;
+}
+
+function _spliceBufferLines(buffer, start, deleteCount, replacement) {
+  const oldCursor = buffer.cursor ? { ...buffer.cursor } : null;
+  buffer.lines.splice(start, deleteCount, ...replacement);
+
+  if (Array.isArray(buffer._ansiStyleLines)) {
+    const template = buffer._ansiStyleLines[start] ?? null;
+    buffer._ansiStyleLines.splice(
+      start,
+      deleteCount,
+      ...replacement.map(() => template),
+    );
+  }
+
+  if (typeof buffer._mdcuiAnsiText === "string") {
+    const ansiLines = buffer._mdcuiAnsiText.split("\n");
+    ansiLines.splice(start, deleteCount, ...replacement);
+    buffer._mdcuiAnsiText = ansiLines.join("\n");
+  }
+
+  buffer.invalidateHighlightFrom?.(start, { force: replacement.length !== deleteCount });
+  if (oldCursor) {
+    const oldEnd = start + deleteCount;
+    if (oldCursor.y >= oldEnd) {
+      buffer.cursor.y = oldCursor.y + replacement.length - deleteCount;
+    } else if (oldCursor.y >= start) {
+      const relativeY = Math.min(oldCursor.y - start, Math.max(0, replacement.length - 1));
+      buffer.cursor.y = start + relativeY;
+    }
+  }
+  buffer.modified = true;
+  buffer.ensureCursor?.();
+}
+
+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 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);
+    return true;
+  }
+
+  const rowPrefix = block.header.indent + block.header.bodyMarker + " ";
+  const replacement = values.map((line) => rowPrefix + line);
+  _spliceBufferLines(buffer, contentStart, capacity, replacement);
+  return true;
+}
+
+export function createTuiSelector(getBuffer) {
+  return function $(selector) {
+    const parsedSelector = _parseBlockIdentity(selector, { selector: true });
+    const selection = {
+      html() {
+        try {
+          return _findHeading(getBuffer?.(), selector)?.html ?? "";
+        } catch {
+          return "";
+        }
+      },
+      line() {
+        try {
+          const buffer = getBuffer?.();
+          return _headingTuiLine(buffer, _findHeading(buffer, selector));
+        } catch {
+          return 0;
+        }
+      },
+      val(...args) {
+        try {
+          const buffer = getBuffer?.();
+          if (!buffer) return args.length > 0 ? selection : "";
+          const heading = _findHeading(buffer, selector);
+          const headingId = _headingSelectorId(selector);
+          if (heading && headingId) {
+            if (args.length > 0) return selection;
+            return _headingCheckboxValue(buffer, heading, headingId);
+          }
+          if (!parsedSelector) return args.length > 0 ? selection : "";
+          const lines = Array.isArray(buffer.lines)
+            ? buffer.lines
+            : String(buffer).replace(/\r\n?/g, "\n").split("\n");
+          if (args.length > 0) {
+            if (Array.isArray(buffer.lines))
+              _setBlockValue(buffer, parsedSelector, args[0]);
+            return selection;
+          }
+          return _blockValue(lines, parsedSelector) ?? "";
+        } catch {
+          return args.length > 0 ? selection : "";
+        }
+      },
+    };
+    return selection;
+  };
+}
+
 // ── micro global object ───────────────────────────────────────────────────────
 
 export function buildMicroGlobal(jsManager) {
   const getApp = () => jsManager._app;
   const getCtx = () => jsManager._ctx;
+  const $ = createTuiSelector(() => getApp()?.buffer);
 
   // Converts cmd args to a safe command string for handleCommand
   function buildCmdString(name, args) {
@@ -921,6 +1203,7 @@ export function buildMicroGlobal(jsManager) {
   };
 
   globalThis.micro = micro;
+  globalThis.$ = $;
   return micro;
 }
 

package/testapp.md

@@ -9,6 +9,20 @@
 - [Print process.argv](javascript:pav())
 - [Calculator🧮計算機](javascript:calc())
   * Use cos sin PI directly
+- [Show ↓ text](javascript:alert($('text').val()))
+
+```text
+Text edit. TUI: Click ↙ to inc lines ↖ to dec
+可編輯文字框 TUI：按↙擴充行數 ↖減少行數
+```
+## Question 問題
+- What is 1+2+3+4+..+..+∞
+
+```text#ans
+-1/12
+```
+- [Submit 提交](javascript:checkAns())
+
 ## Task list
 - [X] task1
 - [ ] task2
@@ -43,6 +57,15 @@ export async function calc()
     
   );
 }
+
+export function checkAns()
+{
+  if($('#ans').val().trim()=='-1/12')
+    $('#ans').val('答對🥳Right!');
+  else
+    $('#ans').val('答錯😫Wrong!');
+}
+
 ```
 
 

package/tests/demo.test.js

@@ -1,10 +1,24 @@
 import { expect, test } from "bun:test";
-import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 const tui = join(import.meta.dir, "..", "tui");
 
+test("--help describes the non-overwriting demo behavior", () => {
+  const result = Bun.spawnSync([tui, "--help"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  expect(result.exitCode).toBe(0);
+  const output = result.stdout.toString();
+  expect(output).toContain("use the existing ./testapp.md without overwriting it");
+  expect(output).toContain("If ./testapp.md is missing, write the bundled demo there first");
+  expect(output).toContain("--demo-imgtool");
+  expect(output).toContain("--demo-imgtool-zh");
+});
+
 test("--demo writes bundled testapp.md to cwd before opening it", async () => {
   const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-"));
   try {
@@ -22,3 +36,98 @@ test("--demo writes bundled testapp.md to cwd before opening it", async () => {
     await rm(dir, { recursive: true, force: true });
   }
 });
+
+test("--demo preserves an existing testapp.md", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-demo-existing-"));
+  const existing = "# Keep my demo\n";
+  try {
+    await writeFile(join(dir, "testapp.md"), existing);
+    const result = Bun.spawnSync([tui, "--demo", "-cat", "-encoding", "utf8"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(await readFile(join(dir, "testapp.md"), "utf8")).toBe(existing);
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("Keep my demo");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("--demo-imgtool writes the bundled image processor to cwd", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-imgtool-"));
+  try {
+    const result = Bun.spawnSync([tui, "--demo-imgtool", "-cat", "-encoding", "utf8"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    const written = await readFile(join(dir, "image-processor.md"), "utf8");
+    expect(written).toContain("# Bun.Image Processor");
+    expect(written).toContain("javascript:readMetadata()");
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("Bun.Image Processor");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("--demo-imgtool preserves an existing image-processor.md", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-imgtool-existing-"));
+  const existing = "# Keep my image tool\n";
+  try {
+    await writeFile(join(dir, "image-processor.md"), existing);
+    const result = Bun.spawnSync([tui, "--demo-imgtool", "-cat", "-encoding", "utf8"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(await readFile(join(dir, "image-processor.md"), "utf8")).toBe(existing);
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("Keep my image tool");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("--demo-imgtool-zh writes the bundled Traditional Chinese image processor to cwd", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-imgtool-zh-"));
+  try {
+    const result = Bun.spawnSync([tui, "--demo-imgtool-zh", "-cat", "-encoding", "utf8"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    const written = await readFile(join(dir, "image-processor.zh-TW.md"), "utf8");
+    expect(written).toContain("先把本機圖片路徑貼到下方");
+    expect(written).toContain("javascript:readMetadata()");
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("先把本機圖片路徑貼到下方");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("--demo-imgtool-zh preserves an existing image-processor.zh-TW.md", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-imgtool-zh-existing-"));
+  const existing = "# 保留我的圖片工具\n";
+  try {
+    await writeFile(join(dir, "image-processor.zh-TW.md"), existing);
+    const result = Bun.spawnSync([tui, "--demo-imgtool-zh", "-cat", "-encoding", "utf8"], {
+      cwd: dir,
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(await readFile(join(dir, "image-processor.zh-TW.md"), "utf8")).toBe(existing);
+    expect(Bun.stripANSI(result.stdout.toString())).toContain("保留我的圖片工具");
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});

package/tests/id-collision.test.js

@@ -0,0 +1,146 @@
+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 { createTuiSelector } from "../src/plugins/js-bridge.js";
+
+const tui = join(import.meta.dir, "..", "tui");
+
+async function runCheck(markdown) {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-check-"));
+  const file = join(dir, "app.md");
+  await writeFile(file, markdown);
+  const result = Bun.spawnSync([tui, "--check", file], { stdout: "pipe", stderr: "pipe" });
+  await rm(dir, { recursive: true, force: true });
+  return result;
+}
+
+test("--check exits 0 and reports unique IDs", async () => {
+  const result = await runCheck("## Input Path\n\n```text#output-path\nvalue\n```\n");
+  expect(result.exitCode).toBe(0);
+  const raw = result.stdout.toString();
+  const output = Bun.stripANSI(raw);
+  expect(output).toContain("No ID collisions found");
+  expect(output).toContain("PASSED");
+  expect(raw).toContain(`${Bun.color("#00d75f", "ansi-16m")}\x1b[1mPASSED\x1b[0m`);
+});
+
+test("--check reports heading/fenced-block collisions with line details", async () => {
+  const result = await runCheck("## Write Status\n\n```text#write-status\nwaiting\n```\n");
+  const output = Bun.stripANSI(result.stdout.toString());
+  expect(result.exitCode).toBe(1);
+  expect(output).toContain("FAIL — Found 1 colliding ID(s)");
+  expect(output).toContain("ID #write-status");
+  expect(output).toContain("Declarations: 2");
+  expect(output).toContain("Line 1");
+  expect(output).toContain("Type: heading");
+  expect(output).toContain("Source: ## Write Status");
+  expect(output).toContain("Line 3");
+  expect(output).toContain("Type: text fenced block");
+  expect(output).toContain("Source: ```text#write-status");
+  expect(result.stdout.toString()).toContain(`${Bun.color("#ff3030", "ansi-16m")}\x1b[1mFAILED\x1b[0m`);
+  expect(output.lastIndexOf("FAILED")).toBeGreaterThan(output.lastIndexOf("Suggested fix"));
+});
+
+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);
+  const output = Bun.stripANSI(result.stdout.toString());
+  expect(output).toContain("ID #myid");
+  expect(output).toContain("Declarations: 2");
+  expect(output).toContain("FAILED");
+});
+
+test("--check includes IDs on arbitrary fenced-block tags", async () => {
+  const result = await runCheck("```hello#myid\nyou\n```\n\n# myid\n");
+  const output = Bun.stripANSI(result.stdout.toString());
+  expect(result.exitCode).toBe(1);
+  expect(output).toContain("ID #myid");
+  expect(output).toContain("Declarations: 2");
+  expect(output).toContain("Type: hello fenced block");
+  expect(output).toContain("Fenced blocks: 1");
+  expect(output).toContain("FAILED");
+});
+
+test("--check rejects duplicate Markdown heading IDs before Bun adds suffixes", async () => {
+  const result = await runCheck("# myid\n\n# myid\n");
+  const output = Bun.stripANSI(result.stdout.toString());
+  expect(result.exitCode).toBe(1);
+  expect(output).toContain("ID #myid");
+  expect(output).toContain("Declarations: 2");
+  expect(output).toContain("Line 1");
+  expect(output).toContain("Line 3");
+  expect(output).toContain("FAILED");
+});
+
+const identityMatrix = [
+  {
+    name: "tag without class",
+    info: "text#myid",
+    selectable: true,
+  },
+  {
+    name: "tag with class",
+    info: "text#myid.field",
+    selectable: true,
+  },
+  {
+    name: "no tag and no class",
+    info: "#myid",
+    selectable: false,
+  },
+  {
+    name: "no tag with class",
+    info: "#myid.field",
+    selectable: false,
+  },
+];
+
+for (const scenario of identityMatrix) {
+  test(`--check identity matrix: ${scenario.name}`, async () => {
+    const result = await runCheck(`\`\`\`${scenario.info}\nvalue\n\`\`\`\n\n# myid\n`);
+    const output = Bun.stripANSI(result.stdout.toString());
+    expect(result.exitCode).toBe(scenario.selectable ? 1 : 0);
+    expect(output).toContain(`Fenced blocks: ${scenario.selectable ? 1 : 0}`);
+    if (scenario.selectable) {
+      expect(output).toContain("ID #myid");
+      expect(output).toContain("Declarations: 2");
+      expect(output).toContain("FAILED");
+    } else {
+      expect(output).toContain("Selectable IDs: 1");
+      expect(output).toContain("PASSED");
+    }
+  });
+}
+
+test("--check ignores tag and class differences when fenced-block IDs collide", async () => {
+  const result = await runCheck(
+    "```text#myid.left.primary\na\n```\n\n```json#myid.right.secondary\nb\n```\n",
+  );
+  const output = Bun.stripANSI(result.stdout.toString());
+  expect(result.exitCode).toBe(1);
+  expect(output).toContain("ID #myid");
+  expect(output).toContain("Declarations: 2");
+  expect(output).toContain("Type: text fenced block");
+  expect(output).toContain("Type: json fenced block");
+  expect(output).toContain("FAILED");
+});
+
+test("TUI $ selector finds one ID across every tag/class query combination", () => {
+  const markdown = "```text#myid.field.primary\nvalue\n```\n";
+  const buffer = { lines: markdown.trimEnd().split("\n") };
+  const $ = createTuiSelector(() => buffer);
+  const selectors = [
+    "text#myid.field",
+    "text#myid",
+    "#myid.field",
+    "#myid",
+  ];
+  for (const selector of selectors) expect($(selector).val()).toBe("value");
+});
+
+test("--check requires exactly one file", () => {
+  const result = Bun.spawnSync([tui, "--check"], { stdout: "pipe", stderr: "pipe" });
+  expect(result.exitCode).toBe(2);
+  expect(result.stderr.toString()).toContain("Usage: jsmdcui --check FILE.md");
+});

package/tests/wui.test.js

@@ -0,0 +1,30 @@
+import { expect, test } from "bun:test";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { readMarkdownInput } from "../runmd.mjs";
+
+test("WUI writes the bundled testapp.md when it is missing", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-"));
+  const mdpath = join(dir, "testapp.md");
+  try {
+    const source = await readMarkdownInput(mdpath);
+    expect(source).toContain("# jsmdcui");
+    expect(await readFile(mdpath, "utf8")).toBe(source);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("WUI preserves an existing testapp.md", async () => {
+  const dir = await mkdtemp(join(tmpdir(), "jsmdcui-wui-existing-"));
+  const mdpath = join(dir, "testapp.md");
+  const existing = "# Keep my WUI demo\n";
+  try {
+    await writeFile(mdpath, existing);
+    expect(await readMarkdownInput(mdpath)).toBe(existing);
+    expect(await readFile(mdpath, "utf8")).toBe(existing);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});