@a-t-h-i/bot-lobby 0.6.2 → 0.6.4

package/src/state/metrics.ts

@@ -5,7 +5,7 @@
  * thinking level, how often it succeeds and what it costs. Append-only JSON
  * lines per project; reads keep the newest `MAX_READ` records.
  */
-import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { appendFileSync, closeSync, mkdirSync, openSync, readSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { RunLogEntry, Task } from "../schemas/task.ts";
@@ -119,6 +119,20 @@ function isRecord(value: unknown): value is MetricRecord {
   return Boolean(record && typeof record.id === "string" && typeof record.kind === "string" && typeof record.durationMs === "number");
 }
 
+/** How much of a long log's end the first read takes: far more than `MAX_READ` records need. */
+const TAIL_BYTES = 4 * 1024 * 1024;
+
+/** A metrics log as followed so far: the file it was, how far it was read, and its newest records. */
+interface Followed {
+  ino: bigint;
+  offset: number;
+  records: MetricRecord[];
+  /** The first read starts inside the file, part way through a line. */
+  midLine: boolean;
+}
+
+const followed = new Map<string, Followed>();
+
 /** Agent runs for the Metrics tab; classifier calls, a few hundred milliseconds each, are read apart. */
 export function readMetrics(root: string, configDir: string, limit = MAX_READ): MetricRecord[] {
   return readRecords(root, configDir, limit).filter((record) => record.kind !== "classifier");
@@ -129,26 +143,62 @@ export function readClassifierMetrics(root: string, configDir: string, limit = M
   return readRecords(root, configDir, limit).filter((record) => record.kind === "classifier");
 }
 
+/**
+ * The newest records of the project's log, agent runs and classifier calls
+ * alike. The log only grows, so after the first read (of its end only) each
+ * read parses just the lines appended since; a log that shrank or was
+ * replaced is read afresh.
+ */
 function readRecords(root: string, configDir: string, limit: number): MetricRecord[] {
   const path = metricsPath(root, configDir);
-  if (!existsSync(path)) return [];
-  let text: string;
+  let ino: bigint;
+  let size: number;
   try {
-    text = readFileSync(path, "utf8");
+    const stat = statSync(path, { bigint: true });
+    ino = stat.ino;
+    size = Number(stat.size);
   } catch {
+    followed.delete(path);
     return [];
   }
-  const records: MetricRecord[] = [];
-  for (const line of text.split("\n").slice(-limit - 1)) {
-    if (!line.trim()) continue;
-    try {
-      const value = JSON.parse(line) as unknown;
-      if (isRecord(value)) records.push(value);
-    } catch {
-      // Torn lines are skipped.
+  let log = followed.get(path);
+  if (!log || log.ino !== ino || size < log.offset) {
+    const offset = Math.max(0, size - TAIL_BYTES);
+    log = { ino, offset, records: [], midLine: offset > 0 };
+    followed.set(path, log);
+  }
+  if (size > log.offset) readAppended(path, log, size);
+  return log.records.length > limit ? log.records.slice(-limit) : [...log.records];
+}
+
+function readAppended(path: string, log: Followed, size: number): void {
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "r");
+    const buffer = Buffer.alloc(size - log.offset);
+    const read = readSync(fd, buffer, 0, buffer.length, log.offset);
+    // Whole lines only: one still being appended is read next time.
+    const end = buffer.lastIndexOf(0x0a, read - 1);
+    if (end < 0) return;
+    const lines = buffer.toString("utf8", 0, end).split("\n");
+    if (log.midLine) lines.shift();
+    log.midLine = false;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      try {
+        const value = JSON.parse(line) as unknown;
+        if (isRecord(value)) log.records.push(value);
+      } catch {
+        // Torn lines are skipped.
+      }
     }
+    if (log.records.length > MAX_READ) log.records.splice(0, log.records.length - MAX_READ);
+    log.offset += end + 1;
+  } catch {
+    // Unreadable for now; the next read tries again.
+  } finally {
+    if (fd !== undefined) closeSync(fd);
   }
-  return records.slice(-limit);
 }
 
 const AGENT_NAMES: Record<string, string> = { backend: "DEV", designer: "DESIGN", qa: "QA" };

package/src/state/persistence.ts

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
+import { join, sep } from "node:path";
 import type { KnowledgeConfig } from "../schemas/configuration.ts";
 import type { Domain } from "../schemas/agent.ts";
 import { TERMINAL_STATES, isTaskState, type Task } from "../schemas/task.ts";
@@ -14,6 +14,7 @@ import {
   type KnowledgeAgent,
 } from "../knowledge/paths.ts";
 import { DEFAULT_KNOWLEDGE_CONTENT, ensureFile, readFileOr, writeFileEnsured } from "../knowledge/store.ts";
+import { forgetCached, forgetCachedUnder, readJsonCached } from "./file-cache.ts";
 
 /** Idempotently create the full knowledge + tasks layout with seed files. */
 export function ensureProjectStructure(root: string, configDir: string): void {
@@ -36,6 +37,7 @@ export function ensureProjectStructure(root: string, configDir: string): void {
 export function createTaskDir(root: string, configDir: string, task: Task): void {
   const dir = taskDir(dataRoot(root, configDir), task.id);
   mkdirSync(dir, { recursive: true });
+  forgetCached(join(dir, "state.json"));
   writeFileEnsured(join(dir, "state.json"), JSON.stringify(task, null, 2));
   ensureFile(join(dir, "proposal.md"), "");
   ensureFile(join(dir, "plan.md"), "");
@@ -77,7 +79,9 @@ export function readTaskArtifact(
 }
 
 export function saveTask(root: string, configDir: string, task: Task): void {
-  writeFileEnsured(join(taskDir(dataRoot(root, configDir), task.id), "state.json"), JSON.stringify(task, null, 2));
+  const path = join(taskDir(dataRoot(root, configDir), task.id), "state.json");
+  forgetCached(path);
+  writeFileEnsured(path, JSON.stringify(task, null, 2));
 }
 
 /** Read a task state: the bot-lobby copy wins, else the newest pre-rename copy. */
@@ -147,6 +151,36 @@ export function listTasks(root: string, configDir: string): Task[] {
   return tasks.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
 }
 
+/** Any parsed JSON object counts as a task, as `readTaskAt` has it. */
+function isObject(value: unknown): value is Task {
+  return typeof value === "object" && value !== null;
+}
+
+/**
+ * All tasks on disk, newest first, like `listTasks`, but a file is read only
+ * when it changed since the last look. The tasks are shared with every other
+ * caller, so they are for reading (the owner's clock, the lobby): whatever
+ * changes a task loads its own copy with `loadTask` and saves that.
+ */
+export function peekTasks(root: string, configDir: string): Task[] {
+  const tasks: Task[] = [];
+  const seen = new Set<string>();
+  for (const { dir } of taskEntries(root, configDir)) {
+    const path = join(dir, "state.json");
+    seen.add(path);
+    const task = readJsonCached(path, isObject);
+    if (task) tasks.push(task);
+  }
+  // Forget tasks that left these folders (deleted or archived).
+  for (const dr of readDataRoots(root, configDir)) forgetCachedUnder(`${tasksRoot(dr)}${sep}`, seen);
+  return tasks.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}
+
+/** The non-terminal task a session owns, from `peekTasks` (for reading only). */
+export function peekOwnedTask(root: string, configDir: string, sessionId: string): Task | undefined {
+  return peekTasks(root, configDir).find((task) => !TERMINAL_STATES.includes(task.state) && task.ownerSessionId === sessionId);
+}
+
 /** Tasks on disk plus the ids whose state.json could not be read (§59). */
 export function taskHealth(root: string, configDir: string): { tasks: Task[]; corrupted: string[] } {
   const tasks: Task[] = [];

package/src/text.ts

@@ -5,6 +5,13 @@ export function truncate(text: string, maxChars: number): string {
   return `${text.slice(0, maxChars)}\n[...${text.length - maxChars} characters omitted]`;
 }
 
+/** The end of `text` within a character budget (the newest entries of a log), marking how much was left out before it. */
+export function tail(text: string, maxChars: number): string {
+  if (maxChars <= 0) return "";
+  if (text.length <= maxChars) return text;
+  return `[...${text.length - maxChars} earlier characters omitted]\n${text.slice(text.length - maxChars)}`;
+}
+
 /** Filler and imperative words that carry no topic signal in a request. */
 const FILLER_WORDS = new Set([
   "let's",
@@ -45,9 +52,28 @@ function fillerKey(word: string): string {
  */
 export function shortTitle(request: string, maxWords = 3): string {
   if (maxWords <= 0) return "";
-  const words = request.trim().split(/\s+/).filter(Boolean);
+  const words = titleText(request).split(/\s+/).filter(Boolean);
   const content = words.filter((word) => !FILLER_WORDS.has(fillerKey(word)));
-  return (content.length > 0 ? content : words).slice(0, maxWords).join(" ");
+  return (content.length > 0 ? content : words).slice(0, maxWords).join(" ").replace(/[:;,]+$/, "");
+}
+
+/** Headings that only label a section (`### Objective`), not name the work. */
+const LABEL_HEADING = /^#{1,6}\s*(objective|goal|goals|summary|overview|task|request|context|background|description|plan)\s*:?\s*$/i;
+
+/**
+ * A request as words for a title: escaped line breaks (`\\n` written out by a
+ * model) read as breaks, label headings are skipped, and Markdown marks
+ * (`#`, `-`, `*`, `>`, backticks) are dropped.
+ */
+function titleText(request: string): string {
+  return request
+    .replace(/\\[nrt]/g, "\n")
+    .split("\n")
+    .filter((line) => !LABEL_HEADING.test(line.trim()))
+    .join(" ")
+    .replace(/[#*>`|]+/g, " ")
+    .replace(/(^|\s)[-+](?=\s|$)/g, " ")
+    .trim();
 }
 
 /** Compact duration such as "45s", "3m" or "2m 05s"; a non-finite input reads "0s". */

package/src/web/extract.ts

@@ -0,0 +1,332 @@
+/**
+ * A web page as a model reads it best: its title and dates, then the main
+ * content as Markdown (headings, paragraphs, lists, tables, code, links made
+ * absolute), with navigation, scripts, forms, cookie banners and the like
+ * left out.
+ */
+import { findAll, findFirst, parseHtml, textOf, type HtmlElement, type HtmlNode } from "./html.ts";
+
+export interface PageMeta {
+  title?: string;
+  description?: string;
+  siteName?: string;
+  published?: string;
+  modified?: string;
+  lang?: string;
+}
+
+export interface ReadablePage extends PageMeta {
+  markdown: string;
+}
+
+/** Elements never worth reading. */
+const DROP = new Set(["script", "style", "noscript", "template", "svg", "canvas", "iframe", "object", "embed", "video", "audio", "map", "head", "link", "meta", "button", "input", "select", "textarea", "form", "dialog", "nav"]);
+/** Page chrome, dropped unless it is all there is. */
+const CHROME = new Set(["aside", "footer"]);
+/** Class or id words that mark page chrome rather than content. */
+const CHROME_HINT = /(?:^|[\s_-])(cookie|consent|gdpr|banner|newsletter|subscribe|signup|sidebar|share|sharing|social|advert|ads?|promo|popup|modal|breadcrumbs?|related|comments?|skip-link|toc-mobile)(?:$|[\s_-])/i;
+const BLOCK = new Set(["address", "article", "aside", "blockquote", "body", "center", "dd", "details", "dialog", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "h1", "h2", "h3", "h4", "h5", "h6", "header", "hgroup", "hr", "html", "li", "main", "ol", "p", "pre", "section", "summary", "table", "tbody", "td", "tfoot", "th", "thead", "tr", "ul", "#root"]);
+
+function isChrome(element: HtmlElement): boolean {
+  if (element.attrs.hidden !== undefined || element.attrs["aria-hidden"] === "true") return true;
+  if (element.attrs.role === "navigation" || element.attrs.role === "banner" || element.attrs.role === "contentinfo" || element.attrs.role === "dialog") return true;
+  const style = element.attrs.style ?? "";
+  if (/display\s*:\s*none|visibility\s*:\s*hidden/i.test(style)) return true;
+  if (!["div", "section", "aside", "ul", "span", "p", "header", "footer"].includes(element.name)) return false;
+  return CHROME_HINT.test(`${element.attrs.class ?? ""} ${element.attrs.id ?? ""}`);
+}
+
+function metaContent(root: HtmlElement, ...keys: string[]): string | undefined {
+  const metas = findAll(root, (element) => element.name === "meta");
+  for (const key of keys) {
+    const meta = metas.find((element) => (element.attrs.property ?? element.attrs.name ?? element.attrs.itemprop ?? "").toLowerCase() === key);
+    const content = meta?.attrs.content?.trim();
+    if (content) return content;
+  }
+  return undefined;
+}
+
+/** A date as it is written in structured data (JSON-LD), when the page has one. */
+function jsonLdDate(root: HtmlElement, key: "datePublished" | "dateModified"): string | undefined {
+  for (const script of findAll(root, (element) => element.name === "script" && (element.attrs.type ?? "").includes("ld+json"))) {
+    const source = script.children.map((child) => (child.type === "text" ? child.text : "")).join("");
+    const match = new RegExp(`"${key}"\\s*:\\s*"([^"]+)"`).exec(source);
+    if (match) return match[1];
+  }
+  return undefined;
+}
+
+/** A date trimmed to what a citation needs: the day (ISO), or the text as the page gives it. */
+function day(value: string | undefined): string | undefined {
+  if (!value) return undefined;
+  const iso = /^(\d{4}-\d{2}-\d{2})/.exec(value.trim());
+  if (iso) return iso[1];
+  const parsed = Date.parse(value);
+  return Number.isNaN(parsed) ? value.trim().slice(0, 40) : new Date(parsed).toISOString().slice(0, 10);
+}
+
+export function pageMeta(root: HtmlElement): PageMeta {
+  const titleElement = findFirst(root, (element) => element.name === "title");
+  const title = metaContent(root, "og:title", "twitter:title") ?? (titleElement ? textOf(titleElement) : undefined);
+  const time = findFirst(root, (element) => element.name === "time" && Boolean(element.attrs.datetime));
+  const html = findFirst(root, (element) => element.name === "html");
+  const meta: PageMeta = {
+    title: title?.replace(/\s+/g, " ").trim() || undefined,
+    description: metaContent(root, "description", "og:description", "twitter:description"),
+    siteName: metaContent(root, "og:site_name", "application-name"),
+    published: day(metaContent(root, "article:published_time", "datepublished", "date", "dc.date", "dc.date.issued", "dcterms.created", "pubdate", "citation_publication_date", "citation_date", "sailthru.date") ?? jsonLdDate(root, "datePublished") ?? time?.attrs.datetime),
+    modified: day(metaContent(root, "article:modified_time", "og:updated_time", "datemodified", "last-modified", "dcterms.modified") ?? jsonLdDate(root, "dateModified")),
+    lang: html?.attrs.lang,
+  };
+  return Object.fromEntries(Object.entries(meta).filter(([, value]) => value !== undefined)) as PageMeta;
+}
+
+/** The part of the page that is its content: main, the one article, role=main, or the body. */
+function contentRoot(root: HtmlElement): HtmlElement {
+  const main = findFirst(root, (element) => element.name === "main" || element.attrs.role === "main");
+  if (main && textOf(main).length > 200) return main;
+  const articles = findAll(root, (element) => element.name === "article");
+  if (articles.length === 1 && textOf(articles[0]!).length > 200) return articles[0]!;
+  const content = findFirst(root, (element) => ["content", "main-content", "maincontent"].includes((element.attrs.id ?? "").toLowerCase()));
+  if (content && textOf(content).length > 200) return content;
+  return findFirst(root, (element) => element.name === "body") ?? root;
+}
+
+/**
+ * Drop what is never content; page chrome goes too unless nothing else is
+ * left. Reading the whole body, its header (logo, site menu) is chrome as well.
+ */
+function prune(node: HtmlElement, keepChrome: boolean, dropHeader: boolean): HtmlElement {
+  const children: HtmlNode[] = [];
+  for (const child of node.children) {
+    if (child.type === "text") children.push(child);
+    else if (DROP.has(child.name)) continue;
+    else if (!keepChrome && (CHROME.has(child.name) || isChrome(child) || (dropHeader && child.name === "header"))) continue;
+    else children.push(prune(child, keepChrome, dropHeader));
+  }
+  return { ...node, children };
+}
+
+interface Context {
+  /** Where relative links point from. */
+  base: URL | undefined;
+}
+
+function absolute(href: string | undefined, base: URL | undefined): string | undefined {
+  if (!href) return undefined;
+  const trimmed = href.trim();
+  if (!trimmed || trimmed.startsWith("#") || /^(javascript|mailto|tel|data):/i.test(trimmed)) return undefined;
+  try {
+    return new URL(trimmed, base).href;
+  } catch {
+    return undefined;
+  }
+}
+
+function fence(code: string): string {
+  const longest = Math.max(2, ...[...code.matchAll(/`+/g)].map((run) => run[0].length));
+  return "`".repeat(longest + 1);
+}
+
+function codeLanguage(element: HtmlElement): string {
+  const code = findFirst(element, (child) => child.name === "code");
+  const classes = `${element.attrs.class ?? ""} ${code?.attrs.class ?? ""} ${element.attrs["data-lang"] ?? ""}`;
+  const match = /(?:language|lang|highlight-source)-([a-z0-9+#-]+)/i.exec(classes) ?? /^\s*([a-z0-9+#-]+)\s*$/i.exec(element.attrs["data-lang"] ?? "");
+  return match?.[1]?.toLowerCase() ?? "";
+}
+
+function rawText(node: HtmlNode): string {
+  if (node.type === "text") return node.text;
+  if (node.name === "br") return "\n";
+  return node.children.map(rawText).join("");
+}
+
+function wrapInline(text: string, mark: string): string {
+  const trimmed = text.trim();
+  if (!trimmed) return text;
+  const lead = text.startsWith(" ") ? " " : "";
+  const trail = text.endsWith(" ") ? " " : "";
+  return `${lead}${mark}${trimmed}${mark}${trail}`;
+}
+
+/** A node's inline Markdown: text with emphasis, code, links and line breaks. */
+function inline(node: HtmlNode, context: Context): string {
+  if (node.type === "text") return node.text.replace(/\s+/g, " ");
+  const inner = () => node.children.map((child) => inline(child, context)).join("");
+  switch (node.name) {
+    case "br":
+      return "\n";
+    case "img": {
+      const alt = (node.attrs.alt ?? "").replace(/\s+/g, " ").trim();
+      const src = absolute(node.attrs.src, context.base);
+      return alt && src ? `![${alt}](${src})` : alt;
+    }
+    case "a": {
+      const text = inner();
+      const href = absolute(node.attrs.href, context.base);
+      if (!text.trim()) return "";
+      return href ? `${text.startsWith(" ") ? " " : ""}[${text.trim()}](${href})${text.endsWith(" ") ? " " : ""}` : text;
+    }
+    case "strong":
+    case "b":
+      return wrapInline(inner(), "**");
+    case "em":
+    case "i":
+    case "cite":
+      return wrapInline(inner(), "*");
+    case "del":
+    case "s":
+    case "strike":
+      return wrapInline(inner(), "~~");
+    case "code":
+    case "kbd":
+    case "samp":
+    case "tt": {
+      const code = rawText(node).replace(/\s+/g, " ");
+      if (!code.trim()) return code;
+      const ticks = code.includes("`") ? "``" : "`";
+      return `${ticks}${ticks.length > 1 ? " " : ""}${code.trim()}${ticks.length > 1 ? " " : ""}${ticks}`;
+    }
+    case "sup":
+      return `^${inner().trim()}`;
+    default:
+      // A block inside inline content (a div in a link) reads as a spaced run.
+      return BLOCK.has(node.name) ? ` ${inner()} ` : inner();
+  }
+}
+
+function paragraph(text: string): string {
+  return text
+    .split("\n")
+    .map((line) => line.replace(/[ \t]+/g, " ").trim())
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function indent(text: string, prefix: string, first = prefix): string {
+  return text
+    .split("\n")
+    .map((line, index) => (index === 0 ? first : line ? prefix : "") + line)
+    .join("\n");
+}
+
+function table(element: HtmlElement, context: Context): string {
+  const rows = findAll(element, (child) => child.name === "tr").map((row) =>
+    row.children
+      .filter((cell): cell is HtmlElement => cell.type === "element" && (cell.name === "td" || cell.name === "th"))
+      .map((cell) => paragraph(inline(cell, context)).replace(/\n+/g, " ").replace(/\|/g, "\\|")),
+  );
+  const filled = rows.filter((row) => row.some((cell) => cell));
+  if (filled.length === 0) return "";
+  const width = Math.max(...filled.map((row) => row.length));
+  const line = (cells: string[]) => `| ${[...cells, ...Array(width - cells.length).fill("")].join(" | ")} |`;
+  return [line(filled[0]!), `|${" --- |".repeat(width)}`, ...filled.slice(1).map(line)].join("\n");
+}
+
+function list(element: HtmlElement, context: Context): string {
+  const ordered = element.name === "ol";
+  let number = Number.parseInt(element.attrs.start ?? "1", 10) || 1;
+  const items: string[] = [];
+  for (const child of element.children) {
+    if (child.type === "text") {
+      if (child.text.trim()) items.push(`- ${child.text.trim()}`);
+      continue;
+    }
+    const body = child.name === "li" ? blocks(child, context).join("\n") : blocks({ ...child, children: [child] }, context).join("\n");
+    if (!body.trim()) continue;
+    const marker = ordered ? `${number++}. ` : "- ";
+    items.push(indent(body, " ".repeat(marker.length), marker));
+  }
+  return items.join("\n");
+}
+
+/** A block element as Markdown blocks. */
+function block(element: HtmlElement, context: Context): string[] {
+  switch (element.name) {
+    case "h1":
+    case "h2":
+    case "h3":
+    case "h4":
+    case "h5":
+    case "h6": {
+      const text = paragraph(inline(element, context)).replace(/\n+/g, " ");
+      return text ? [`${"#".repeat(Number(element.name[1]))} ${text}`] : [];
+    }
+    case "p":
+    case "summary":
+    case "figcaption":
+    case "dt": {
+      const text = paragraph(element.children.map((child) => inline(child, context)).join(""));
+      return text ? [element.name === "dt" ? `**${text}**` : text] : [];
+    }
+    case "pre": {
+      const code = rawText(element).replace(/^\n/, "").replace(/\s+$/, "");
+      if (!code.trim()) return [];
+      const marks = fence(code);
+      return [`${marks}${codeLanguage(element)}\n${code}\n${marks}`];
+    }
+    case "ul":
+    case "ol":
+    case "menu": {
+      const text = list(element, context);
+      return text ? [text] : [];
+    }
+    case "blockquote": {
+      const inner = blocks(element, context).join("\n\n");
+      return inner ? [indent(inner, "> ")] : [];
+    }
+    case "table": {
+      const text = table(element, context);
+      return text ? [text] : [];
+    }
+    case "hr":
+      return ["---"];
+    default:
+      return blocks(element, context);
+  }
+}
+
+/** The children of an element as Markdown blocks: inline runs become paragraphs. */
+function blocks(element: HtmlElement, context: Context): string[] {
+  const out: string[] = [];
+  let run = "";
+  const flush = () => {
+    const text = paragraph(run);
+    if (text) out.push(text);
+    run = "";
+  };
+  for (const child of element.children) {
+    if (child.type === "element" && BLOCK.has(child.name)) {
+      flush();
+      out.push(...block(child, context));
+    } else {
+      run += inline(child, context);
+    }
+  }
+  flush();
+  return out;
+}
+
+/** An HTML page as its metadata plus its main content in Markdown. */
+export function htmlToMarkdown(html: string, url?: string): ReadablePage {
+  const root = parseHtml(html);
+  const meta = pageMeta(root);
+  const baseHref = findFirst(root, (element) => element.name === "base")?.attrs.href;
+  let base: URL | undefined;
+  try {
+    base = url ? new URL(baseHref ?? "", url) : undefined;
+  } catch {
+    base = undefined;
+  }
+  const content = contentRoot(root);
+  const wholePage = content.name === "body" || content.name === "#root";
+  let pruned = prune(content, false, wholePage);
+  if (textOf(pruned).length < 80) pruned = prune(content, true, false);
+  const markdown = blocks(pruned, { base })
+    .join("\n\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  return { ...meta, markdown };
+}
+