@sirux/md-press 0.1.0 → 0.2.0

package/README.md

@@ -10,23 +10,25 @@ Press Markdown into clean pages. Pure code: no AI, no tokens, no build setup.
 npm install -g @sirux/md-press
 md-press notes.md           # build notes.html, a page you can share anywhere
 md-press serve notes.md     # open notes.md live, checkboxes save into the file
+md-press board backlog.md   # open backlog.md as a Kanban board that writes back to it
 ```
 
 ## Why
 
-Notes, plans, and trackers live best as Markdown. They read best as a page. md-press gives the file a better view without taking it away from you. The file stays the source of truth, readable and editable by people, editors, and agents alike.
+Notes, plans, and trackers live best as Markdown. They read best as a page, and a backlog works best as a board. md-press gives the file a better view without taking it away from you. The file stays the source of truth, readable and editable by people, editors, and agents alike.
 
-## Two ways to use it
+## Three ways to use it
 
 ### Build: a page to share
 
 ```sh
-md-press notes.md                  # writes notes.html next to notes.md
-md-press docs/*.md --out pages     # builds many files into one folder
-npx @sirux/md-press notes.md       # runs without installing
+md-press notes.md                   # writes notes.html next to notes.md
+md-press docs --out pages           # builds every .md in docs/, keeping its folders
+md-press - < notes.md > notes.html  # reads standard input, writes standard output
+npx @sirux/md-press notes.md        # runs without installing
 ```
 
-You get one HTML file with its styles and scripts inlined, ready to open, send, print, or host anywhere. Checklist progress on a built page is saved in the viewer's browser.
+You get one HTML file with its styles, scripts, and images inlined, ready to open, send, print, or host anywhere. Links to other `.md` files point at the pages they become. Checklist progress on a built page is saved in the viewer's browser.
 
 ### Serve: a live page for working
 
@@ -43,13 +45,45 @@ Opens `notes.md` at `http://localhost:5180`.
 
 Stop it with Ctrl+C.
 
+### Board: a live Kanban board
+
+```sh
+md-press board backlog.md
+```
+
+Opens `backlog.md` as a board at `http://localhost:5180`. Nothing about the file has to change to make it one:
+
+```markdown
+# Launch backlog
+
+## Todo
+- [ ] Write the announcement `docs`
+- [ ] Fix the login redirect `bug` `p1`
+  - happens only with single sign-on
+
+## Doing
+- [ ] Ship 0.2 `release`
+
+## Done
+- [x] Set up CI `ops`
+```
+
+- **`##` headings are columns.** The `- [ ]` items directly under one are its cards. Indented lines under a card are its notes and move with it.
+- **Trailing `` `code` `` spans are tags.** They get a color from their name. Click a tag at the top to filter the board.
+- **Drag a card** to another column or position, or pick a column from the arrow menu on the card. Only the card's own lines move in the file. Move it back and the file is byte for byte what it was.
+- **The last column counts as done.** A card moved into it is checked, a card moved out is unchecked. Tick a card's box to check it where it is. A board with a single column has no done column.
+- **Add a card** by typing at the bottom of a column. It becomes a `- [ ]` line there.
+- **Same server, same rules as serve.** The board reloads when the file changes, a stale save is refused, and writes are atomic. `/page` shows the reading view of the same file, and `md-press serve` has `/board`.
+
+Try it on [`examples/backlog.md`](examples/backlog.md).
+
 ## Options
 
 | Option | Mode | What it does |
 | --- | --- | --- |
-| `--out <folder>` | build | Writes pages into this folder instead of next to each file |
-| `--port <number>` | serve | Port to start from. Default 5180, and the next 9 are tried if it is busy |
-| `--no-open` | serve | Does not open the browser |
+| `--out <folder>` | build | Writes pages into this folder instead of next to each file. A folder given as input keeps its structure |
+| `--port <number>` | serve, board | Port to start from. Default 5180, and the next 9 are tried if it is busy |
+| `--no-open` | serve, board | Does not open the browser |
 | `-v`, `--version` | any | Shows the version |
 | `-h`, `--help` | any | Shows help |
 
@@ -58,10 +92,14 @@ Stop it with Ctrl+C.
 ## What every page gets
 
 - **Light and dark mode** that follow the system setting, plus clean print styles.
-- **Readable on phones.** Wide tables and code scroll inside themselves, never the page.
-- **Code highlighting**, done when the page is made, so pages stay fast.
+- **Readable on phones.** Wide tables and code scroll inside themselves, long links and words wrap, and the page itself never scrolls sideways.
+- **Code highlighting**, done when the page is made, so pages stay fast. Every block has a Copy button.
 - **Checklists.** `- [ ]` items become real checkboxes with a progress bar.
-- **Smart titles.** Uses frontmatter `title:`, then the first `#` heading, then the file name.
+- **Anchor links.** Every heading gets a GitHub-style id, so `[see below](#install)` and hand-written tables of contents work.
+- **Callouts.** `> [!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, and `[!CAUTION]` render the way GitHub shows them.
+- **Footnotes.** `[^1]` in the text, `[^1]: The note` anywhere in the file.
+- **Table alignment** from `:---:` and `---:`.
+- **Smart titles.** Uses frontmatter `title:`, then the first `#` heading (underlined headings count too), then the first heading of any level, then the file name. A `#` inside a code block is never a title.
 - **Diagrams.** ` ```mermaid ` blocks render as diagrams. This is the only feature that loads anything from the network, and only on pages that have a diagram. Offline, the diagram source shows instead.
 
 See [`examples/showcase.md`](examples/showcase.md) for every feature on one page. Try it both ways.
@@ -72,26 +110,35 @@ See [`examples/showcase.md`](examples/showcase.md) for every feature on one page
 ---
 title: Q4 launch plan
 description: Owners, dates, and open risks
+lang: th
 ---
 ```
 
-`title` sets the browser tab title. `description` sets the page's meta description. Other keys are ignored for now.
+`title` sets the browser tab title. `description` sets the page's meta description. `lang` sets the page language, which browsers use for line breaking and fonts; the default is `en`. Other keys are ignored for now.
 
 ## Use it from code
 
 ```js
-const { renderPage, buildFile } = require("@sirux/md-press");
+const { renderPage, buildFile, parseBoard, moveCard, addCard } = require("@sirux/md-press");
 
 const html = renderPage("# Hello\n\n- [ ] Ship it", "hello.md");
 buildFile("notes.md", "pages");
+
+const board = parseBoard(backlogText);                              // { title, columns: [{ title, cards }] }
+const moved = moveCard(backlogText, { column: 0, index: 1 }, { column: 2, index: 0 });
+const added = addCard(backlogText, 0, "Write the announcement `docs`");
 ```
 
+`renderDocument` returns the page with its title and task counts. `moveCard` and `addCard` return the new file text and change nothing but the lines involved.
+
 ## Good to know
 
-- **Built pages save progress per browser**, keyed by file name. Only `serve` writes to the file.
-- **A served page is read-only if md-press cannot match every checkbox to its line**, for example when a task sits inside an indented code block. It says so in the toolbar rather than risk editing the wrong line.
+- **Built pages save progress per browser**, keyed by file name. Only `serve` and `board` write to the file.
+- **Images are inlined up to 4 MB each.** Bigger or missing ones stay as links, and the build says so.
+- **A served page is read-only if md-press cannot match every checkbox to its line**, for example when a task sits inside an indented code block. It says so in the toolbar, and the terminal says how many task lines and checkboxes it found.
+- **On a board, only top-level `- [ ]` items under `##` headings are cards.** Tasks before the first `##` heading and nested tasks show on the page but not on the board.
 - **Raw HTML is kept**, so `<kbd>` and `<details>` work. To show a tag as text, wrap it in backticks. Only press or serve files you trust, the same as opening any HTML file.
-- **`serve` answers only this computer.** It is not reachable from your phone or network.
+- **`serve` and `board` answer only this computer.** They are not reachable from your phone or network.
 - **The package is `@sirux/md-press`, the command is `md-press`.** npm reserves plain `md-press` because it is close to an older, unrelated package.
 - **Requires Node 20 or newer.**
 

package/bin/md-press.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 /*
-Command line entry for md-press. Two modes share one parser for options:
-"build" (the default, so a bare file list builds pages) and "serve", which
-opens one file as a live page on localhost. The command stays thin; all
-behavior worth testing lives in src/.
+Command line entry for md-press. Three modes share one parser for options:
+"build" (the default, so a bare file list builds pages), "serve", which
+opens one file as a live page on localhost, and "board", which opens it as a
+live Kanban board on the same server. The command stays thin; all behavior
+worth testing lives in src/.
 */
 
 const fileSystem = require("fs");
