jsmdcui 0.5.0 → 0.6.3

package/src/index.js

@@ -98,6 +98,8 @@ import { mkdir } from "node:fs/promises";
 import { dirname, basename, join, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import process from "node:process";
+import { toggleTaskCheckboxBeforeColumn } from "./cui/task-checkbox.mjs";
+import { checkMarkdownIdCollisions, formatMarkdownIdCheckAnsi } from "./cui/id-collision.mjs";
 import { Config } from "./config/config.js";
 import { defaultAllSettings, OPTION_CHOICES, LOCAL_SETTINGS } from "./config/defaults.js";
 import { cleanConfig } from "./config/clean.js";
@@ -947,11 +949,16 @@ function parseArgs(argv) {
     options: false,
     help: false,
     clean: false,
+    check: false,
     cat: false,
     docs: false,
+    exportReadme: false,
     changelog: false,
     testapp: false,
     demo: false,
+    demoSelect: false,
+    demoImgtool: false,
+    demoImgtoolZh: false,
     allowUrl: false,
     buildExe: false,
     buildFor: "",
@@ -971,6 +978,7 @@ function parseArgs(argv) {
     else if (arg === "-options") flags.options = true;
     else if (arg === "-help" || arg === "--help" || arg === "-h") flags.help = true;
     else if (arg === "-clean") flags.clean = true;
+    else if (arg === "--check") flags.check = true;
     else if (arg === "--cat" || arg === "-cat" || arg === "--ccat" || arg === "-ccat" || arg === "--bat" || arg === "-bat" || arg === "--glow" || arg === "-glow") flags.cat = true;
     else if (arg === "--xxd" || arg === "--hexdump") {
       flags.cat = true;
@@ -989,9 +997,13 @@ function parseArgs(argv) {
       flags.settings.set("encoding", "utf-8");
     }
     else if (arg === "--docs" || arg === "--readme") flags.docs = true;
+    else if (arg === "--export-readme") flags.exportReadme = true;
     else if (arg === "--changelog") flags.changelog = true;
     else if (arg === "--testapp.md") flags.testapp = true;
     else if (arg === "--demo") flags.demo = true;
+    else if (arg === "--demo-select") flags.demoSelect = true;
+    else if (arg === "--demo-imgtool") flags.demoImgtool = true;
+    else if (arg === "--demo-imgtool-zh") flags.demoImgtoolZh = true;
     else if (arg === "--allow-url") flags.allowUrl = true;
     else if (arg === "--build-exe") flags.buildExe = true;
     else if (arg === "--build-for") flags.buildFor = argv[++i] ?? "";
@@ -1024,9 +1036,13 @@ function usage() {
   ${pkg.name} --wui [FILE.md]
 
 Modes:
+  --check FILE.md
+      Check heading and fenced-block IDs for collisions, print details, and exit
+      Exits 0 when IDs are unique, 1 on collisions, and 2 on usage/read errors
   --wui [FILE.md]
       Generate or overwrite Markdown UI files beside FILE.md and start the server
-      Without FILE.md, use testapp.md and write generated files in the current directory
+      Without FILE.md, use the existing ./testapp.md without overwriting it
+      If ./testapp.md is missing, write the bundled demo there first
   --cat, --ccat, --bat, --glow
       Render file(s) and write to stdout, then exit (.md uses mdcui/createTui)
       A local .md file also writes or overwrites five generated files beside it
@@ -1060,6 +1076,8 @@ Information:
       Show version+backend info & exit
   --docs, --readme
       Show ${pkg.name}'s README.md & exit
+  --export-readme
+      Write or overwrite ./README.md with the bundled README.md & exit
   --changelog
       Show CHANGELOG.md & exit
   -profile, --profile
@@ -1069,7 +1087,17 @@ Demo:
   --testapp.md
       Write the bundled testapp.md to stdout & exit
   --demo
-      Outputs & overwrites ./testapp.md, opens it in the TUI, and writes 5 generated files
+      Use the existing ./testapp.md without overwriting it, or write the bundled demo if missing
+      Open it in the TUI and write 5 generated files beside it
+  --demo-select
+      Use the existing ./select.md without overwriting it, or write the bundled demo if missing
+      Open it in the TUI and write 5 generated files beside it
+  --demo-imgtool
+      Use the existing ./image-processor.md without overwriting it, or write the bundled demo if missing
+      Open the Bun.Image processor in the TUI and write 5 generated files beside it
+  --demo-imgtool-zh
+      Use the existing ./image-processor.zh-TW.md without overwriting it, or write the bundled demo if missing
+      Open the Traditional Chinese Bun.Image processor in the TUI and write 5 generated files beside it
 
 Remote Markdown:
   --allow-url
@@ -4062,6 +4090,12 @@ class App {
           return true;
         }
       }
+
+      const checkboxResult = toggleTaskCheckboxBeforeColumn(payload.line, x);
+      if (checkboxResult.toggled) {
+        buf.lines[y] = checkboxResult.line;
+        buf.modified = true;
+      }
     
       this.message = `event ${payload.trigger}:`+
       `(${payload.row},${payload.col})`+
@@ -7498,8 +7532,17 @@ async function loadBuffers(files, command) {
 }
 
 async function printReadmeDocs() {
-  const readme = readInternalAssetText("README.md") ?? await Bun.file(join(REPO_ROOT, "README.md")).text();
-  process.stdout.write(Bun.markdown.ansi(readme, { hyperlinks: true }));
+  process.stdout.write(Bun.markdown.ansi(await bundledReadmeSource(), { hyperlinks: true }));
+}
+
+async function bundledReadmeSource() {
+  return readInternalAssetText("README.md") ?? await Bun.file(join(REPO_ROOT, "README.md")).text();
+}
+
+async function exportReadme() {
+  const readmePath = resolve("README.md");
+  await Bun.write(readmePath, await bundledReadmeSource());
+  console.log(`Wrote ${readmePath}`);
 }
 
 async function printChangelogDocs() {
@@ -7508,11 +7551,11 @@ async function printChangelogDocs() {
 }
 
 async function printTestappSource() {
-  process.stdout.write(await bundledTestappSource());
+  process.stdout.write(await bundledMarkdownSource("testapp.md"));
 }
 
-async function bundledTestappSource() {
-  return readInternalAssetText("testapp.md") ?? await Bun.file(join(REPO_ROOT, "testapp.md")).text();
+async function bundledMarkdownSource(filename) {
+  return readInternalAssetText(filename) ?? await Bun.file(join(REPO_ROOT, filename)).text();
 }
 
 async function main() {
@@ -7558,10 +7601,33 @@ async function main() {
     console.log("Clipboard:", backends);
     return;
   }
+  if (flags.check) {
+    if (rawFiles.length !== 1) {
+      console.error("Usage: jsmdcui --check FILE.md");
+      process.exitCode = 2;
+      return;
+    }
+    const checkPath = resolve(rawFiles[0]);
+    try {
+      const file = Bun.file(checkPath);
+      if (!(await file.exists())) throw new Error("file not found");
+      const result = checkMarkdownIdCollisions(await file.text());
+      process.stdout.write(formatMarkdownIdCheckAnsi(checkPath, result));
+      if (result.collisions.length) process.exitCode = 1;
+    } catch (error) {
+      console.error(`Cannot check ${checkPath}: ${error?.message || error}`);
+      process.exitCode = 2;
+    }
+    return;
+  }
   if (flags.docs) {
     await printReadmeDocs();
     return;
   }
+  if (flags.exportReadme) {
+    await exportReadme();
+    return;
+  }
   if (flags.changelog) {
     await printChangelogDocs();
     return;
@@ -7570,9 +7636,20 @@ async function main() {
     await printTestappSource();
     return;
   }
-  if (flags.demo) {
-    const demoPath = resolve("testapp.md");
-    await Bun.write(demoPath, await bundledTestappSource());
+  const demoFilename = flags.demo
+    ? "testapp.md"
+    : flags.demoSelect
+      ? "select.md"
+      : flags.demoImgtool
+        ? "image-processor.md"
+        : flags.demoImgtoolZh
+          ? "image-processor.zh-TW.md"
+          : "";
+  if (demoFilename) {
+    const demoPath = resolve(demoFilename);
+    if (!(await Bun.file(demoPath).exists())) {
+      await Bun.write(demoPath, await bundledMarkdownSource(demoFilename));
+    }
     rawFiles.splice(0, rawFiles.length, demoPath);
   }
   if (flags.options) {

package/src/plugins/js-bridge.js

@@ -770,6 +770,100 @@ function _blockValue(lines, selector) {
   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);
@@ -828,11 +922,32 @@ 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 {
-          if (!parsedSelector) return args.length > 0 ? selection : "";
           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");

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 });
+  }
+});