mcp-context-card 0.5.0

package/dist/card-gen.js

@@ -0,0 +1,14 @@
+/**
+ * card-gen - write docs/card.html from the three sources, so the card is
+ * browsable on GitHub and screenshot-able for the README. Same renderer as
+ * GET /card and the render_context_card tool.
+ */
+import { writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { renderCard } from "./render-card.js";
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+    writeFileSync(join(root, "docs/card.html"), renderCard(root));
+    console.log("wrote docs/card.html — the context card, rendered from AGENTS.md / project.fafm / .well-known/fafa");
+}

package/dist/catalog-gen.d.ts

@@ -0,0 +1,26 @@
+export declare function buildCatalog(root: string): {
+    specVersion: string;
+    host: {
+        displayName: string;
+        identifier: string;
+    };
+    entries: ({
+        identifier: string;
+        displayName: string;
+        type: string;
+        mediaType: string;
+        description: string;
+        url: string;
+        _meta?: undefined;
+    } | {
+        identifier: string;
+        displayName: string;
+        type: string;
+        mediaType: string;
+        description: string;
+        url: string;
+        _meta: {
+            "io.github.wolfe-jam.mcp-context-card/iana": string;
+        };
+    })[];
+};

package/dist/catalog-gen.js

@@ -0,0 +1,72 @@
+/**
+ * catalog-gen — write `.well-known/ai-catalog.json` FROM the three sources
+ * (`AGENTS.md`, `project.fafm`, `.well-known/fafa`) that also back the Server
+ * Card `_meta` block. Same three artifacts, second exposure mechanism.
+ *
+ * Descriptions are derived from real file content (section count, fact count,
+ * the agent's own description) — not hand-written blurbs that drift. The CI
+ * job `catalog:check` regenerates this and fails on any diff.
+ */
+import { writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { parseAgentsMd } from "./agents-md.js";
+import { parseFafm } from "./faf/parse-fafm.js";
+import { parseFafa } from "./faf/parse-fafa.js";
+import { META_NS } from "./identity.js";
+const iana = (t) => `https://www.iana.org/assignments/media-types/${t}`;
+export function buildCatalog(root) {
+    const agents = parseAgentsMd(join(root, "AGENTS.md"));
+    const fafm = parseFafm(join(root, "project.fafm"));
+    const fafa = parseFafa(join(root, ".well-known/fafa"));
+    const host = fafa?.name ?? "mcp-context-card";
+    return {
+        specVersion: "1.0",
+        host: {
+            displayName: host,
+            identifier: "https://github.com/Wolfe-Jam/mcp-context-card",
+        },
+        entries: [
+            {
+                identifier: `urn:air:${host}:context`,
+                displayName: `${host} — project context (AGENTS.md)`,
+                type: "text/markdown",
+                mediaType: "text/markdown",
+                description: agents
+                    ? (() => {
+                        const h = agents.sections.filter((s) => s.level > 1).map((s) => s.heading);
+                        return `Agent instructions for this project — ${h.length} section(s): ${h
+                            .slice(0, 6)
+                            .join(", ")}${h.length > 6 ? ", …" : ""}.`;
+                    })()
+                    : "Agent instructions for this project (AGENTS.md — not present).",
+                url: "./AGENTS.md",
+            },
+            {
+                identifier: `urn:air:${host}:memory`,
+                displayName: `${host} — persistent memory (.fafm)`,
+                type: "application/vnd.fafm+yaml",
+                mediaType: "application/vnd.fafm+yaml",
+                description: `Cross-session memory — ${fafm.facts.length} fact(s), profile "${fafm.profile ?? "?"}". Recall survives a process restart. No de-facto standard for this concern yet.`,
+                url: "./project.fafm",
+                _meta: { [`${META_NS}/iana`]: iana("application/vnd.fafm+yaml") },
+            },
+            {
+                identifier: `urn:air:${host}:identity`,
+                displayName: `${host} — agent identity (.fafa)`,
+                type: "application/vnd.fafa+yaml",
+                mediaType: "application/vnd.fafa+yaml",
+                description: fafa?.description ??
+                    `Agent identity card (status: ${fafa?.status ?? "unknown"}).`,
+                url: "./.well-known/fafa",
+                _meta: { [`${META_NS}/iana`]: iana("application/vnd.fafa+yaml") },
+            },
+        ],
+    };
+}
+// Direct run → write the file.
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const root = join(dirname(fileURLToPath(import.meta.url)), "..");
+    writeFileSync(join(root, ".well-known/ai-catalog.json"), JSON.stringify(buildCatalog(root), null, 2) + "\n");
+    console.log("wrote .well-known/ai-catalog.json — 3 sibling entries, derived from AGENTS.md / project.fafm / .well-known/fafa");
+}

