viveworker 0.8.0 → 0.8.2

package/scripts/a2a-executor.mjs

@@ -10,6 +10,7 @@ import { spawn, spawnSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import os from "node:os";
+import { Blob, File } from "node:buffer";
 import { completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
 
 const APP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
@@ -176,13 +177,39 @@ export async function executeA2ATask(task, config, runtime, state, { recordTimel
     executor = available.codex ? "codex" : available.claude ? "claude" : "codex";
   }
 
-  console.log(`[a2a-exec] Starting task ${task.id} via ${executor}: ${instruction.slice(0, 80)}`);
+  const executionOptions = resolveA2AExecutionOptions(task, config, executor);
+  const executionInstruction = buildA2AExecutionInstruction(instruction, task);
+
+  console.log(
+    `[a2a-exec] Starting task ${task.id} via ${executor}${executionOptions.model ? ` model=${executionOptions.model}` : ""}: ${instruction.slice(0, 80)}`
+  );
 
   try {
     const result = executor === "claude"
-      ? await runClaudeExec(instruction)
-      : await runCodexExec(instruction, config);
-    completeA2ATask(task, result);
+      ? await runClaudeExec(executionInstruction, executionOptions)
+      : await runCodexExec(executionInstruction, config, executionOptions);
+
+    if (shouldUploadPaidDeliverable(task)) {
+      const paidShare = await uploadPaidA2ADeliverable({ config, task, resultText: result });
+      const responseText = buildPaidUnlockResponse({ task, paidShare });
+      completeA2ATask(task, responseText);
+      task.paidDeliverable = paidShare;
+      if (task.artifacts?.[0]) {
+        task.artifacts[0].name = "x402 unlockable deliverable";
+        task.artifacts[0].metadata = {
+          viveworker: {
+            mode: "x402-pro",
+            url: paidShare.url,
+            slug: paidShare.slug,
+            price: paidShare.price,
+            payTo: paidShare.payTo,
+            network: paidShare.network,
+          },
+        };
+      }
+    } else {
+      completeA2ATask(task, result);
+    }
     console.log(`[a2a-exec] Task ${task.id} completed via ${executor} (${result.length} chars)`);
   } catch (error) {
     failA2ATask(task, error.message);
@@ -206,6 +233,8 @@ export async function executeA2ATask(task, config, runtime, state, { recordTimel
     messageText: task.status === "completed"
       ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 500)
       : task.statusMessage || "Failed",
+    viveworker: task.viveworker || {},
+    paidDeliverable: task.paidDeliverable || null,
     taskStatus: task.status,
     createdAtMs: task.updatedAtMs || Date.now(),
     readOnly: true,
@@ -237,6 +266,16 @@ export async function executeA2ATask(task, config, runtime, state, { recordTimel
         stableId: `a2a_task_result:${task.id}`,
         title: `A2A ${icon}: ${instruction.slice(0, 60)}`,
         body: resultBody || instruction.slice(0, 160),
+        buildLocalizedContent: ({ locale }) => {
+          const lang = locale?.startsWith("ja") ? "ja" : "en";
+          const instructionSnippet = instruction.slice(0, 60);
+          return {
+            title: isCompleted
+              ? (lang === "ja" ? `A2A 完了: ${instructionSnippet}` : `A2A completed: ${instructionSnippet}`)
+              : (lang === "ja" ? `A2A 失敗: ${instructionSnippet}` : `A2A failed: ${instructionSnippet}`),
+            body: resultBody || instruction.slice(0, 160),
+          };
+        },
       });
     } catch (error) {
       console.error(`[a2a-exec-push] ${error.message}`);
@@ -244,13 +283,225 @@ export async function executeA2ATask(task, config, runtime, state, { recordTimel
   }
 }
 
+export function resolveA2AExecutionOptions(task, config, executor) {
+  const spec = task?.viveworker || {};
+  const requestedModel = cleanText(spec.requestedModel || "");
+  const tier = cleanText(spec.requestedTier || "");
+  const proModel = cleanText(config?.a2aProModel || process.env.A2A_PRO_MODEL || "");
+  return {
+    model: requestedModel || (tier === "pro" ? proModel : ""),
+    tier,
+    executor,
+  };
+}
+
+export function buildA2AExecutionInstruction(instruction, task) {
+  const spec = task?.viveworker || {};
+  const tier = cleanText(spec.requestedTier || "");
+  if (tier !== "pro") {
+    return instruction;
+  }
+  const deliverableType = cleanText(spec.deliverableType || "research brief");
+  return [
+    "You are completing a paid A2A Pro deliverable.",
+    `Deliverable type: ${deliverableType}.`,
+    "Prioritize accuracy, clear structure, and actionable conclusions. Do not mention internal account tiers or subscription access.",
+    "",
+    instruction,
+  ].join("\n");
+}
+
+export function shouldUploadPaidDeliverable(task) {
+  return task?.viveworker?.paidDeliverable === true || cleanText(task?.viveworker?.mode || "") === "x402-pro";
+}
+
+function resolvePaidShareSpec(config, task) {
+  const spec = task?.viveworker || {};
+  const payment = spec.payment || {};
+  const price = cleanText(payment.price || config?.a2aProPrice || process.env.A2A_PRO_PRICE || "");
+  const payTo = cleanText(payment.payTo || config?.a2aProPayTo || process.env.A2A_PRO_PAY_TO || "");
+  const expiresDaysRaw = cleanText(spec.expiresDays || config?.a2aProExpiresDays || process.env.A2A_PRO_EXPIRES_DAYS || "7");
+  const expiresDays = Number(expiresDaysRaw);
+  if (!price || !payTo) {
+    throw new Error("x402-pro task requires price and payTo metadata, or A2A_PRO_PRICE and A2A_PRO_PAY_TO");
+  }
+  if (payment.invalid === true) {
+    throw new Error(`invalid x402 payment metadata: ${payment.reason || "invalid-payment"}`);
+  }
+  if (!/^\d+(\.\d{1,6})?$/u.test(price)) {
+    throw new Error("x402-pro price must be a decimal with up to 6 fractional digits");
+  }
+  if (!/^0x[0-9a-fA-F]{40}$/u.test(payTo)) {
+    throw new Error("x402-pro payTo must be a 0x-prefixed EVM address");
+  }
+  return {
+    price,
+    payTo,
+    expiresDays: Number.isFinite(expiresDays) && expiresDays > 0 && expiresDays <= 30 ? String(expiresDays) : "7",
+  };
+}
+
+export async function uploadPaidA2ADeliverable({ config, task, resultText }) {
+  const userId = cleanText(config?.a2aRelayUserId || "");
+  const apiKey = cleanText(config?.a2aApiKey || "");
+  const shareUrl = cleanText(config?.a2aShareUrl || process.env.VIVEWORKER_SHARE_URL || "https://share.viveworker.com").replace(/\/+$/u, "");
+  if (!userId || !apiKey) {
+    throw new Error("A2A credentials are required to upload paid deliverables");
+  }
+  const paidSpec = resolvePaidShareSpec(config, task);
+  const html = buildPaidDeliverableHtml({ task, resultText, paidSpec });
+  const form = new FormData();
+  const safeTaskId = cleanText(task?.id || "task").replace(/[^a-z0-9_-]+/giu, "-").slice(0, 64) || "task";
+  const file = new File(
+    [new Blob([html], { type: "text/html; charset=utf-8" })],
+    `a2a-${safeTaskId}-deliverable.html`,
+    { type: "text/html; charset=utf-8" }
+  );
+  form.set("file", file);
+  form.set("price", paidSpec.price);
+  form.set("payTo", paidSpec.payTo);
+  form.set("expiresDays", paidSpec.expiresDays);
+
+  const response = await fetchWithTimeout(`${shareUrl}/api/upload`, {
+    method: "POST",
+    headers: {
+      "x-a2a-user": userId,
+      "x-a2a-key": apiKey,
+    },
+    body: form,
+  }, 60_000);
+  const body = await readJson(response);
+  if (!response.ok || body?.error) {
+    throw new Error(`paid deliverable upload failed: ${formatApiError(response.status, body)}`);
+  }
+  return {
+    url: body.url,
+    slug: body.slug,
+    price: body.price ? formatUsdcAtomic(body.price) : paidSpec.price,
+    priceAtomic: body.price || "",
+    payTo: body.payTo || paidSpec.payTo,
+    network: body.network || "",
+    expiresAtMs: body.expiresAtMs || 0,
+  };
+}
+
+export function buildPaidUnlockResponse({ task, paidShare }) {
+  const deliverableType = cleanText(task?.viveworker?.deliverableType || "deliverable");
+  return [
+    `A2A Pro ${deliverableType} is ready.`,
+    "",
+    `Unlock URL: ${paidShare.url}`,
+    `Price: ${paidShare.price} USDC${paidShare.network ? ` on ${paidShare.network}` : ""}`,
+    `Pay to: ${paidShare.payTo}`,
+    "",
+    "Open the URL with an x402-compatible client or browser flow to pay and receive the result.",
+  ].join("\n");
+}
+
+function buildPaidDeliverableHtml({ task, resultText, paidSpec }) {
+  const title = `A2A Pro Deliverable`;
+  const instruction = cleanText(task?.instruction || "");
+  const created = new Date().toISOString();
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(title)}</title>
+  <style>
+    :root { color-scheme: dark; --bg: #081015; --card: #121d24; --text: #eef7fb; --muted: #9fb3bf; --line: rgba(255,255,255,.12); --accent: #7dd3fc; }
+    body { margin: 0; background: radial-gradient(circle at 20% 0%, rgba(55, 211, 153, .16), transparent 34%), var(--bg); color: var(--text); font: 16px/1.65 -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; }
+    main { max-width: 860px; margin: 0 auto; padding: 56px 22px 72px; }
+    .badge { display: inline-flex; border: 1px solid var(--line); border-radius: 999px; padding: 6px 12px; color: var(--accent); font-weight: 700; letter-spacing: .02em; }
+    h1 { font-size: clamp(34px, 7vw, 64px); line-height: .96; letter-spacing: -.055em; margin: 24px 0 16px; }
+    .meta, .prompt, .result { background: rgba(18, 29, 36, .86); border: 1px solid var(--line); border-radius: 24px; padding: 22px; margin-top: 18px; box-shadow: 0 24px 80px rgba(0,0,0,.28); }
+    .meta { color: var(--muted); }
+    .meta strong { color: var(--text); }
+    pre { white-space: pre-wrap; word-break: break-word; margin: 0; font: inherit; }
+    h2 { margin: 0 0 10px; font-size: 18px; color: var(--accent); }
+  </style>
+</head>
+<body>
+  <main>
+    <span class="badge">viveworker A2A Pro</span>
+    <h1>Paid agent deliverable</h1>
+    <section class="meta">
+      <div><strong>Task:</strong> ${escapeHtml(task?.id || "")}</div>
+      <div><strong>Created:</strong> ${escapeHtml(created)}</div>
+      <div><strong>Price:</strong> ${escapeHtml(paidSpec.price)} USDC</div>
+      <div><strong>Pay to:</strong> ${escapeHtml(paidSpec.payTo)}</div>
+    </section>
+    <section class="prompt">
+      <h2>Request</h2>
+      <pre>${escapeHtml(instruction)}</pre>
+    </section>
+    <section class="result">
+      <h2>Result</h2>
+      <pre>${escapeHtml(resultText)}</pre>
+    </section>
+  </main>
+</body>
+</html>`;
+}
+
+async function readJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return {};
+  }
+}
+
+function formatApiError(status, body) {
+  const error = cleanText(body?.error || body?.message || "");
+  const hint = cleanText(body?.hint || "");
+  return [`HTTP ${status}`, error, hint].filter(Boolean).join(" — ");
+}
+
+function formatUsdcAtomic(value) {
+  const raw = cleanText(value || "");
+  if (!/^\d+$/u.test(raw)) {
+    return raw;
+  }
+  const padded = raw.padStart(7, "0");
+  const whole = padded.slice(0, -6).replace(/^0+(?=\d)/u, "") || "0";
+  const frac = padded.slice(-6).replace(/0+$/u, "");
+  return frac ? `${whole}.${frac}` : whole;
+}
+
+function escapeHtml(value) {
+  return String(value ?? "")
+    .replace(/&/gu, "&amp;")
+    .replace(/</gu, "&lt;")
+    .replace(/>/gu, "&gt;")
+    .replace(/"/gu, "&quot;");
+}
+
+function cleanText(value) {
+  return String(value ?? "").replace(/\s+/gu, " ").trim();
+}
+
+async function fetchWithTimeout(url, init = {}, timeoutMs = 30_000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 /**
  * Spawn `codex exec` and capture stdout+stderr.
  */
-function runCodexExec(instruction, config) {
+function runCodexExec(instruction, config, options = {}) {
   return new Promise((resolve, reject) => {
     const codexBin = resolveCodexBin(config);
-    const args = ["exec", "--full-auto", "--skip-git-repo-check", instruction];
+    const args = ["exec", "--full-auto", "--skip-git-repo-check"];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
+    args.push(instruction);
     const cwd = config.workspaceRoot || os.tmpdir();
 
     const child = spawn(codexBin, args, {
@@ -303,10 +554,13 @@ function runCodexExec(instruction, config) {
 /**
  * Spawn `claude -p` and capture stdout+stderr.
  */
-function runClaudeExec(instruction) {
+function runClaudeExec(instruction, options = {}) {
   return new Promise((resolve, reject) => {
     const claudeBin = resolveClaudeBin();
     const args = ["-p", instruction, "--output-format", "text"];
+    if (options.model) {
+      args.push("--model", options.model);
+    }
 
     const child = spawn(claudeBin, args, {
       cwd: os.tmpdir(),

package/scripts/a2a-handler.mjs

@@ -158,6 +158,90 @@ function extractTextFromParts(parts) {
     .trim();
 }
 
+function isPlainObject(value) {
+  return value && typeof value === "object" && !Array.isArray(value);
+}
+
+function cleanMetadataText(value, maxLength = 500) {
+  return String(value ?? "")
+    .replace(/\s+/gu, " ")
+    .trim()
+    .slice(0, maxLength);
+}
+
+const PRICE_REGEX = /^\d+(\.\d{1,6})?$/u;
+const ETH_ADDR_REGEX = /^0x[0-9a-fA-F]{40}$/u;
+
+function normalizeRequestedExecutor(value) {
+  const normalized = cleanMetadataText(value, 30).toLowerCase();
+  return normalized === "codex" || normalized === "claude" || normalized === "auto" ? normalized : "";
+}
+
+function normalizeRequestedTier(value) {
+  const normalized = cleanMetadataText(value, 50).toLowerCase();
+  if (normalized === "pro" || normalized === "pro-assisted" || normalized === "premium") {
+    return "pro";
+  }
+  if (normalized === "standard" || normalized === "free") {
+    return "standard";
+  }
+  return normalized || "";
+}
+
+function normalizePaymentSpec(source) {
+  const payment = isPlainObject(source?.payment) ? source.payment : source;
+  const price = cleanMetadataText(payment?.price ?? payment?.amount ?? payment?.amountUsdc ?? "", 30);
+  const payTo = cleanMetadataText(payment?.payTo ?? payment?.pay_to ?? payment?.recipient ?? "", 80);
+  if (!price && !payTo) {
+    return null;
+  }
+  if (!PRICE_REGEX.test(price) || !ETH_ADDR_REGEX.test(payTo)) {
+    return {
+      enabled: false,
+      invalid: true,
+      reason: "invalid-price-or-pay-to",
+      price,
+      payTo,
+    };
+  }
+  return {
+    enabled: true,
+    price,
+    payTo: payTo.toLowerCase(),
+    mode: cleanMetadataText(payment?.mode || source?.settlement || "x402", 40).toLowerCase() || "x402",
+  };
+}
+
+export function normalizeViveworkerTaskMetadata(metadata = {}) {
+  const root = isPlainObject(metadata) ? metadata : {};
+  const source = isPlainObject(root.viveworker) ? root.viveworker : root;
+  const mode = cleanMetadataText(source.mode || source.flow || "", 80).toLowerCase();
+  const requestedTier = normalizeRequestedTier(source.requestedTier || source.tier || source.qualityTier || source.modelTier);
+  const requestedExecutor = normalizeRequestedExecutor(source.requestedExecutor || source.executor);
+  const requestedModel = cleanMetadataText(source.requestedModel || source.model || "", 80);
+  const deliverableType = cleanMetadataText(source.deliverableType || source.deliverable || "research brief", 120);
+  const payment = normalizePaymentSpec(source);
+  const paidDeliverable =
+    mode === "x402-pro" ||
+    mode === "pay-per-unlock" ||
+    mode === "paid-unlock" ||
+    Boolean(payment);
+
+  if (!mode && !requestedTier && !requestedExecutor && !requestedModel && !paidDeliverable) {
+    return {};
+  }
+
+  return {
+    mode: mode || (paidDeliverable ? "x402-pro" : ""),
+    requestedTier,
+    requestedExecutor,
+    requestedModel,
+    deliverableType,
+    paidDeliverable,
+    payment,
+  };
+}
+
 function buildTaskResponse(task) {
   return {
     id: task.id,
@@ -269,6 +353,7 @@ async function handleMessageSend({
   const contextId = params.contextId || taskId();
   const token = historyToken(`a2a_task:${id}`);
   const now = Date.now();
+  const viveworker = normalizeViveworkerTaskMetadata(message.metadata || params.metadata || {});
 
   const task = {
     id,
@@ -279,6 +364,8 @@ async function handleMessageSend({
     messages: [message],
     artifacts: [],
     instruction,
+    metadata: message.metadata || params.metadata || {},
+    viveworker,
     callerInfo: {
       ip: req.socket?.remoteAddress || "",
       userAgent: req.headers["user-agent"] || "",
@@ -311,6 +398,7 @@ async function handleMessageSend({
         summary: cleanText(instruction).slice(0, 160),
         instruction,
         messageText: instruction,
+        viveworker,
         createdAtMs: now,
         readOnly: false,
         provider: "a2a",

package/scripts/a2a-relay-client.mjs

@@ -14,6 +14,7 @@ import os from "node:os";
 import path from "node:path";
 import { promises as fs, readFileSync } from "node:fs";
 import { upsertEnvText } from "./lib/pairing.mjs";
+import { normalizeViveworkerTaskMetadata } from "./a2a-handler.mjs";
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -248,6 +249,8 @@ async function ingestRelayTask({ relayTask, config, runtime, state, helpers }) {
   const token = historyToken(`a2a_task:${relayTask.id}`);
   const instruction = cleanText(relayTask.instruction || "");
   const now = Date.now();
+  const relayMetadata = relayTask.metadata || relayTask.messages?.[0]?.metadata || {};
+  const viveworker = normalizeViveworkerTaskMetadata(relayMetadata);
 
   const task = {
     id: relayTask.id,
@@ -258,6 +261,8 @@ async function ingestRelayTask({ relayTask, config, runtime, state, helpers }) {
     messages: relayTask.messages || [],
     artifacts: [],
     instruction,
+    metadata: relayMetadata,
+    viveworker,
     callerInfo: relayTask.callerInfo || {},
     createdAtMs: relayTask.createdAtMs || now,
     updatedAtMs: now,
@@ -289,6 +294,7 @@ async function ingestRelayTask({ relayTask, config, runtime, state, helpers }) {
         title: `A2A: ${instruction.slice(0, 80)}`,
         summary: instruction.slice(0, 160),
         messageText: instruction,
+        viveworker,
         createdAtMs: relayTask.createdAtMs || now,
         readOnly: false,
         provider: "a2a",

package/scripts/lib/markdown-render.mjs

@@ -170,15 +170,125 @@ function renderBlockquote(lines) {
 
 function renderCodeBlock(lines) {
   const [fence, ...rest] = lines;
+  // parseBlocks pushes the closing fence onto the block before breaking out
+  // of the loop, so `rest` ends with that closing line whenever the fence is
+  // properly closed. Strip it so the rendered <pre><code>...</code></pre>
+  // doesn't show the literal "```" as the last line of the code body.
+  const body = [...rest];
+  if (body.length > 0 && /^```\s*$/u.test(body[body.length - 1])) {
+    body.pop();
+  }
   const language = fence.replace(/^```/u, "").trim();
   const className = language ? ` class="language-${escapeHtml(language)}"` : "";
-  return `<pre><code${className}>${escapeHtml(rest.join("\n"))}</code></pre>`;
+  return `<pre><code${className}>${escapeHtml(body.join("\n"))}</code></pre>`;
 }
 
 function renderParagraph(lines) {
   return `<p>${lines.map((line) => renderInline(line.trim())).join("<br>")}</p>`;
 }
 
+// ---------------------------------------------------------------------------
+// Pipe-style markdown tables
+// ---------------------------------------------------------------------------
+//
+//     | header 1 | header 2 |
+//     |----------|---------:|
+//     | cell     | 42       |
+//
+// Detection requires both a header row (single line starting AND ending with
+// `|`) and a separator row immediately below it whose cells are
+// `:?-{2,}:?` (with optional alignment markers). Anything else falls through
+// to the paragraph fallback so a stray `| not a table |` line still
+// renders as plain text.
+//
+// Cells go through `renderInline` so they pick up the existing escape /
+// inline-formatting pipeline; we never inject raw HTML.
+
+function isTableRowLine(line) {
+  if (typeof line !== "string") return false;
+  const trimmed = line.trim();
+  return trimmed.length >= 2 && trimmed.startsWith("|") && trimmed.endsWith("|");
+}
+
+function splitTableCells(line) {
+  // Strip the leading + trailing pipes; honour `\|` as an escaped literal.
+  const trimmed = line.trim().replace(/^\|/u, "").replace(/\|$/u, "");
+  const cells = [];
+  let current = "";
+  let i = 0;
+  while (i < trimmed.length) {
+    if (trimmed[i] === "\\" && trimmed[i + 1] === "|") {
+      current += "|";
+      i += 2;
+      continue;
+    }
+    if (trimmed[i] === "|") {
+      cells.push(current);
+      current = "";
+      i += 1;
+      continue;
+    }
+    current += trimmed[i];
+    i += 1;
+  }
+  cells.push(current);
+  return cells.map((cell) => cell.trim());
+}
+
+function isTableSeparatorLine(line) {
+  if (!isTableRowLine(line)) return false;
+  const cells = splitTableCells(line);
+  if (cells.length === 0) return false;
+  return cells.every((cell) => /^:?-{2,}:?$/u.test(cell));
+}
+
+function parseTableAlignments(separatorLine) {
+  return splitTableCells(separatorLine).map((cell) => {
+    const left = cell.startsWith(":");
+    const right = cell.endsWith(":");
+    if (left && right) return "center";
+    if (right) return "right";
+    if (left) return "left";
+    return "";
+  });
+}
+
+function renderTableCell(cell, align, tag) {
+  const styleAttr = align ? ` style="text-align:${align}"` : "";
+  return `<${tag}${styleAttr}>${renderInline(cell)}</${tag}>`;
+}
+
+function renderTable(headerLine, separatorLine, dataLines) {
+  const alignments = parseTableAlignments(separatorLine);
+  const headerCells = splitTableCells(headerLine);
+  // Pad alignments out to header width so any data row that's wider still
+  // gets a sensible alignment default.
+  while (alignments.length < headerCells.length) alignments.push("");
+
+  const headerHtml = headerCells
+    .map((cell, i) => renderTableCell(cell, alignments[i] || "", "th"))
+    .join("");
+  const bodyHtml = dataLines
+    .map((row) => {
+      const cells = splitTableCells(row);
+      const cellsHtml = cells
+        .map((cell, i) => renderTableCell(cell, alignments[i] || "", "td"))
+        .join("");
+      return `<tr>${cellsHtml}</tr>`;
+    })
+    .join("");
+
+  return `<table><thead><tr>${headerHtml}</tr></thead><tbody>${bodyHtml}</tbody></table>`;
+}
+
+function looksLikeTableStart(lines, index) {
+  return (
+    isTableRowLine(lines[index]) &&
+    index + 1 < lines.length &&
+    isTableSeparatorLine(lines[index + 1])
+  );
+}
+
 function parseBlocks(markdown) {
   const lines = markdown.replace(/\r\n/gu, "\n").trim().split("\n");
   const blocks = [];
@@ -241,6 +351,19 @@ function parseBlocks(markdown) {
       continue;
     }
 
+    if (looksLikeTableStart(lines, index)) {
+      const headerLine = lines[index];
+      const separatorLine = lines[index + 1];
+      const dataLines = [];
+      index += 2;
+      while (index < lines.length && isTableRowLine(lines[index])) {
+        dataLines.push(lines[index]);
+        index += 1;
+      }
+      blocks.push(renderTable(headerLine, separatorLine, dataLines));
+      continue;
+    }
+
     const block = [];
     while (index < lines.length) {
       const current = lines[index];
@@ -250,6 +373,10 @@ function parseBlocks(markdown) {
       if (isUnorderedList(current) || isOrderedList(current) || /^(?:---|\*\*\*|___)\s*$/u.test(current)) {
         break;
       }
+      if (looksLikeTableStart(lines, index)) {
+        // Don't swallow a table-start row into the previous paragraph.
+        break;
+      }
       block.push(current);
       index += 1;
     }