@uniqbit/mate-core 0.18.5 → 1.0.0-canary.0

package/src/cli/commands/doctor.ts

@@ -6,6 +6,7 @@ import { parse as parseYaml } from "yaml";
 
 import { FRAMEWORK_NAME } from "../../framework";
 import { gitEnvironment } from "../../runtime/companion-git";
+import { companionClaudeMdHasOwnText } from "../../runtime/companion-instructions";
 import { getActiveDistribution } from "../../distribution";
 import { hasOpenspecCapability } from "../../lib/orchestrator/capabilities";
 import { checkEngineRequirement } from "../../lib/orchestrator/engine-guard";
@@ -13,6 +14,8 @@ import type { GlobalConfigStore } from "../../lib/orchestrator/global-config-sto
 import { pathIsDirectory } from "../../lib/fs-utils";
 import { resolveRootContext, type RootContext } from "../../lib/orchestrator/root-context";
 import type { CapabilityConfig, FrameworkConfig, HubMember } from "../../lib/orchestrator/types";
+import { locateOpenSpec, type OpenSpecLocation } from "../../lib/openspec-cli";
+import { MATE_CLAUDE_PLUGIN_NAME } from "../../lib/package-paths";
 import {
   describeUnknownAudience,
   readAudienceSelection,
@@ -23,7 +26,20 @@ import {
   type PluginInspection,
   type PluginVerificationFailure,
 } from "../../tools/setup/dynamic-plugins/verify";
+import { hydrateDynamicPlugins } from "../../tools/setup/dynamic-plugins/hydrate";
+import {
+  inspectClaudePluginDirectories,
+  type ClaudePluginDirectoryInspection,
+} from "../../tools/setup";
 import { getRequiredPluginDrift } from "../../tools/setup/policy";
+import {
+  CLAUDE_PLUGIN_MANIFEST,
+  CLAUDE_PLUGIN_MARKETPLACE,
+  type ClaudePluginContributionFailure,
+  type ClaudePluginDirectoryProblem,
+  type ClaudePluginDirectoryReport,
+  type ClaudePluginUnpublishedReason,
+} from "../../tools/setup/providers/claude-plugin-folders";
 import { resolveCommandOnPath } from "../../tools/setup/utils";
 import { writeJsonStdout } from "../write-json-stdout";
 import { printSection, renderKeyValueTable, renderTable } from "./status";
@@ -35,6 +51,12 @@ interface DoctorDeps {
   /** Returns a member checkout's HEAD commit, or null when unreadable. */
   gitHead?: (memberPath: string) => string | null;
   inspectPlugins?: (companionPath: string) => Promise<PluginInspection>;
+  /** Loads the companion's declared plugins so their Capabilities contribute. */
+  hydratePlugins?: (companionPath: string) => Promise<void>;
+  inspectClaudePlugins?: (
+    companionPath: string,
+    config: FrameworkConfig,
+  ) => Promise<ClaudePluginDirectoryInspection>;
   /** Environment `MATE_AUDIENCE` is read from; defaults to the process environment. */
   env?: Record<string, string | undefined>;
 }
@@ -46,6 +68,8 @@ export interface DoctorToolInstallation {
   source: string;
   status: "ok" | "missing";
   path: string | null;
+  /** Set for a tool Mate ships itself, such as the OpenSpec CLI. */
+  version?: string;
 }
 
 export interface DoctorHubMember {
@@ -79,6 +103,17 @@ export interface DoctorReport {
   engineRequirement?: { range: string; ok: boolean; detail: string };
   /** Present when the companion's `openspec/config.yaml` has `rules` keys OpenSpec ignores. */
   openspecRuleWarnings?: Array<{ key: string; message: string }>;
+  /** Present when the companion `CLAUDE.md` holds text no Working Repository session receives. */
+  companionInstructionWarnings?: Array<{ file: string; message: string }>;
+  /**
+   * Enabled Capabilities' Claude plugin folders, which load only with `mate claude`; absent when
+   * none. `problem` names why `mate claude` leaves a folder out: `not-absolute`,
+   * `missing-manifest`, `bundled-mate-plugin` (Mate's own plugin, which every managed launch
+   * loads already) or `mate-plugin-name` (its manifest uses Mate's plugin name).
+   */
+  claudePlugins?: ClaudePluginDirectoryReport[];
+  /** Capabilities whose contributions failed, so their Claude plugin folders are unknown; absent when none. */
+  claudePluginFailures?: ClaudePluginContributionFailure[];
   hub?: { members: DoctorHubMember[] };
   resolutionFailures: Array<{ companionPath: string; message: string }>;
 }
@@ -87,6 +122,8 @@ interface ToolCheck {
   name: string;
   command: string;
   source: string;
+  /** Locates a tool Mate ships instead of looking it up on PATH. */
+  bundled?: () => OpenSpecLocation;
 }
 
 /** Doctor's view of the shared root kind: registry/env resolution means cwd is a working repo. */
@@ -127,7 +164,12 @@ function getSelectedToolChecks(config: {
     checks.push({ name: "uv", command: "uv", source: "package manager" });
   }
   if (selectedCapabilities.has("openspec")) {
-    checks.push({ name: "openspec", command: "openspec", source: "capability" });
+    checks.push({
+      name: "openspec",
+      command: "openspec",
+      source: "capability",
+      bundled: locateOpenSpec,
+    });
   }
   if (selectedCapabilities.has("tokensave")) {
     checks.push({ name: "tokensave", command: "tokensave", source: "capability" });
@@ -147,6 +189,21 @@ function collectToolInstallations(
   pathValue: string,
 ): DoctorToolInstallation[] {
   return getSelectedToolChecks(config).map((check) => {
+    if (check.bundled) {
+      const source = `${check.source}, bundled with ${FRAMEWORK_NAME}`;
+      const location = check.bundled();
+      if ("missing" in location) {
+        return { tool: check.name, source, status: "missing", path: null };
+      }
+      // An unreadable manifest only loses the version; the CLI itself resolved.
+      return {
+        tool: check.name,
+        source,
+        status: "ok",
+        path: location.bin,
+        ...(location.version ? { version: location.version } : {}),
+      };
+    }
     const resolved = resolveCommandOnPath(check.command, pathValue);
     return {
       tool: check.name,
@@ -309,6 +366,19 @@ async function collectOpenSpecRuleWarnings(
     }));
 }
 
+function collectCompanionInstructionWarnings(
+  companionPath: string,
+): NonNullable<DoctorReport["companionInstructionWarnings"]> {
+  if (!companionClaudeMdHasOwnText(companionPath)) return [];
+  const file = path.join(companionPath, "CLAUDE.md");
+  return [
+    {
+      file,
+      message: `${file} holds text besides @AGENTS.md and Mate-managed blocks. That text does not reach Working Repository sessions, only sessions started in the companion. Move rules meant for every session into ${path.join(companionPath, "AGENTS.md")}.`,
+    },
+  ];
+}
+
 export async function collectDoctorReport(deps: DoctorDeps = {}): Promise<DoctorReport> {
   const cwd = path.resolve(deps.cwd ?? process.cwd());
   const pathValue = deps.pathValue ?? process.env.PATH ?? "";
@@ -356,6 +426,23 @@ export async function collectDoctorReport(deps: DoctorDeps = {}): Promise<Doctor
     if (warnings.length > 0) report.openspecRuleWarnings = warnings;
   }
 
+  if (root.rootPath && (kind === "working" || kind === "companion")) {
+    const warnings = collectCompanionInstructionWarnings(root.rootPath);
+    if (warnings.length > 0) report.companionInstructionWarnings = warnings;
+  }
+
+  if (root.rootPath && root.config && (kind === "working" || kind === "companion")) {
+    /** Doctor reports plugin failures below; hydration supplies their contributions. */
+    const hydrate =
+      deps.hydratePlugins ??
+      ((companionPath) => hydrateDynamicPlugins({ companionPath, env, warn: () => {} }));
+    await hydrate(root.rootPath);
+    const inspectClaudePlugins = deps.inspectClaudePlugins ?? inspectClaudePluginDirectories;
+    const inspection = await inspectClaudePlugins(root.rootPath, root.config);
+    if (inspection.plugins.length > 0) report.claudePlugins = inspection.plugins;
+    if (inspection.failures.length > 0) report.claudePluginFailures = inspection.failures;
+  }
+
   if (root.rootPath && root.config) {
     const inspect =
       deps.inspectPlugins ?? ((companionPath) => inspectDeclaredPlugins(companionPath, { env }));
@@ -386,7 +473,12 @@ function renderToolInstallations(installations: DoctorToolInstallation[]): strin
   }
   return renderTable(
     ["Tool", "Source", "Status", "Path"],
-    installations.map((item) => [item.tool, item.source, item.status, item.path ?? ""]),
+    installations.map((item) => [
+      item.version ? `${item.tool} ${item.version}` : item.tool,
+      item.source,
+      item.status,
+      item.path ?? "",
+    ]),
   );
 }
 
@@ -404,6 +496,65 @@ function renderHubMembers(members: DoctorHubMember[]): string {
   );
 }
 
+/** The Status column's text for each reason a folder is left out. */
+const CLAUDE_PLUGIN_PROBLEM_STATUS: Record<ClaudePluginDirectoryProblem, string> = {
+  "not-absolute": "not an absolute path",
+  "bundled-mate-plugin": "Mate's bundled plugin, already loaded",
+  "missing-manifest": `missing ${CLAUDE_PLUGIN_MANIFEST}`,
+  "mate-plugin-name": `uses Mate's plugin name ${MATE_CLAUDE_PLUGIN_NAME}`,
+};
+
+function claudePluginStatus(plugin: ClaudePluginDirectoryReport): string {
+  return plugin.problem ? CLAUDE_PLUGIN_PROBLEM_STATUS[plugin.problem] : "present";
+}
+
+/** The Plain Sessions column's text for each reason a loadable folder is not published. */
+const CLAUDE_PLUGIN_UNPUBLISHED_STATUS: Record<ClaudePluginUnpublishedReason, string> = {
+  "foreign-marketplace": `no: ${CLAUDE_PLUGIN_MARKETPLACE} is not Mate's and does not list it`,
+  "invalid-marketplace-name": "no: its name cannot form a marketplace name",
+  "name-conflict": "no: its marketplace name is already in use",
+  "missing-marketplace": `no: ${CLAUDE_PLUGIN_MARKETPLACE} could not be written`,
+};
+
+function claudePluginPlainSessions(plugin: ClaudePluginDirectoryReport): string {
+  if (plugin.marketplace) return `marketplace ${plugin.marketplace}`;
+  if (plugin.unpublishedReason) return CLAUDE_PLUGIN_UNPUBLISHED_STATUS[plugin.unpublishedReason];
+  return "no";
+}
+
+/** A table for each list present, then a note on where plain sessions load them. */
+function renderClaudePlugins(
+  plugins: ClaudePluginDirectoryReport[] | undefined,
+  failures: ClaudePluginContributionFailure[] | undefined,
+): string {
+  const tables: string[] = [];
+  if (plugins) {
+    tables.push(
+      renderTable(
+        ["Capability", "Plugin Folder", "Status", "Plain Sessions"],
+        plugins.map((plugin) => [
+          plugin.capability,
+          plugin.path,
+          claudePluginStatus(plugin),
+          claudePluginPlainSessions(plugin),
+        ]),
+      ),
+    );
+  }
+  if (failures) {
+    tables.push(
+      renderTable(
+        ["Capability", "Error"],
+        failures.map((failure) => [failure.capability, failure.reason]),
+      ),
+    );
+  }
+  return [
+    ...tables.flatMap((table) => [table, ""]),
+    `\`${FRAMEWORK_NAME} claude\` loads every present plugin. Plain \`claude\` sessions load one with a marketplace, and only in a wrapped repository that Claude Code trusts.`,
+  ].join("\n");
+}
+
 function renderHumanReport(report: DoctorReport): void {
   console.log("Mate Doctor");
   console.log("");
@@ -477,6 +628,12 @@ function renderHumanReport(report: DoctorReport): void {
   if (report.engineRequirement) {
     printSection("Version Requirement", report.engineRequirement.detail);
   }
+  if (report.claudePlugins || report.claudePluginFailures) {
+    printSection(
+      "Claude Plugins",
+      renderClaudePlugins(report.claudePlugins, report.claudePluginFailures),
+    );
+  }
   if (report.openspecRuleWarnings) {
     printSection(
       "OpenSpec Config",
@@ -486,6 +643,15 @@ function renderHumanReport(report: DoctorReport): void {
       ),
     );
   }
+  if (report.companionInstructionWarnings) {
+    printSection(
+      "Companion Instructions",
+      renderList(
+        report.companionInstructionWarnings.map((warning) => warning.message),
+        "",
+      ),
+    );
+  }
 
   printSection(
     "Resolution Failures",
@@ -506,7 +672,8 @@ function renderHumanReport(report: DoctorReport): void {
  * capabilities and tool checks for companions, member health for hubs.
  * Declared plugins of the effective set (base plus the `MATE_AUDIENCE`
  * audience) are verified strictly (installed, loadable); any failure is named
- * on stderr and exits non-zero, as is an undeclared `MATE_AUDIENCE`.
+ * on stderr and exits non-zero, as is an undeclared `MATE_AUDIENCE` or a
+ * Capability whose runtime contributions fail to load.
  * `--json` emits the same report as one JSON document.
  */
 export async function runDoctorCommand(argv: string[] = [], deps: DoctorDeps = {}): Promise<void> {
@@ -518,6 +685,12 @@ export async function runDoctorCommand(argv: string[] = [], deps: DoctorDeps = {
   for (const failure of failures) {
     process.stderr.write(`${FRAMEWORK_NAME}: plugin ${failure.package}: ${failure.reason}\n`);
   }
+  for (const failure of report.claudePluginFailures ?? []) {
+    process.stderr.write(
+      `${FRAMEWORK_NAME}: capability ${failure.capability}: ${failure.reason}\n`,
+    );
+    process.exitCode = 1;
+  }
   if (report.audienceError) {
     process.stderr.write(`${FRAMEWORK_NAME}: ${report.audienceError}\n`);
     process.exitCode = 1;

package/src/cli/commands/plugin/install.ts

@@ -32,6 +32,8 @@ function withDeclaration(
   );
 }
 
+const INSTALL_USAGE = `usage: ${FRAMEWORK_NAME} plugin install <package>[@version]`;
+
 export interface PluginInstallCommandDeps {
   cwd?: string;
   installDeps?: PluginInstallDeps;
@@ -50,10 +52,13 @@ export async function runPluginInstallCommand(
   deps: PluginInstallCommandDeps = {},
 ): Promise<boolean> {
   const spec = argv[0];
-  if (!spec) {
-    process.stderr.write(
-      `${FRAMEWORK_NAME}: usage: ${FRAMEWORK_NAME} plugin install <package>[@version]\n`,
-    );
+  if (spec === "-h" || spec === "--help") {
+    process.stdout.write(`${INSTALL_USAGE}\n`);
+    return true;
+  }
+  if (!spec || spec.startsWith("-")) {
+    const problem = spec ? `unknown option ${spec}; ` : "";
+    process.stderr.write(`${FRAMEWORK_NAME}: ${problem}${INSTALL_USAGE}\n`);
     process.exitCode = 1;
     return false;
   }

package/src/cli/commands/plugin/plugin.ts

@@ -1,13 +1,14 @@
 import { usage } from "../../usage";
-import { runPluginInstallCommand } from "./install";
+import { type PluginInstallCommandDeps, runPluginInstallCommand } from "./install";
 
 export async function runPluginCommand(
   subcommand: string | undefined,
   argv: string[],
+  deps: PluginInstallCommandDeps = {},
 ): Promise<void> {
   switch (subcommand) {
     case "install":
-      await runPluginInstallCommand(argv);
+      if (!(await runPluginInstallCommand(argv, deps))) process.exitCode = 1;
       return;
     default:
       console.error(`Unknown plugin command: ${subcommand ?? ""}`);

package/src/cli/commands/report/adapter.ts

@@ -5,13 +5,21 @@ import type {
   ReportKeyValue,
   ReportMetric,
   ReportSection,
+  ReportStatusTone,
 } from "./types";
 import { REPORT_DOCUMENT_VERSION } from "./types";
 
+/** Collector status strings mapped to tones, so the built-in report never relies on inference. */
+const TOOL_STATUS_TONES: Record<string, ReportStatusTone> = {
+  ok: "ok",
+  "no data": "warn",
+  "no window data": "warn",
+  "not installed": "neutral",
+  "not enabled": "neutral",
+};
+
 export function reportDataToDocument(data: ReportData): ReportDocument {
   const metadata: ReportKeyValue[] = [
-    { label: "Window", value: `Last ${data.days} days` },
-    { label: "Generated", value: data.generatedAt },
     { label: "Working repository", value: data.workingRepoPath },
     { label: "Companion repository", value: data.companionRepoPath },
     { label: "Active agents", value: data.activeAgents.join(", ") || "None" },
@@ -57,6 +65,7 @@ export function reportDataToDocument(data: ReportData): ReportDocument {
       items: data.toolStatus.map((entry) => ({
         label: entry.name,
         status: entry.status,
+        tone: TOOL_STATUS_TONES[entry.status] ?? "neutral",
       })),
     },
   ];

package/src/cli/commands/report/contract.ts

@@ -1,5 +1,7 @@
 import {
   REPORT_DOCUMENT_VERSION,
+  REPORT_STATUS_TONES,
+  REPORT_TEXT_FORMATS,
   type ReportDiagramSection,
   type ReportDiffSection,
   type ReportDocument,
@@ -46,6 +48,21 @@ function requiredString(
   return true;
 }
 
+function optionalEnum(
+  value: unknown,
+  allowed: readonly string[],
+  path: string,
+  issues: ReportValidationIssue[],
+): void {
+  if (value === undefined || allowed.includes(value as string)) return;
+  const list = `${allowed.slice(0, -1).join(", ")}${allowed.length > 2 ? "," : ""} or ${allowed.at(-1)}`;
+  issues.push({ path, message: `must be one of ${list}` });
+}
+
+function optionalCaption(value: unknown, path: string, issues: ReportValidationIssue[]): void {
+  if (value !== undefined) requiredString(value, path, issues);
+}
+
 function validateKeyValues(value: unknown, path: string, issues: ReportValidationIssue[]): boolean {
   if (!Array.isArray(value)) {
     issues.push({ path, message: "must be an array" });
@@ -112,6 +129,7 @@ function validateStatuses(value: unknown, path: string, issues: ReportValidation
     if (item.detail !== undefined && typeof item.detail !== "string") {
       issues.push({ path: `${itemPath}.detail`, message: "must be a string" });
     }
+    optionalEnum(item.tone, REPORT_STATUS_TONES, `${itemPath}.tone`, issues);
   });
   return true;
 }
@@ -209,14 +227,17 @@ function validateSection(value: unknown, path: string, issues: ReportValidationI
       if (typeof value.content !== "string") {
         issues.push({ path: `${path}.content`, message: "must be a string" });
       }
+      optionalEnum(value.format, REPORT_TEXT_FORMATS, `${path}.format`, issues);
       return;
     case "diagram":
       validateDiagram(value, path, issues);
+      optionalCaption(value.caption, `${path}.caption`, issues);
       return;
     case "diff":
       if (typeof value.patch !== "string") {
         issues.push({ path: `${path}.patch`, message: "must be a string" });
       }
+      optionalCaption(value.caption, `${path}.caption`, issues);
       return;
     default:
       issues.push({

package/src/cli/commands/report/highlight.ts

@@ -1,5 +1,12 @@
-import { normalizeLanguage, renderNodesToHtml, renderTokens, tokenize } from "@tanstack/highlight";
-import { createThemeCss } from "@tanstack/highlight/theme";
+import {
+  type HighlightRenderNode,
+  normalizeLanguage,
+  renderNodesToHtml,
+  renderTokens,
+  tokenize,
+} from "@tanstack/highlight";
+import { createThemeCss, createThemeRule } from "@tanstack/highlight/theme";
+import githubDark from "@tanstack/highlight/themes/github-dark";
 import githubLight from "@tanstack/highlight/themes/github-light";
 
 /** Sole boundary against `@tanstack/highlight`, so an upstream API break stays a single-file fix. */
@@ -18,7 +25,30 @@ export function highlightInline(code: string, language: string | undefined): str
   return renderNodesToHtml(renderTokens(tokens));
 }
 
-/** Token colours as an inlinable stylesheet; carries no script, font, or external reference. */
+/**
+ * The same tokens as structure rather than markup, for a renderer that builds elements
+ * and so never holds a markup string. An unknown language yields plain text nodes.
+ */
+export function highlightNodes(
+  code: string,
+  language: string | undefined,
+): ReadonlyArray<HighlightRenderNode> {
+  const { tokens } = tokenize(code, { lang: resolveHighlightLanguage(language) });
+  return renderTokens(tokens);
+}
+
+/**
+ * Token colours as an inlinable stylesheet; carries no script, font, or external reference.
+ * Light by default, dark on screen when the reader prefers it or the page sets
+ * `data-scheme="dark"`, and light in print because both dark rules are screen-only.
+ */
 export function highlightStyleBlock(codeBlockSelector: string): string {
-  return createThemeCss({ light: githubLight, codeBlockSelector });
+  const light = createThemeCss({ light: githubLight, codeBlockSelector });
+  return `${light}
+@media screen and (prefers-color-scheme: dark) {
+${createThemeRule(':root:not([data-scheme="light"])', githubDark)}
+}
+@media screen {
+${createThemeRule(':root[data-scheme="dark"]', githubDark)}
+}`;
 }

package/src/cli/commands/report/markdown.ts

@@ -0,0 +1,110 @@
+import { highlightInline } from "./highlight";
+
+/**
+ * Safe Markdown subset for report text and captions: paragraphs, headings shifted
+ * below the section heading, one-level lists, code spans, strong, emphasis,
+ * `http(s)` links, and highlighted fenced code. Every literal is escaped before
+ * markup is added, so raw HTML and any other syntax degrade to visible text.
+ */
+
+export function escapeHTML(value: string): string {
+  return value.replace(/[&<>"']/g, (character) => {
+    switch (character) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      default:
+        return "&#39;";
+    }
+  });
+}
+
+const FENCE = /^\s{0,3}```\s*([\w+#.-]*)\s*$/;
+const HEADING = /^\s{0,3}(#{1,6})\s+(.*)$/;
+const LIST_ITEM = /^\s{0,3}([-*]|\d+[.)])\s+(.*)$/;
+const INLINE_TOKEN = /`([^`\n]+)`|\[([^\]\n]+)\]\(([^()\s]+)\)/g;
+const SAFE_URL = /^https?:\/\/\S+$/i;
+
+/** Emphasis runs over already-escaped text, which carries no `*` or `_` of its own. */
+function emphasize(escaped: string): string {
+  return escaped
+    .replace(/\*\*(?=\S)([^*]*?\S)\*\*/g, "<strong>$1</strong>")
+    .replace(/\*(?=\S)([^*]*?\S)\*/g, "<em>$1</em>")
+    .replace(/(^|\W)_(?=\S)([^_]*?\S)_(?!\w)/g, "$1<em>$2</em>");
+}
+
+function renderInline(source: string): string {
+  let html = "";
+  let last = 0;
+  for (const match of source.matchAll(INLINE_TOKEN)) {
+    html += emphasize(escapeHTML(source.slice(last, match.index)));
+    const [whole, code, label, url] = match;
+    if (code !== undefined) {
+      html += `<code>${escapeHTML(code)}</code>`;
+    } else if (SAFE_URL.test(url)) {
+      html += `<a href="${escapeHTML(url)}" rel="noopener noreferrer">${emphasize(escapeHTML(label))}</a>`;
+    } else {
+      html += emphasize(escapeHTML(whole));
+    }
+    last = match.index + whole.length;
+  }
+  return html + emphasize(escapeHTML(source.slice(last)));
+}
+
+function renderFence(code: string[], language: string): string {
+  return `<pre class="report-code">${highlightInline(code.join("\n"), language || undefined)}</pre>`;
+}
+
+export function renderMarkdownSubset(source: string): string {
+  const lines = source.replace(/\r\n?/g, "\n").split("\n");
+  const blocks: string[] = [];
+  let paragraph: string[] = [];
+  let list: { tag: "ul" | "ol"; items: string[] } | undefined;
+
+  const flush = (): void => {
+    if (paragraph.length) blocks.push(`<p>${paragraph.map(renderInline).join("\n")}</p>`);
+    if (list) blocks.push(`<${list.tag}>${list.items.join("")}</${list.tag}>`);
+    paragraph = [];
+    list = undefined;
+  };
+
+  for (let index = 0; index < lines.length; index++) {
+    const line = lines[index];
+    const fence = FENCE.exec(line);
+    if (fence) {
+      flush();
+      const code: string[] = [];
+      while (++index < lines.length && !FENCE.test(lines[index])) code.push(lines[index]);
+      blocks.push(renderFence(code, fence[1]));
+      continue;
+    }
+    if (line.trim() === "") {
+      flush();
+      continue;
+    }
+    const heading = HEADING.exec(line);
+    if (heading) {
+      flush();
+      const level = Math.min(heading[1].length + 2, 6);
+      blocks.push(`<h${level}>${renderInline(heading[2].trim())}</h${level}>`);
+      continue;
+    }
+    const item = LIST_ITEM.exec(line);
+    if (item) {
+      const tag = /\d/.test(item[1]) ? "ol" : "ul";
+      if (paragraph.length || (list && list.tag !== tag)) flush();
+      list ??= { tag, items: [] };
+      list.items.push(`<li>${renderInline(item[2])}</li>`);
+      continue;
+    }
+    if (list) flush();
+    paragraph.push(line);
+  }
+  flush();
+  return blocks.join("");
+}