package/dist/constants.d.ts

@@ -0,0 +1,5 @@
+/** Server identity constants, in their own module so any file can import
+ *  them without pulling in the whole server. */
+export declare const NAME = "mcp-context-card";
+export declare const VERSION = "0.5.0";
+export declare const SERVER_CARD_URI = "mcp-context-card://server-card";

package/dist/constants.js

@@ -0,0 +1,5 @@
+/** Server identity constants, in their own module so any file can import
+ *  them without pulling in the whole server. */
+export const NAME = "mcp-context-card";
+export const VERSION = "0.5.0";
+export const SERVER_CARD_URI = "mcp-context-card://server-card";

package/dist/faf/parse-fafa.d.ts

@@ -0,0 +1,2 @@
+import type { AgentIdentity } from "./types.js";
+export declare function parseFafa(path: string): AgentIdentity | null;

package/dist/faf/parse-fafa.js

@@ -0,0 +1,32 @@
+/**
+ * parse-fafa — read a `.fafa` agent identity card into a typed shape.
+ * `application/vnd.fafa+yaml` — yaml, parsed as yaml.
+ */
+import { readFileSync } from "node:fs";
+import { parse } from "yaml";
+export function parseFafa(path) {
+    let doc;
+    try {
+        doc = parse(readFileSync(path, "utf8")) ?? {};
+    }
+    catch {
+        return null;
+    }
+    const agent = doc.agent ?? {};
+    return {
+        version: str(doc.version),
+        name: str(agent.name),
+        displayName: str(agent.displayName),
+        vendor: str(agent.vendor),
+        agentVersion: str(agent.version),
+        description: str(agent.description),
+        status: str(agent.status),
+        license: str(agent.license),
+    };
+}
+function str(v) {
+    if (v === undefined || v === null)
+        return undefined;
+    const s = String(v).trim().replace(/\s+/g, " ");
+    return s.length ? s : undefined;
+}

package/dist/faf/parse-fafm.d.ts

@@ -0,0 +1,7 @@
+import type { Memory, MemoryFact } from "./types.js";
+export declare function parseFafm(path: string): Memory;
+export declare function recall(path: string, id: string): MemoryFact | null;
+/** Add a fact, or update its text in place if the id already exists. */
+export declare function remember(path: string, id: string, text: string): void;
+/** Remove a fact by id. Returns true if one was removed. */
+export declare function forget(path: string, id: string): boolean;

package/dist/faf/parse-fafm.js