+const path = require("path");
 const { spawn } = require("child_process");
-const { buildFile } = require("../src/build.js");
+const { buildFile, renderPage } = require("../src/build.js");
 const { startServer } = require("../src/serve.js");
 const { version } = require("../package.json");
 
@@ -16,15 +18,23 @@ const usageText = `md-press ${version}
 Press Markdown into clean pages, to share or to work in.
 
 Usage:
-  md-press <file.md> [more.md ...] [--out folder]   Build static pages
-  md-press serve <file.md> [--port 5180]            Open a live page that saves checkboxes to the file
+  md-press <file.md|folder> [more ...] [--out folder]   Build static pages
+  md-press - < notes.md > notes.html                     Build from standard input
+  md-press serve <file.md> [--port 5180]                 Open a live page that saves checkboxes to the file
+  md-press board <file.md> [--port 5180]                 Open the file as a live Kanban board
 
 Options:
   --out <folder>   Build: write pages into this folder instead of next to each file
-  --port <number>  Serve: port to start from (default 5180, tries the next 9 if busy)
-  --no-open        Serve: do not open the browser
+  --port <number>  Serve, board: port to start from (default 5180, tries the next 9 if busy)
+  --no-open        Serve, board: do not open the browser
   -v, --version    Show the version
-  -h, --help       Show this help`;
+  -h, --help       Show this help
+
+A folder builds every .md file inside it, subfolders included. With --out,
+the folder's structure is kept.
+
+On a board, ## headings are columns, top-level - [ ] items are cards, and
+trailing \`code\` spans are tags. Moving a card moves its lines in the file.`;
 
 function exitWithError(message) {
   console.error(`md-press: ${message}`);
@@ -35,7 +45,7 @@ function exitWithError(message) {
 /*
 Splits raw arguments into file paths and options. Options that do not apply
 to the chosen mode, and unknown flags, are rejected rather than silently
-ignored or treated as file names.
+ignored or treated as file names. A lone "-" means standard input.
 */
 function readArguments(rawArguments, mode) {
   const sourcePaths = [];
@@ -53,14 +63,14 @@ function readArguments(rawArguments, mode) {
       if (!nextArgument || nextArgument.startsWith("-")) exitWithError("--out needs a folder name");
       options.outputFolder = nextArgument;
       index += 1;
-    } else if (argument === "--port" && mode === "serve") {
+    } else if (argument === "--port" && mode !== "build") {
       const port = Number(nextArgument);
       if (!Number.isInteger(port) || port < 1 || port > 65535) exitWithError("--port needs a number from 1 to 65535");
       options.port = port;
       index += 1;
-    } else if (argument === "--no-open" && mode === "serve") {
+    } else if (argument === "--no-open" && mode !== "build") {
       options.openBrowser = false;
-    } else if (argument.startsWith("-")) {
+    } else if (argument.startsWith("-") && argument !== "-") {
       exitWithError(`unknown option ${argument} for ${mode}`);
     } else {
       sourcePaths.push(argument);
@@ -73,22 +83,90 @@ function isReadableFile(filePath) {
   return fileSystem.existsSync(filePath) && fileSystem.statSync(filePath).isFile();
 }
 
+function isFolder(filePath) {
+  return fileSystem.existsSync(filePath) && fileSystem.statSync(filePath).isDirectory();
+}
+
+function pagePathFor(sourcePath) {
+  return path.join(path.dirname(sourcePath), path.basename(sourcePath, path.extname(sourcePath)) + ".html");
+}
+
+/*
+Every Markdown file in a folder and its subfolders, in a stable order.
+Dotfolders and node_modules are skipped.
+*/
+function findMarkdownFiles(folder) {
+  const found = [];
+  const entries = fileSystem.readdirSync(folder, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+    const entryPath = path.join(folder, entry.name);
+    if (entry.isDirectory()) found.push(...findMarkdownFiles(entryPath));
+    else if (entry.isFile() && /\.(md|markdown)$/i.test(entry.name)) found.push(entryPath);
+  }
+  return found;
+}
+
+/*
+Works out which page each input becomes before anything is written. Files
+named on the command line go flat into --out; files found inside a folder
+keep their path under it. Two inputs that would write the same page stop
+the build, because the second would silently replace the first.
+*/
+function planBuild(sourcePaths, outputFolder) {
+  const jobs = [];
+  for (const sourcePath of sourcePaths) {
+    if (isFolder(sourcePath)) {
+      const files = findMarkdownFiles(sourcePath);
+      if (files.length === 0) {
+        console.error(`Skipped ${sourcePath}: no Markdown files in it`);
+        process.exitCode = 1;
+      }
+      for (const filePath of files) {
+        const outputPath = outputFolder ? path.join(outputFolder, path.relative(sourcePath, pagePathFor(filePath))) : pagePathFor(filePath);
+        jobs.push({ sourcePath: filePath, outputPath });
+      }
+    } else if (isReadableFile(sourcePath)) {
+      const outputPath = outputFolder ? path.join(outputFolder, path.basename(pagePathFor(sourcePath))) : pagePathFor(sourcePath);
+      jobs.push({ sourcePath, outputPath });
+    } else {
+      console.error(`Skipped ${sourcePath}: file not found`);
+      process.exitCode = 1;
+    }
+  }
+
+  const sourcesByOutput = new Map();
+  for (const job of jobs) {
+    const key = path.resolve(job.outputPath);
+    sourcesByOutput.set(key, [...(sourcesByOutput.get(key) || []), job.sourcePath]);
+  }
+  for (const [outputPath, sources] of sourcesByOutput) {
+    if (sources.length > 1) {
+      exitWithError(`${sources.join(" and ")} would both write ${path.relative(process.cwd(), outputPath)}. Build them into different folders or rename one.`);
+    }
+  }
+  return jobs;
+}
+
 function runBuild(rawArguments) {
   const { sourcePaths, options } = readArguments(rawArguments, "build");
   if (sourcePaths.length === 0) {
     console.log(usageText);
     process.exit(1);
   }
-  if (options.outputFolder) fileSystem.mkdirSync(options.outputFolder, { recursive: true });
+  if (sourcePaths.includes("-")) {
+    if (sourcePaths.length > 1) exitWithError("- (standard input) must be the only input");
+    if (options.outputFolder) exitWithError("--out does not apply when reading standard input; the page goes to standard output");
+    process.stdout.write(renderPage(fileSystem.readFileSync(0, "utf8"), "-"));
+    return;
+  }
 
-  for (const sourcePath of sourcePaths) {
-    if (!isReadableFile(sourcePath)) {
-      console.error(`Skipped ${sourcePath}: file not found`);
-      process.exitCode = 1;
-      continue;
-    }
-    const outputPath = buildFile(sourcePath, options.outputFolder);
-    console.log(`${sourcePath} -> ${outputPath}`);
+  for (const job of planBuild(sourcePaths, options.outputFolder)) {
+    const outputPath = buildFile(job.sourcePath, null, {
+      outputPath: job.outputPath,
+      onWarning: (message) => console.error(`${job.sourcePath}: ${message}`),
+    });
+    console.log(`${job.sourcePath} -> ${outputPath}`);
   }
 }
 
@@ -107,16 +185,18 @@ function openInBrowser(url) {
   child.unref();
 }
 
-async function runServe(rawArguments) {
-  const { sourcePaths, options } = readArguments(rawArguments, "serve");
-  if (sourcePaths.length !== 1) exitWithError("serve takes exactly one Markdown file");
+async function runServe(rawArguments, mode) {
+  const { sourcePaths, options } = readArguments(rawArguments, mode);
+  if (sourcePaths.length !== 1 || sourcePaths[0] === "-") exitWithError(`${mode} takes exactly one Markdown file`);
   const [sourcePath] = sourcePaths;
   if (!isReadableFile(sourcePath)) exitWithError(`${sourcePath}: file not found`);
 
   try {
-    const { url } = await startServer(sourcePath, { port: options.port });
-    console.log(`Serving ${sourcePath} at ${url}`);
-    console.log("Checkbox changes save to the file. Press Ctrl+C to stop.");
+    const { url } = await startServer(sourcePath, { port: options.port, mode });
+    console.log(`Serving ${sourcePath} as a ${mode} at ${url}`);
+    console.log(mode === "board"
+      ? "Moving cards and ticking boxes save to the file. Press Ctrl+C to stop."
+      : "Checkbox changes save to the file. Press Ctrl+C to stop.");
     if (options.openBrowser) openInBrowser(url);
   } catch (error) {
     exitWithError(`could not start the server: ${error.message}`);
@@ -125,7 +205,8 @@ async function runServe(rawArguments) {
 
 function main() {
   const rawArguments = process.argv.slice(2);
-  if (rawArguments[0] === "serve") return runServe(rawArguments.slice(1));
+  if (rawArguments[0] === "serve") return runServe(rawArguments.slice(1), "serve");
+  if (rawArguments[0] === "board") return runServe(rawArguments.slice(1), "board");
   if (rawArguments[0] === "build") return runBuild(rawArguments.slice(1));
   return runBuild(rawArguments);
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sirux/md-press",
-  "version": "0.1.0",
-  "description": "Press Markdown into clean pages. Build self-contained HTML, or serve it live and save checkboxes back to the file. No AI, no tokens.",
+  "version": "0.2.0",
+  "description": "Press Markdown into clean pages. Build self-contained HTML, serve it live and save checkboxes back to the file, or open it as a Kanban board. No AI, no tokens.",
   "keywords": [
     "markdown",
     "html",
@@ -10,7 +10,10 @@
     "checklist",
     "offline",
     "live",
-    "todo"
+    "todo",
+    "kanban",
+    "board",
+    "backlog"
   ],
   "homepage": "https://github.com/sirasitxp/md-press#readme",
   "bugs": {
@@ -22,7 +25,7 @@
   },
   "license": "MIT",
   "author": "Sirasit Thitirattanakorn (Sirux) <sirasit@sirux.io>",
-  "main": "src/build.js",
+  "main": "src/index.js",
   "bin": {
     "md-press": "bin/md-press.js"
   },
@@ -41,7 +44,8 @@
   },
   "dependencies": {
     "highlight.js": "^11.12.0",
-    "marked": "^18.0.14"
+    "marked": "^18.0.14",
+    "marked-footnote": "^1.4.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.5",

package/src/board.js

@@ -0,0 +1,273 @@
+/*
+Reads a Markdown backlog as a Kanban board and writes changes back to it.
+
+The shape is the one people already write: "##" headings are columns, and
+the top-level task items ("- [ ] Ship it") under a heading are its cards, in
+order. A card owns its own line plus every line under it that is indented or
+a continuation, so nested notes travel with the card. Trailing `code` spans
+on the card's line are tags. With two or more columns, the last one counts
+as done: a card moved into it is checked, a card moved out is unchecked.
+
+Every change is a line operation on the file. Moving a card cuts its lines
+and pastes them at the target, adding a card appends one line, and nothing
+else in the file changes. Moving a card away and back gives the same bytes.
+
+Rendering the board page lives here too, next to the parser it depends on.
+*/
+
+const fileSystem = require("fs");
+const path = require("path");
+const { Marked } = require("marked");
+const { bodyLines, findTaskLines, taskLinePattern, setTaskLineState } = require("./tasks.js");
+const { splitFrontmatter } = require("./frontmatter.js");
+const { escapeHtml, markdownToText } = require("./build.js");
+
+const templateFolder = path.join(__dirname, "template");
+const pageStyles = fileSystem.readFileSync(path.join(templateFolder, "page.css"), "utf8");
+const boardStyles = fileSystem.readFileSync(path.join(templateFolder, "board.css"), "utf8");
+const boardScript = fileSystem.readFileSync(path.join(templateFolder, "board.js"), "utf8");
+
+const headingPattern = /^ {0,3}(#{1,2})[ \t]+(.*?)(?:[ \t]+#+)?[ \t]*$/;
+const listLinePattern = /^[ \t]*(?:[-*+]|\d{1,9}[.)])[ \t]/;
+const blockStartPattern = /^(?:#{1,6}[ \t]|(?:[-*+]|\d{1,9}[.)])[ \t]|```|~~~|>|(?:[-*_][ \t]*){3,}$)/;
+const trailingTagsPattern = /(?:[ \t]+`[^`\n]+`)+[ \t]*$/;
+
+function isBlank(text) {
+  return text.trim() === "";
+}
+
+/* Splits "Fix login `bug` `p1`" into { title: "Fix login", tags: ["bug", "p1"] }. */
+function splitTags(text) {
+  const match = text.match(trailingTagsPattern);
+  if (!match) return { title: text.trim(), tags: [] };
+  const tags = Array.from(match[0].matchAll(/`([^`]+)`/g), (tagMatch) => tagMatch[1].trim());
+  return { title: text.slice(0, match.index).trim(), tags };
+}
+
+/*
+Parses the board. Returns { title, columns }, where each column is
+{ title, lineIndex, cards, loose } and each card is
+{ title, tags, checked, lineIndex, lineCount, taskIndex, notes }.
+
+taskIndex is the card's position among all task lines in the file, the same
+index the page and /api/task use. notes is the card's extra lines, dedented,
+as Markdown. loose is true when the column's cards are separated by nothing
+but blank lines, so a card added to it gets the same spacing.
+*/
+function parseBoard(sourceText) {
+  const lines = bodyLines(sourceText);
+  const taskIndexByLine = new Map(findTaskLines(sourceText).map((task, index) => [task.lineIndex, index]));
+  const columns = [];
+  let title = "";
+  let column = null;
+  let card = null;
+
+  function closeCard() {
+    if (!card) return;
+    while (card.lineCount > 1 && isBlank(lines[card.position + card.lineCount - 1].text)) card.lineCount -= 1;
+    const extra = lines.slice(card.position + 1, card.position + card.lineCount).map((line) => line.text);
+    const indent = Math.min(...extra.filter((text) => !isBlank(text)).map((text) => text.match(/^[ \t]*/)[0].length), Infinity);
+    card.notes = extra.map((text) => text.slice(Math.min(indent, text.length))).join("\n").trim();
+    card = null;
+  }
+
+  lines.forEach((line, position) => {
+    const { text } = line;
+    const headingMatch = line.inCode ? null : text.match(headingPattern);
+    if (headingMatch && headingMatch[1] === "#") {
+      closeCard();
+      column = null;
+      if (!title) title = markdownToText(headingMatch[2]);
+      return;
+    }
+    if (headingMatch) {
+      closeCard();
+      column = { title: markdownToText(headingMatch[2]), lineIndex: line.lineIndex, cards: [], loose: false };
+      columns.push(column);
+      return;
+    }
+    if (!column) return;
+
+    const taskMatch = line.inCode || /^[ \t>]/.test(text) ? null : text.match(taskLinePattern);
+    if (taskMatch) {
+      closeCard();
+      const previous = column.cards[column.cards.length - 1];
+      const between = previous ? lines.slice(previous.position + previous.lineCount, position) : [];
+      if (between.length > 0 && between.every((line) => isBlank(line.text))) column.loose = true;
+      const { title: cardTitle, tags } = splitTags(text.slice(taskMatch[0].length));
+      card = {
+        title: cardTitle,
+        tags,
+        checked: taskMatch[2] !== " ",
+        lineIndex: line.lineIndex,
+        lineCount: 1,
+        taskIndex: taskIndexByLine.get(line.lineIndex),
+        notes: "",
+        position,
+      };
+      column.cards.push(card);
+      return;
+    }
+    if (!card) return;
+
+    const previousText = lines[position - 1].text;
+    const continues = line.inCode
+      || isBlank(text)
+      || /^[ \t]/.test(text)
+      || (!isBlank(previousText) && !blockStartPattern.test(text));
+    if (continues) card.lineCount += 1;
+    else closeCard();
+  });
+  closeCard();
+  columns.forEach((item) => item.cards.forEach((entry) => { delete entry.position; }));
+  return { title, columns };
+}
+
+/*
+Removes a run of lines. A blank line left touching another blank line, where
+the card used to be, is dropped too, so the file does not gain empty space.
+*/
+function removeLines(lines, start, count) {
+  lines.splice(start, count);
+  if (start > 0 && start < lines.length && isBlank(lines[start - 1]) && isBlank(lines[start])) lines.splice(start, 1);
+}
+
+/*
+Inserts card lines into a column, before the card at cardIndex or at the end
+of the column when cardIndex is past the last card. Spacing follows the
+column: a blank line after a heading or paragraph, and between cards when
+the column already spaces its cards that way. A move passes the spacing of
+the column as it was before the card left, since a column with one card
+left cannot show it.
+*/
+function insertCardLines(lines, board, columnIndex, cardLines, cardIndex, loose = board.columns[columnIndex].loose) {
+  const column = board.columns[columnIndex];
+  const nextColumn = board.columns[columnIndex + 1];
+  const before = column.cards[cardIndex];
+  let insertAt;
+  if (before) {
+    insertAt = before.lineIndex;
+  } else {
+    insertAt = nextColumn ? nextColumn.lineIndex : lines.length;
+    while (insertAt > column.lineIndex + 1 && isBlank(lines[insertAt - 1])) insertAt -= 1;
+  }
+  const previous = lines[insertAt - 1];
+  const gapBefore = !isBlank(previous) && (!listLinePattern.test(previous) || (loose && !before));
+  const gapAfter = Boolean(before) && loose;
+  lines.splice(insertAt, 0, ...(gapBefore ? [""] : []), ...cardLines, ...(gapAfter ? [""] : []));
+}
+
+function findCard(board, columnIndex, cardIndex) {
+  const card = board.columns[columnIndex]?.cards[cardIndex];
+  if (!card) throw new RangeError(`No card at column ${columnIndex}, index ${cardIndex}`);
+  return card;
+}
+
+function checkColumn(board, columnIndex) {
+  if (!board.columns[columnIndex]) throw new RangeError(`No column at index ${columnIndex}`);
+}
+
+/*
+Moves one card. from and to are { column, index }; to.index is the card's
+final position in the target column. Returns the new source text.
+*/
+function moveCard(sourceText, from, to) {
+  const board = parseBoard(sourceText);
+  const card = findCard(board, from.column, from.index);
+  checkColumn(board, to.column);
+  const lastColumn = board.columns.length > 1 ? board.columns.length - 1 : -1;
+  const lines = sourceText.split("\n");
+  const cardLines = lines.slice(card.lineIndex, card.lineIndex + card.lineCount);
+  if (to.column === lastColumn && from.column !== lastColumn) cardLines[0] = setTaskLineState(cardLines[0], true);
+  if (from.column === lastColumn && to.column !== lastColumn) cardLines[0] = setTaskLineState(cardLines[0], false);
+  removeLines(lines, card.lineIndex, card.lineCount);
+  insertCardLines(lines, parseBoard(lines.join("\n")), to.column, cardLines, to.index, board.columns[to.column].loose);
+  return lines.join("\n");
+}
+
+/* Adds a card with the given text at the end of a column. Returns the new source text. */
+function addCard(sourceText, columnIndex, text) {
+  const title = String(text).replace(/\s+/g, " ").trim();
+  if (!title) throw new RangeError("A card needs some text");
+  const board = parseBoard(sourceText);
+  checkColumn(board, columnIndex);
+  const checked = board.columns.length > 1 && columnIndex === board.columns.length - 1;
+  const lines = sourceText.split("\n");
+  insertCardLines(lines, board, columnIndex, [`- [${checked ? "x" : " "}] ${title}`], Infinity);
+  return lines.join("\n");
+}
+
+/* A stable hue for a tag name, so the same tag looks the same everywhere. */
+function hueFor(tag) {
+  let hash = 7;
+  for (const character of tag.toLowerCase()) hash = ((hash * 33) ^ character.codePointAt(0)) >>> 0;
+  return hash % 360;
+}
+
+function renderTag(tag) {
+  return `<span class="tag" style="--hue: ${hueFor(tag)}">${escapeHtml(tag)}</span>`;
+}
+
+/*
+Renders the board as a live page. Cards carry their column, index, task
+index, and tags as data attributes for the board script.
+*/
+function renderBoard(sourceText, sourceName, { live }) {
+  const board = parseBoard(sourceText);
+  const { metadata } = splitFrontmatter(sourceText);
+  const markdown = new Marked();
+  const baseName = path.basename(sourceName);
+  const title = metadata.title || board.title || path.basename(baseName, path.extname(baseName));
+  const allTags = Array.from(new Set(board.columns.flatMap((column) => column.cards.flatMap((card) => card.tags)))).sort();
+  const columnOptions = board.columns.map((column, index) => `<option value="${index}">${escapeHtml(column.title)}</option>`).join("");
+
+  const columnsHtml = board.columns.map((column, columnIndex) => {
+    const cards = column.cards.map((card, cardIndex) => `<li class="card${card.checked ? " done" : ""}" draggable="true" data-column="${columnIndex}" data-index="${cardIndex}" data-task="${card.taskIndex}" data-tags="${escapeHtml(card.tags.join(" "))}">
+<label class="card-main"><input type="checkbox" class="task"${card.checked ? " checked" : ""} aria-label="${escapeHtml(card.title)}"> <span class="card-title">${markdown.parseInline(card.title)}</span></label>
+${card.tags.length ? `<div class="card-tags">${card.tags.map(renderTag).join("")}</div>` : ""}
+${card.notes ? `<div class="card-notes">${markdown.parse(card.notes)}</div>` : ""}
+<label class="card-move"><span class="sr-only">Move to</span><select data-column="${columnIndex}" data-index="${cardIndex}"><option value="">Move to…</option>${columnOptions}</select></label>
+</li>`).join("\n");
+    return `<section class="column" aria-label="${escapeHtml(column.title)}">
+<h2>${escapeHtml(column.title)} <span class="count">${column.cards.length}</span></h2>
+<ul class="cards" data-column="${columnIndex}">
+${cards}
+</ul>
+<form class="add-card" data-column="${columnIndex}"><input type="text" name="text" placeholder="Add a card" aria-label="New card in ${escapeHtml(column.title)}" autocomplete="off"><button type="submit">Add</button></form>
+</section>`;
+  }).join("\n");
+
+  const empty = board.columns.length === 0
+    ? `<p class="board-empty">No columns yet. Add <code>## Heading</code> lines to ${escapeHtml(baseName)} for columns, and <code>- [ ] Task</code> lines under them for cards.</p>`
+    : "";
+  const pageSettings = { live: { version: live.version, fileName: baseName } };
+
+  return `<!doctype html>
+<html lang="${escapeHtml(metadata.lang || "en")}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<title>${escapeHtml(title)}</title>
+<style>${pageStyles}
+${boardStyles}</style>
+</head>
+<body class="board-body">
+<div class="progress board-toolbar" role="status" aria-live="polite">
+<strong class="board-title">${escapeHtml(title)}</strong>
+${allTags.length ? `<div class="board-filter" aria-label="Filter by tag">${allTags.map(renderTag).join("")}</div>` : ""}
+<a class="board-link" href="/page">Page view</a>
+<span class="toolbar-status">Live, saving to ${escapeHtml(baseName)}</span>
+</div>
+<main class="board">
+${columnsHtml}
+${empty}
+</main>
+<footer>Board of ${escapeHtml(baseName)} with md-press. Columns are <code>##</code> headings, cards are <code>- [ ]</code> items, tags are trailing <code>\`code\`</code>.</footer>
+<script>const mdPress = ${JSON.stringify(pageSettings).replace(/</g, "\\u003c")};
+${boardScript}</script>
+</body>
+</html>
+`;
+}
+
+module.exports = { parseBoard, moveCard, addCard, renderBoard, splitTags, hueFor };