@@ -0,0 +1,119 @@
+/**
+ * parse-fafm — read and write a `.fafm` file (persistent memory).
+ *
+ * Uses the `yaml` package's Document API so remember()/recall() edit the
+ * file structurally and stringify back with comments and layout intact.
+ * This file is dogfood memory about the repo's own build — the header
+ * comments matter, and a `git diff` after a `remember()` should show only
+ * the fact that was added, not a whole-file reformat.
+ */
+import { readFileSync, writeFileSync } from "node:fs";
+import { parseDocument, Scalar, YAMLSeq, YAMLMap } from "yaml";
+/** Stringify options that keep the file stable across edits. */
+const OUT = {
+    lineWidth: 0, // never fold long scalars onto new lines
+    flowCollectionPadding: false, // `["a","b"]`, not `[ "a", "b" ]`
+};
+/** A double-quoted string scalar — the .fafm/.fafa house convention. */
+function q(v) {
+    const s = new Scalar(v);
+    s.type = Scalar.QUOTE_DOUBLE;
+    return s;
+}
+/** A YAMLMap with every string value double-quoted. */
+function factMap(entries) {
+    const m = new YAMLMap();
+    for (const [k, v] of Object.entries(entries))
+        m.set(k, q(v));
+    return m;
+}
+function load(path) {
+    return parseDocument(readFileSync(path, "utf8"));
+}
+export function parseFafm(path) {
+    let doc;
+    try {
+        doc = load(path);
+        if (doc.errors.length)
+            return { facts: [] };
+    }
+    catch {
+        return { facts: [] };
+    }
+    let facts = [];
+    try {
+        const seq = doc.getIn(["memory", "facts"], true);
+        const j = seq?.toJSON?.();
+        if (Array.isArray(j))
+            facts = j;
+    }
+    catch {
+        /* leave facts empty */
+    }
+    return {
+        version: doc.get("version"),
+        profile: doc.get("profile"),
+        namepoint: doc.get("namepoint"),
+        facts: facts.map(normFact),
+    };
+}
+export function recall(path, id) {
+    return parseFafm(path).facts.find((f) => f.id === id) ?? null;
+}
+/** Add a fact, or update its text in place if the id already exists. */
+export function remember(path, id, text) {
+    const doc = load(path);
+    let facts = doc.getIn(["memory", "facts"], true);
+    if (!facts) {
+        if (!doc.has("memory"))
+            doc.set("memory", new YAMLMap());
+        facts = new YAMLSeq();
+        doc.getIn(["memory"], true).set("facts", facts);
+    }
+    const now = new Date().toISOString();
+    for (const item of facts.items) {
+        if (item.get("id") === id) {
+            item.set("text", q(text));
+            item.set("verification_status", q("unverified"));
+            doc.set("last_etched", q(now));
+            writeFileSync(path, doc.toString(OUT));
+            return;
+        }
+    }
+    facts.add(factMap({
+        text,
+        id,
+        type: "session",
+        priority: "standard",
+        source: "remember()",
+        verification_status: "unverified",
+    }));
+    doc.set("last_etched", q(now));
+    writeFileSync(path, doc.toString(OUT));
+}
+/** Remove a fact by id. Returns true if one was removed. */
+export function forget(path, id) {
+    const doc = load(path);
+    const facts = doc.getIn(["memory", "facts"], true);
+    if (!facts)
+        return false;
+    const idx = facts.items.findIndex((it) => it.get("id") === id);
+    if (idx === -1)
+        return false;
+    facts.delete(idx);
+    doc.set("last_etched", q(new Date().toISOString()));
+    writeFileSync(path, doc.toString(OUT));
+    return true;
+}
+function normFact(f) {
+    const o = (f ?? {});
+    return {
+        id: String(o.id ?? ""),
+        text: String(o.text ?? ""),
+        type: o.type,
+        priority: o.priority,
+        tags: Array.isArray(o.tags) ? o.tags.map(String) : undefined,
+        source: o.source,
+        verification_status: o.verification_status,
+    };
+}

package/dist/faf/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared types for the two FAF-family formats this server reads.
+ * These are the minimal shapes mcp-context-card needs — not the full specs.
+ * Full specs: application/vnd.fafm+yaml, application/vnd.fafa+yaml
+ * (both IANA-registered).
+ */
+/** One `.fafm` fact. */
+export interface MemoryFact {
+    id: string;
+    text: string;
+    type?: string;
+    priority?: string;
+    tags?: string[];
+    source?: string;
+    verification_status?: string;
+}
+/** A parsed `.fafm` — persistent memory. */
+export interface Memory {
+    version?: string;
+    profile?: string;
+    namepoint?: string;
+    facts: MemoryFact[];
+}
+/** A parsed `.fafa` — agent identity card. */
+export interface AgentIdentity {
+    version?: string;
+    name?: string;
+    displayName?: string;
+    vendor?: string;
+    agentVersion?: string;
+    description?: string;
+    status?: string;
+    license?: string;
+}

package/dist/faf/types.js

@@ -0,0 +1,7 @@
+/**
+ * Shared types for the two FAF-family formats this server reads.
+ * These are the minimal shapes mcp-context-card needs — not the full specs.
+ * Full specs: application/vnd.fafm+yaml, application/vnd.fafa+yaml
+ * (both IANA-registered).
+ */
+export {};

package/dist/identity.d.ts

@@ -0,0 +1,35 @@
+import type { AgentIdentity } from "./faf/types.js";
+/** The `_meta` key namespace — the publisher's, reverse-DNS. */
+export declare const META_NS = "io.github.wolfe-jam.mcp-context-card";
+export declare function identity(root: string): AgentIdentity | null;
+/**
+ * The identity to show: the `.well-known/fafa` card if present — richer and
+ * portable — else a thin one from `package.json` (the common project has no
+ * `.fafa`). null only when neither exists.
+ */
+export declare function resolveIdentity(root: string): AgentIdentity | null;
+/** Human-readable one-liner for the `whoami` tool. */
+export declare function whoami(root: string): string;
+/**
+ * The `_meta` context block — one namespaced key per concern. The `context`
+ * concern points at `AGENTS.md` (the de-facto standard, plain Markdown). The
+ * other two point at their worked-example artifacts; `memory` carries a note
+ * because there is no de-facto standard for it yet.
+ */
+export declare function trinityMeta(): {
+    readonly "io.github.wolfe-jam.mcp-context-card/context": {
+        readonly source: "AGENTS.md";
+        readonly mediaType: "text/markdown";
+    };
+    readonly "io.github.wolfe-jam.mcp-context-card/memory": {
+        readonly source: "project.fafm";
+        readonly mediaType: "application/vnd.fafm+yaml";
+        readonly iana: string;
+        readonly note: "no de-facto standard for agent memory yet — this is one instantiation";
+    };
+    readonly "io.github.wolfe-jam.mcp-context-card/identity": {
+        readonly source: ".well-known/fafa";
+        readonly mediaType: "application/vnd.fafa+yaml";
+        readonly iana: string;
+    };
+};

package/dist/identity.js

@@ -0,0 +1,82 @@
+/**
+ * identity — reads this server's own `.well-known/fafa` and reports it, and
+ * builds the `_meta` context block for the Server Card.
+ *
+ * The `_meta` block is three reverse-DNS-namespaced keys — one per concern
+ * (context, memory, identity) — each naming a source file, its media type,
+ * and (where one exists) its IANA anchor. Same shape a real client reading
+ * the Server Card would consume; see server.ts for where it's emitted.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseFafa } from "./faf/parse-fafa.js";
+/** The `_meta` key namespace — the publisher's, reverse-DNS. */
+export const META_NS = "io.github.wolfe-jam.mcp-context-card";
+const iana = (t) => `https://www.iana.org/assignments/media-types/${t}`;
+export function identity(root) {
+    return parseFafa(join(root, ".well-known/fafa"));
+}
+/** Fall back to package.json — most projects have no .fafa, but they have this. */
+function fromPackageJson(root) {
+    try {
+        const p = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+        if (!p.name)
+            return null;
+        return {
+            name: String(p.name),
+            agentVersion: p.version ? String(p.version) : undefined,
+            license: p.license ? String(p.license) : undefined,
+            description: p.description ? String(p.description) : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The identity to show: the `.well-known/fafa` card if present — richer and
+ * portable — else a thin one from `package.json` (the common project has no
+ * `.fafa`). null only when neither exists.
+ */
+export function resolveIdentity(root) {
+    return identity(root) ?? fromPackageJson(root);
+}
+/** Human-readable one-liner for the `whoami` tool. */
+export function whoami(root) {
+    const id = resolveIdentity(root);
+    if (!id)
+        return "(no .well-known/fafa or package.json found)";
+    const parts = [
+        id.displayName ?? id.name ?? "(unnamed)",
+        id.agentVersion ? `v${id.agentVersion}` : null,
+        id.vendor ? `vendor: ${id.vendor}` : null,
+        id.status ? `status: ${id.status}` : null,
+        id.license ? id.license : null,
+    ].filter(Boolean);
+    return parts.join(" · ") + (id.description ? `\n${id.description}` : "");
+}
+/**
+ * The `_meta` context block — one namespaced key per concern. The `context`
+ * concern points at `AGENTS.md` (the de-facto standard, plain Markdown). The
+ * other two point at their worked-example artifacts; `memory` carries a note
+ * because there is no de-facto standard for it yet.
+ */
+export function trinityMeta() {
+    return {
+        [`${META_NS}/context`]: {
+            source: "AGENTS.md",
+            mediaType: "text/markdown",
+        },
+        [`${META_NS}/memory`]: {
+            source: "project.fafm",
+            mediaType: "application/vnd.fafm+yaml",
+            iana: iana("application/vnd.fafm+yaml"),
+            note: "no de-facto standard for agent memory yet — this is one instantiation",
+        },
+        [`${META_NS}/identity`]: {
+            source: ".well-known/fafa",
+            mediaType: "application/vnd.fafa+yaml",
+            iana: iana("application/vnd.fafa+yaml"),
+        },
+    };
+}

package/dist/md.d.ts

@@ -0,0 +1,22 @@
+/**
+ * md - a minimal Markdown to HTML renderer, dependency-free.
+ *
+ * Covers exactly what an AGENTS.md uses: ATX headings, paragraphs, fenced
+ * code, unordered / ordered lists (one nested level), GFM tables,
+ * blockquotes, horizontal rules, and inline bold / italic / code / links.
+ * Anything it does not recognise becomes an escaped paragraph. It never
+ * throws and never emits an unescaped angle bracket.
+ *
+ * Not spec-compliant CommonMark. If a project's AGENTS.md outgrows it,
+ * swap in `marked`.
+ */
+export declare function escapeHtml(s: string): string;
+/** kebab slug for a heading id */
+export declare function slug(s: string): string;
+/**
+ * Inline pass: escape first, then pull out code spans as HTML-comment
+ * placeholders (impossible in escaped text), then links -> bold -> italic,
+ * then restore the code spans. ASCII throughout.
+ */
+export declare function renderInline(src: string): string;
+export declare function renderMarkdown(src: string): string;

package/dist/md.js

@@ -0,0 +1,186 @@
+/**
+ * md - a minimal Markdown to HTML renderer, dependency-free.
+ *
+ * Covers exactly what an AGENTS.md uses: ATX headings, paragraphs, fenced
+ * code, unordered / ordered lists (one nested level), GFM tables,
+ * blockquotes, horizontal rules, and inline bold / italic / code / links.
+ * Anything it does not recognise becomes an escaped paragraph. It never
+ * throws and never emits an unescaped angle bracket.
+ *
+ * Not spec-compliant CommonMark. If a project's AGENTS.md outgrows it,
+ * swap in `marked`.
+ */
+export function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+/** kebab slug for a heading id */
+export function slug(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^\w\s-]/g, "")
+        .trim()
+        .replace(/\s+/g, "-");
+}
+const SAFE_URL = /^(https?:|mailto:|#|\.?\/)/i;
+/**
+ * Inline pass: escape first, then pull out code spans as HTML-comment
+ * placeholders (impossible in escaped text), then links -> bold -> italic,
+ * then restore the code spans. ASCII throughout.
+ */
+export function renderInline(src) {
+    const codes = [];
+    let s = escapeHtml(src).replace(/`([^`]+)`/g, (_m, c) => {
+        codes.push("<code>" + c + "</code>");
+        return "<!--c" + (codes.length - 1) + "-->";
+    });
+    s = s.replace(/\[([^\]]+)\]\(([^)\s]+)\)/g, (_m, text, url) => {
+        // url is already escaped; &amp; is valid inside an href
+        return SAFE_URL.test(String(url).replace(/&amp;/g, "&"))
+            ? '<a href="' + url + '">' + text + "</a>"
+            : text;
+    });
+    s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+    s = s.replace(/__([^_]+)__/g, "<strong>$1</strong>");
+    s = s.replace(/(^|[^*])\*([^*\s][^*]*?)\*(?!\*)/g, "$1<em>$2</em>");
+    s = s.replace(/(^|[^\w])_([^_\s][^_]*?)_(?![\w])/g, "$1<em>$2</em>");
+    s = s.replace(/<!--c(\d+)-->/g, (_m, i) => codes[Number(i)] ?? "");
+    return s;
+}
+const HEADING = /^(#{1,6})\s+(.+?)\s*#*\s*$/;
+const FENCE = /^(\s*)(```+|~~~+)(.*)$/;
+const HR = /^ {0,3}([-*_])(?: *\1){2,} *$/;
+const LI = /^(\s*)([-*+]|\d+[.)])\s+(.*)$/;
+const TABLE_SEP = /^\s*\|?[\s:|-]*-[\s:|-]*\|?\s*$/;
+function tableRow(line) {
+    return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+}
+export function renderMarkdown(src) {
+    const lines = src.replace(/\r\n/g, "\n").split("\n");
+    const out = [];
+    let i = 0;
+    const flushPara = (buf) => {
+        if (buf.length)
+            out.push("<p>" + renderInline(buf.join(" ").trim()) + "</p>");
+        buf.length = 0;
+    };
+    while (i < lines.length) {
+        const line = lines[i];
+        if (!line.trim()) {
+            i++;
+            continue;
+        }
+        // fenced code
+        const fence = line.match(FENCE);
+        if (fence) {
+            const close = fence[2][0] === "`" ? /^\s*```+\s*$/ : /^\s*~~~+\s*$/;
+            const lang = fence[3].trim();
+            const body = [];
+            i++;
+            while (i < lines.length && !close.test(lines[i])) {
+                body.push(lines[i]);
+                i++;
+            }
+            i++; // closing fence
+            const cls = lang ? ' class="language-' + escapeHtml(lang) + '"' : "";
+            out.push("<pre><code" + cls + ">" + escapeHtml(body.join("\n")) + "</code></pre>");
+            continue;
+        }
+        // heading
+        const h = line.match(HEADING);
+        if (h) {
+            const n = h[1].length;
+            out.push("<h" + n + ' id="' + slug(h[2]) + '">' + renderInline(h[2].trim()) + "</h" + n + ">");
+            i++;
+            continue;
+        }
+        // hr
+        if (HR.test(line)) {
+            out.push("<hr>");
+            i++;
+            continue;
+        }
+        // blockquote
+        if (/^\s*>/.test(line)) {
+            const inner = [];
+            while (i < lines.length && /^\s*>/.test(lines[i])) {
+                inner.push(lines[i].replace(/^\s*>\s?/, ""));
+                i++;
+            }
+            out.push("<blockquote>" + renderMarkdown(inner.join("\n")) + "</blockquote>");
+            continue;
+        }
+        // table
+        if (line.includes("|") && i + 1 < lines.length && TABLE_SEP.test(lines[i + 1])) {
+            const head = tableRow(line);
+            i += 2;
+            const rows = [];
+            while (i < lines.length && lines[i].includes("|") && lines[i].trim()) {
+                rows.push(tableRow(lines[i]));
+                i++;
+            }
+            const th = head.map((c) => "<th>" + renderInline(c) + "</th>").join("");
+            const trs = rows
+                .map((r) => "<tr>" + r.map((c) => "<td>" + renderInline(c) + "</td>").join("") + "</tr>")
+                .join("");
+            out.push("<table><thead><tr>" + th + "</tr></thead><tbody>" + trs + "</tbody></table>");
+            continue;
+        }
+        // list (one nested level)
+        if (LI.test(line)) {
+            const first = line.match(LI);
+            const tag = /\d/.test(first[2]) ? "ol" : "ul";
+            const items = [];
+            let baseIndent = first[1].length;
+            let cur = null;
+            const push = () => {
+                if (cur) {
+                    const subHtml = cur.sub.length ? renderMarkdown(cur.sub.join("\n")) : "";
+                    items.push("<li>" + renderInline(cur.text.join(" ").trim()) + subHtml + "</li>");
+                    cur = null;
+                }
+            };
+            while (i < lines.length) {
+                const m = lines[i].match(LI);
+                if (m && m[1].length <= baseIndent + 1) {
+                    push();
+                    baseIndent = m[1].length;
+                    cur = { text: [m[3]], sub: [] };
+                    i++;
+                }
+                else if (m && cur) {
+                    cur.sub.push(lines[i].slice(baseIndent + 2));
+                    i++;
+                }
+                else if (lines[i].trim() && cur && !HEADING.test(lines[i]) && !FENCE.test(lines[i])) {
+                    cur.text.push(lines[i].trim());
+                    i++;
+                }
+                else {
+                    break;
+                }
+            }
+            push();
+            out.push("<" + tag + ">" + items.join("") + "</" + tag + ">");
+            continue;
+        }
+        // paragraph
+        const buf = [];
+        while (i < lines.length &&
+            lines[i].trim() &&
+            !HEADING.test(lines[i]) &&
+            !FENCE.test(lines[i]) &&
+            !HR.test(lines[i]) &&
+            !LI.test(lines[i]) &&
+            !/^\s*>/.test(lines[i]) &&
+            !(lines[i].includes("|") && i + 1 < lines.length && TABLE_SEP.test(lines[i + 1]))) {
+            buf.push(lines[i]);
+            i++;
+        }
+        flushPara(buf);
+    }
+    return out.join("\n");
+}