diff --git a/benchmarks/plugin-emoji.ts b/benchmarks/plugin-emoji.ts
new file mode 100644
index 00000000..fc996e37
--- /dev/null
+++ b/benchmarks/plugin-emoji.ts
@@ -0,0 +1,110 @@
+import { bench, run, group, barplot } from 'mitata'
+import MarkdownIt from 'markdown-it'
+import MarkdownExit from 'markdown-exit'
+import { markdownItComark } from 'comark/plugins/syntax'
+import { full as markdownItEmoji } from 'markdown-it-emoji'
+import { createParse } from 'comark'
+import { unified } from 'unified'
+import remarkParse from 'remark-parse'
+import remarkGfm from 'remark-gfm'
+import remarkEmoji from 'remark-emoji'
+import emoji from '../packages/comark/src/plugins/emoji'
+
+const short = `Hello :wave: world :rocket: that's :100: percent :fire:`
+
+const medium = `
+# Welcome :tada:
+
+This is a **great** day :sunny: for coding :computer:
+
+## Features :sparkles:
+
+- Fast parsing :rocket:
+- Easy to use :thumbsup:
+- Great docs :books:
+
+> "Keep it simple" :smile: -- someone wise :nerd_face:
+
+Check out our :star: project on :octocat: GitHub!
+
+Don't :x: forget to :heart: the repo :pray:
+`
+
+const long = Array.from(
+  { length: 50 },
+  (_, i) => `
+## Section ${i + 1} :bookmark:
+
+Paragraph ${i + 1} has some :smile: emoji and :rocket: inline codes.
+
+- Item :thumbsup: with emoji
+- Another :star: item
+- Final :checkered_flag: item
+
+> Quote with :heart: and :fire: emoji :100:
+`
+).join('\n')
+
+// markdown-it: baseline vs emoji
+const markdownIt = new MarkdownIt({ html: false, linkify: true })
+  .enable(['table', 'strikethrough'])
+  .use(markdownItComark)
+const markdownItEm = new MarkdownIt({ html: false, linkify: true })
+  .enable(['table', 'strikethrough'])
+  .use(markdownItComark)
+  .use(markdownItEmoji)
+
+// markdown-exit: baseline vs emoji
+const markdownExit = new MarkdownExit({ html: false, linkify: true })
+  .enable(['table', 'strikethrough'])
+  .use(markdownItComark)
+const markdownExitEm = new MarkdownExit({ html: false, linkify: true })
+  .enable(['table', 'strikethrough'])
+  .use(markdownItComark)
+  .use(markdownItEmoji)
+
+// comark: baseline vs emoji plugin
+const comark = createParse()
+const comarkEm = createParse({ plugins: [emoji()] })
+
+// remark (unified): baseline vs emoji
+const remark = unified().use(remarkParse).use(remarkGfm)
+const remarkEm = unified().use(remarkParse).use(remarkGfm).use(remarkEmoji)
+
+for (const [label, content] of [
+  ['short text', short],
+  ['medium text', medium],
+  ['long text (50 sections)', long],
+] as const) {
+  barplot(() => {
+    group(`emoji — ${label}`, () => {
+      bench('comark', async () => {
+        await comark(content)
+      })
+      bench('comark + emoji', async () => {
+        await comarkEm(content)
+      })
+      bench('markdown-it', () => {
+        markdownIt.parse(content, {})
+      })
+      bench('markdown-it + emoji', () => {
+        markdownItEm.parse(content, {})
+      })
+      bench('markdown-exit', () => {
+        markdownExit.parse(content, {})
+      })
+      bench('markdown-exit + emoji', () => {
+        markdownExitEm.parse(content, {})
+      })
+      bench('remark', () => {
+        remark.parse(content)
+      })
+      bench('remark + emoji', () => {
+        remarkEm.runSync(remarkEm.parse(content))
+      })
+    })
+  })
+}
+
+console.log('🏃 Running benchmarks...\n')
+await run()
diff --git a/benchmarks/plugin-punctuation.ts b/benchmarks/plugin-punctuation.ts
index a15263f0..a4390f96 100644
--- a/benchmarks/plugin-punctuation.ts
+++ b/benchmarks/plugin-punctuation.ts
@@ -1,11 +1,15 @@
 import { bench, run, group, barplot } from 'mitata'
+import MarkdownIt from 'markdown-it'
 import MarkdownExit from 'markdown-exit'
 import { markdownItComark } from 'comark/plugins/syntax'
 import { createParse } from 'comark'
-import { log } from '@comark/ansi'
+import { unified } from 'unified'
+import remarkParse from 'remark-parse'
+import remarkGfm from 'remark-gfm'
+import remarkSmartypants from 'remark-smartypants'
 import punctuation from '../packages/comark/src/plugins/punctuation'
 
-// ── Test content (exercises ALL features: quotes, dashes, ellipsis, symbols, normalization) ──
+// Test content (exercises ALL features: quotes, dashes, ellipsis, symbols, normalization)
 
 const short = `"Hello" -- world... (c) 2025 what???? ok,,`
 
@@ -38,113 +42,65 @@ Really????  Wow!!!!! hmm,, ok?.... end
 `
 ).join('\n')
 
-// ── markdown-it typographer ─────────────────────────────────────────────────
-
-const parserTypographer = new MarkdownExit({
-  html: false,
-  linkify: true,
-  typographer: true,
-})
+// markdown-it: baseline vs typographer
+const markdownIt = new MarkdownIt({ html: false, linkify: true, typographer: false })
   .enable(['table', 'strikethrough'])
   .use(markdownItComark)
-
-const parserNoTypographer = new MarkdownExit({
-  html: false,
-  linkify: true,
-  typographer: false,
-})
+const markdownItTypo = new MarkdownIt({ html: false, linkify: true, typographer: true })
   .enable(['table', 'strikethrough'])
   .use(markdownItComark)
 
-// ── comark with full punctuation plugin (all features) ──────────────────────
-
-const comarkFull = createParse({ plugins: [punctuation()] })
-const comarkBaseline = createParse()
-
-// ── Benchmarks ──────────────────────────────────────────────────────────────
-
-barplot(() => {
-  group('short text (all features)', () => {
-    bench('markdown-it typographer', () => {
-      parserTypographer.parse(short, {})
-    })
-    bench('markdown-it baseline', () => {
-      parserNoTypographer.parse(short, {})
-    })
-    bench('comark + punctuation (full)', async () => {
-      await comarkFull(short)
-    })
-    bench('comark baseline', async () => {
-      await comarkBaseline(short)
-    })
-  })
-})
-
-barplot(() => {
-  group('medium text (all features)', () => {
-    bench('markdown-it typographer', () => {
-      parserTypographer.parse(medium, {})
-    })
-    bench('markdown-it baseline', () => {
-      parserNoTypographer.parse(medium, {})
-    })
-    bench('comark + punctuation (full)', async () => {
-      await comarkFull(medium)
-    })
-    bench('comark baseline', async () => {
-      await comarkBaseline(medium)
-    })
-  })
-})
+// markdown-exit: baseline vs typographer
+const markdownExit = new MarkdownExit({ html: false, linkify: true, typographer: false })
+  .enable(['table', 'strikethrough'])
+  .use(markdownItComark)
+const markdownExitTypo = new MarkdownExit({ html: false, linkify: true, typographer: true })
+  .enable(['table', 'strikethrough'])
+  .use(markdownItComark)
 
-barplot(() => {
-  group('long text — 50 sections (all features)', () => {
-    bench('markdown-it typographer', () => {
-      parserTypographer.parse(long, {})
-    })
-    bench('markdown-it baseline', () => {
-      parserNoTypographer.parse(long, {})
-    })
-    bench('comark + punctuation (full)', async () => {
-      await comarkFull(long)
-    })
-    bench('comark baseline', async () => {
-      await comarkBaseline(long)
+// comark: baseline vs punctuation plugin
+const comark = createParse()
+const comarkPunct = createParse({ plugins: [punctuation()] })
+
+// remark (unified): baseline vs smartypants
+const remark = unified().use(remarkParse).use(remarkGfm)
+const remarkSmarty = unified().use(remarkParse).use(remarkGfm).use(remarkSmartypants)
+
+
+for (const [label, content] of [
+  ['short text', short],
+  ['medium text', medium],
+  ['long text (50 sections)', long],
+] as const) {
+  barplot(() => {
+    group(`punctuation — ${label}`, () => {
+      bench('comark', async () => {
+        await comark(content)
+      })
+      bench('comark + punctuation', async () => {
+        await comarkPunct(content)
+      })
+      bench('markdown-it', () => {
+        markdownIt.parse(content, {})
+      })
+      bench('markdown-it + typographer', () => {
+        markdownItTypo.parse(content, {})
+      })
+      bench('markdown-exit', () => {
+        markdownExit.parse(content, {})
+      })
+      bench('markdown-exit + typographer', () => {
+        markdownExitTypo.parse(content, {})
+      })
+      bench('remark', () => {
+        remark.parse(content)
+      })
+      bench('remark + smartypants', () => {
+        remarkSmarty.runSync(remarkSmarty.parse(content))
+      })
     })
   })
-})
-
-// ── Output comparison ───────────────────────────────────────────────────────
-
-function flattenText(nodes: any[]): string {
-  let text = ''
-  for (const node of nodes) {
-    if (typeof node === 'string') text += node
-    else if (Array.isArray(node) && node.length > 2) text += flattenText(node.slice(2))
-  }
-  return text
 }
 
-const testStr = `"Hello" -- world... (c) what???? ok,, really!.... hmm.....`
-
-console.log('=== Output Comparison ===\n')
-console.log('Input:', JSON.stringify(testStr))
-
-const miTokens = parserTypographer.parse(testStr, {})
-const miText = miTokens
-  .filter((t: any) => t.type === 'inline')
-  .map((t: any) => t.content)
-  .join('')
-console.log('markdown-it typographer:', JSON.stringify(miText))
-
-const comarkTree = await comarkFull(testStr)
-console.log('comark punctuation:     ', JSON.stringify(flattenText(comarkTree.nodes)))
-
-console.log('\n🏃 Running benchmarks...\n')
+console.log('🏃 Running benchmarks...\n')
 await run()
-
-await log(`> [!NOTE]
-> The goal of this benchmark is to compare the additional time each parser takes when
-> using punctuation plugins.
->
-> Official plugin adds ~100% the execution time, while comark adds ~25% execution time`)
diff --git a/docs/app/pages/benchmarks.vue b/docs/app/pages/benchmarks.vue
new file mode 100644
index 00000000..7f2f7ecd
--- /dev/null
+++ b/docs/app/pages/benchmarks.vue
@@ -0,0 +1,482 @@
+<script setup lang="ts">
+definePageMeta({
+  footer: false,
+})
+
+const title = 'Benchmarks - Comark'
+const description =
+  'Performance benchmarks comparing Comark parsing and rendering against markdown-it, markdown-exit, and remark.'
+useSeoMeta({
+  title,
+  description,
+})
+defineOgImage('Docs.satori', {
+  headline: 'Benchmarks',
+  title,
+  description,
+})
+
+interface BenchEntry {
+  name: string
+  avg: number
+  unit: string
+  avgNs: number
+}
+
+interface BenchGroup {
+  name: string
+  entries: BenchEntry[]
+}
+
+interface BenchData {
+  generated: string
+  runtime: string
+  cpu: string
+  benchmarks: Record<string, BenchGroup[]>
+}
+
+const { data } = await useFetch<BenchData>('/api/benchmarks')
+
+const searchQuery = ref('')
+const selectedVariants = ref<Record<string, string>>({})
+
+// Merge groups that share a " — " prefix within the same file into variant tabs
+interface MergedGroup {
+  id: string
+  label: string
+  file: string
+  variants: { key: string; group: BenchGroup }[]
+}
+
+const mergedBenchmarks = computed<MergedGroup[]>(() => {
+  if (!data.value?.benchmarks) return []
+  const result: MergedGroup[] = []
+
+  for (const [file, groups] of Object.entries(data.value.benchmarks)) {
+    if (groups.length <= 1) {
+      // Single group — no variant tabs needed
+      result.push({
+        id: `${file}:${groups[0]!.name}`,
+        label: groups[0]!.name || file,
+        file,
+        variants: [{ key: '', group: groups[0]! }],
+      })
+      continue
+    }
+
+    // Multiple groups in same file — merge as variant tabs
+    const label = file.replace(/^plugin-/, '').replace(/-/g, ' ')
+
+    result.push({
+      id: file,
+      label,
+      file,
+      variants: groups.map((g) => {
+        // Extract variant label from after " — " separator: "emoji — short text" → "Short"
+        const sep = g.name.indexOf(' — ')
+        const variantPart = sep > -1 ? g.name.slice(sep + 3) : g.name
+        const sizeMatch = variantPart.match(/^(short|medium|long)\b/i)
+        if (sizeMatch) {
+          let key = sizeMatch[1].charAt(0).toUpperCase() + sizeMatch[1].slice(1)
+          const extra = variantPart.match(/\((.+?)\)/)
+          if (extra) key += ` (${extra[1].trim()})`
+          return { key, group: g }
+        }
+        return { key: variantPart, group: g }
+      }),
+    })
+  }
+
+  return result
+})
+
+const filteredBenchmarks = computed(() => {
+  const q = searchQuery.value.toLowerCase().trim()
+  if (!q) return mergedBenchmarks.value
+  return mergedBenchmarks.value.filter(
+    (m) =>
+      m.label.toLowerCase().includes(q) ||
+      m.file.toLowerCase().includes(q) ||
+      m.variants.some(
+        (v) => v.key.toLowerCase().includes(q) || v.group.entries.some((e) => e.name.toLowerCase().includes(q))
+      )
+  )
+})
+
+const totalGroups = computed(() => mergedBenchmarks.value.length)
+
+const benchFiles = computed(() => {
+  if (!data.value?.benchmarks) return []
+  return Object.keys(data.value.benchmarks).sort()
+})
+
+function activeVariant(entry: MergedGroup) {
+  if (entry.variants.length <= 1) return entry.variants[0]
+  const sel = selectedVariants.value[entry.id]
+  return entry.variants.find((v) => v.key === sel) || entry.variants[0]
+}
+
+function activeEntries(entry: MergedGroup): BenchEntry[] {
+  const entries = activeVariant(entry)?.group.entries ?? []
+  return [...entries].sort((a, b) => a.avgNs - b.avgNs)
+}
+
+function slugify(name: string) {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/(^-|-$)/g, '')
+}
+
+// Performance-based colors: green (fastest) → red (slowest)
+const perfColors = [
+  'bg-emerald-500 dark:bg-emerald-400',
+  'bg-lime-500 dark:bg-lime-400',
+  'bg-amber-400 dark:bg-amber-300',
+  'bg-orange-500 dark:bg-orange-400',
+  'bg-red-500 dark:bg-red-400',
+]
+
+function barColor(entry: BenchEntry, entries: BenchEntry[]) {
+  if (entries.length <= 1) return perfColors[0]
+  const sorted = [...entries].sort((a, b) => a.avgNs - b.avgNs)
+  const rank = sorted.findIndex((e) => e.name === entry.name)
+  const idx = Math.round((rank / (entries.length - 1)) * (perfColors.length - 1))
+  return perfColors[idx]
+}
+
+function formatTime(avg: number, unit: string) {
+  return `${avg} ${unit}`
+}
+
+function formatDate(iso: string) {
+  return new Date(iso).toLocaleDateString('en-US', {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+  })
+}
+
+// Bar width: bars represent time — slowest gets 100%, fastest gets smallest bar
+function barWidth(entry: BenchEntry, entries: BenchEntry[]) {
+  const max = Math.max(...entries.map((e) => e.avgNs))
+  if (max === 0) return 0
+  return (entry.avgNs / max) * 100
+}
+
+// Generate an insight description for an expanded benchmark group
+function groupDescription(entry: MergedGroup): string {
+  const entries = activeEntries(entry)
+  if (entries.length < 2) return ''
+
+  // Detect baseline/plugin pairs for overhead comparison
+  const pairs: { parser: string; baseline: BenchEntry; plugin: BenchEntry; overheadPct: number }[] = []
+  for (const e of entries) {
+    const n = e.name.toLowerCase()
+    if (n.includes('+') || n.includes('typographer') || n.includes('punctuation') || n.includes('smartypants')) continue // skip plugin entries, we'll match them from baselines
+    // Find matching plugin entry
+    const plugin = entries.find((p) => {
+      const pn = p.name.toLowerCase()
+      if (pn === n) return false
+      const baseName = n.replace(/\s*\(.*\)/, '') // strip "(unified)" etc.
+      return pn.startsWith(baseName) && pn !== n
+    })
+    if (plugin) {
+      const overheadPct = ((plugin.avgNs - e.avgNs) / e.avgNs) * 100
+      pairs.push({ parser: e.name, baseline: e, plugin, overheadPct })
+    }
+  }
+
+  if (pairs.length >= 2) {
+    // Overhead comparison mode
+    const sorted = [...pairs].sort((a, b) => a.overheadPct - b.overheadPct)
+    const best = sorted[0]!
+    const parts = sorted.map((p) => {
+      const sign = p.overheadPct >= 0 ? '+' : ''
+      return `${p.parser} ${sign}${Math.round(p.overheadPct)}%`
+    })
+    return `${best.parser} has the lowest plugin overhead (${parts.join(', ')}).`
+  }
+
+  // Check for streaming advantage vs non-comark competitors
+  const streaming = entries.find((e) => e.name.toLowerCase().includes('streaming'))
+  const competitors = entries.filter((e) => !e.name.toLowerCase().includes('comark'))
+  if (streaming && competitors.length > 0) {
+    const fastestCompetitor = competitors.reduce((a, b) => (a.avgNs < b.avgNs ? a : b))
+    if (streaming.avgNs < fastestCompetitor.avgNs) {
+      const speedup = (fastestCompetitor.avgNs / streaming.avgNs).toFixed(1)
+      return `Comark streaming is ${speedup}× faster than ${fastestCompetitor.name} (${formatTime(streaming.avg, streaming.unit)}).`
+    }
+  }
+
+  // Default: fastest entry with speedup ratio
+  const fastest = entries.reduce((a, b) => (a.avgNs < b.avgNs ? a : b))
+  const slowest = entries.reduce((a, b) => (a.avgNs > b.avgNs ? a : b))
+  if (fastest.avgNs > 0 && slowest.avgNs > fastest.avgNs * 1.5) {
+    const speedup = (slowest.avgNs / fastest.avgNs).toFixed(1)
+    return `${fastest.name} is the fastest at ${formatTime(fastest.avg, fastest.unit)} — ${speedup}× faster than ${slowest.name}.`
+  }
+  return `${fastest.name} is the fastest at ${formatTime(fastest.avg, fastest.unit)}.`
+}
+
+function scrollToGroup(id: string) {
+  const el = document.getElementById(`bench-${slugify(id)}`)
+  if (el) {
+    el.scrollIntoView({ behavior: 'smooth', block: 'start' })
+  }
+}
+</script>
+
+<template>
+  <div class="min-h-[calc(100vh-64px)] bg-default">
+    <!-- Header -->
+    <div class="relative border-b border-default">
+      <UContainer class="relative z-10 py-6 sm:py-10">
+        <div class="flex flex-col sm:flex-row sm:items-end sm:justify-between gap-4">
+          <div>
+            <h1 class="text-2xl sm:text-3xl font-bold text-neutral-900 dark:text-white mb-1">
+              <UIcon
+                name="i-lucide-bar-chart-2"
+                class="size-5 text-primary-500"
+              />
+              Benchmarks
+            </h1>
+            <p class="text-neutral-500 dark:text-neutral-400 text-sm max-w-xl">
+              Performance comparisons across parsers, renderers, and plugins.
+            </p>
+          </div>
+          <div
+            v-if="data"
+            class="flex flex-wrap gap-x-4 gap-y-1 text-[11px] text-neutral-400 dark:text-neutral-500 tabular-nums font-mono"
+          >
+            <span>{{ formatDate(data.generated) }}</span>
+            <span>{{ data.cpu }}</span>
+            <span>{{ data.runtime }}</span>
+          </div>
+        </div>
+      </UContainer>
+    </div>
+
+    <!-- Context note -->
+    <section class="border-b border-default p-5 sm:p-8 md:px-12 md:py-6">
+      <UContainer>
+        <div class="space-y-1.5 text-sm/6 text-muted">
+          <p>
+            Each benchmark compares the <strong class="text-highlighted font-medium">overhead</strong> that a plugin
+            adds to baseline parsing. <strong class="text-primary">Comark</strong> consistently has the
+            <strong class="text-highlighted font-medium">lowest plugin overhead</strong> across all benchmarks — its
+            plugin architecture adds minimal cost on top of the parsing step.
+          </p>
+          <p>
+            Bars represent speed: <span class="text-emerald-500 dark:text-emerald-400 font-medium">longer bars</span> =
+            faster. Entries are sorted fastest-first.
+          </p>
+        </div>
+      </UContainer>
+    </section>
+
+    <UContainer>
+      <div class="flex flex-col lg:flex-row gap-6">
+        <!-- Sidebar -->
+        <aside
+          class="lg:w-56 shrink-0 lg:sticky lg:top-16 lg:self-start lg:border-r border-default p-5 sm:p-6 space-y-6"
+        >
+          <!-- Search -->
+          <div class="relative">
+            <UIcon
+              name="i-lucide-search"
+              class="absolute left-2.5 top-1/2 -translate-y-1/2 size-3.5 text-dimmed"
+            />
+            <input
+              v-model="searchQuery"
+              type="text"
+              placeholder="Filter..."
+              class="w-full pl-8 pr-3 py-1.5 text-sm rounded-md border border-default bg-default text-default placeholder:text-dimmed focus:outline-none focus:ring-2 focus:ring-primary/20 font-mono"
+            />
+          </div>
+
+          <!-- TOC -->
+          <nav
+            v-if="filteredBenchmarks.length > 0"
+            class="hidden lg:block"
+          >
+            <div class="flex items-center justify-between mb-2">
+              <p class="text-[11px] font-medium text-neutral-400 dark:text-neutral-500 uppercase tracking-wider">
+                Groups ({{ filteredBenchmarks.length
+                }}<template v-if="searchQuery && filteredBenchmarks.length !== totalGroups">
+                  /{{ totalGroups }} </template
+                >)
+              </p>
+            </div>
+            <ul class="space-y-0.5 max-h-[60vh] overflow-y-auto">
+              <li
+                v-for="entry in filteredBenchmarks"
+                :key="entry.id"
+              >
+                <button
+                  class="w-full text-left px-2 py-1 text-xs rounded hover:bg-neutral-100 dark:hover:bg-neutral-800 text-neutral-600 dark:text-neutral-400 hover:text-neutral-900 dark:hover:text-neutral-200 truncate transition-colors"
+                  @click="scrollToGroup(entry.id)"
+                >
+                  {{ entry.label }}
+                  <span
+                    v-if="entry.variants.length > 1"
+                    class="text-neutral-400 dark:text-neutral-500"
+                    >({{ entry.variants.length }})</span
+                  >
+                </button>
+              </li>
+            </ul>
+          </nav>
+
+          <!-- Run locally -->
+          <details
+            v-if="benchFiles.length > 0"
+            class="hidden lg:block"
+          >
+            <summary
+              class="font-mono text-[0.65rem] font-semibold tracking-widest uppercase text-dimmed cursor-pointer select-none hover:text-muted"
+            >
+              Run locally
+            </summary>
+            <div class="mt-2 space-y-2 text-[11px] font-mono text-dimmed">
+              <p
+                v-for="file in benchFiles"
+                :key="file"
+                class="break-all"
+              >
+                npx tsx benchmarks/{{ file }}.ts
+              </p>
+              <hr class="border-muted" />
+              <p class="break-all">node scripts/bench.mjs</p>
+            </div>
+          </details>
+        </aside>
+
+        <!-- Main content -->
+        <div class="flex-1 min-w-0 space-y-4 py-6">
+          <!-- Empty state -->
+          <div
+            v-if="filteredBenchmarks.length === 0"
+            class="rounded-lg border border-dashed border-default py-16 text-center"
+          >
+            <p class="text-sm text-neutral-500 dark:text-neutral-400">No benchmarks match "{{ searchQuery }}"</p>
+            <button
+              class="mt-2 text-xs text-primary-500 hover:underline"
+              @click="searchQuery = ''"
+            >
+              Clear filter
+            </button>
+          </div>
+
+          <!-- Benchmark groups -->
+          <div
+            v-for="entry in filteredBenchmarks"
+            :id="`bench-${slugify(entry.id)}`"
+            :key="entry.id"
+            class="rounded-lg border border-default bg-white dark:bg-neutral-900 overflow-hidden scroll-mt-20"
+          >
+            <!-- Group header -->
+            <div class="w-full flex items-center gap-3 px-4 py-3">
+              <div class="flex-1 min-w-0">
+                <div class="flex items-center">
+                  <h2 class="text-sm font-semibold text-neutral-900 dark:text-white truncate">
+                    {{ entry.label }}
+                  </h2>
+                  <p
+                    v-if="groupDescription(entry)"
+                    class="px-4 pt-3 pb-2 text-xs text-neutral-500 dark:text-neutral-400"
+                  >
+                    {{ groupDescription(entry) }}
+                  </p>
+                </div>
+              </div>
+              <div class="hidden sm:flex items-center gap-2 shrink-0">
+                <span
+                  class="text-[10px] px-1.5 py-0.5 rounded bg-neutral-100 dark:bg-neutral-800 text-neutral-400 dark:text-neutral-500 font-mono tabular-nums"
+                >
+                  {{ entry.file }}.ts
+                </span>
+                <span class="text-xs text-neutral-400 dark:text-neutral-500">
+                  {{ activeEntries(entry).length }} entries
+                </span>
+              </div>
+            </div>
+
+            <!-- Variant tabs -->
+            <div
+              v-if="entry.variants.length > 1"
+              class="border-t border-default px-4 py-2 flex flex-wrap gap-1"
+            >
+              <button
+                v-for="v in entry.variants"
+                :key="v.key"
+                class="px-2.5 py-1 text-xs rounded-md transition-colors"
+                :class="
+                  activeVariant(entry)?.key === v.key
+                    ? 'bg-primary-500 text-white dark:bg-primary-400 dark:text-neutral-900'
+                    : 'bg-neutral-100 dark:bg-neutral-800 text-neutral-600 dark:text-neutral-400 hover:bg-neutral-200 dark:hover:bg-neutral-700'
+                "
+                @click.stop="selectedVariants[entry.id] = v.key"
+              >
+                {{ v.key }}
+              </button>
+            </div>
+
+            <!-- Bar chart -->
+            <div class="border-t border-default">
+              <div
+                v-for="(result, i) in activeEntries(entry)"
+                :key="result.name"
+                class="flex items-center gap-3 px-4 py-2"
+                :class="{ 'border-t border-default/50': i > 0 }"
+              >
+                <!-- Color dot + name -->
+                <div class="w-44 shrink-0 flex items-center gap-2 min-w-0">
+                  <span
+                    class="size-2 rounded-full shrink-0"
+                    :class="barColor(result, activeEntries(entry))"
+                  />
+                  <span class="text-xs text-neutral-700 dark:text-neutral-300 truncate">
+                    {{ result.name }}
+                  </span>
+                </div>
+
+                <!-- Bar -->
+                <div class="flex-1 h-5 bg-neutral-100 dark:bg-neutral-800 rounded overflow-hidden">
+                  <div
+                    class="h-full rounded transition-all duration-500"
+                    :class="barColor(result, activeEntries(entry))"
+                    :style="{ width: barWidth(result, activeEntries(entry)) + '%' }"
+                  />
+                </div>
+
+                <!-- Value -->
+                <div class="w-20 shrink-0 flex items-center justify-end">
+                  <span class="text-xs font-mono tabular-nums text-neutral-600 dark:text-neutral-400">
+                    {{ formatTime(result.avg, result.unit) }}
+                  </span>
+                </div>
+              </div>
+            </div>
+          </div>
+
+          <!-- Methodology note -->
+          <p
+            v-if="data"
+            class="text-[11px] text-neutral-400 dark:text-neutral-500 pt-2 pb-8"
+          >
+            Benchmarks generated with
+            <NuxtLink
+              external
+              href="https://github.com/evanwashere/mitata"
+              class="underline hover:text-neutral-600 dark:hover:text-neutral-300"
+              target="_blank"
+              >mitata</NuxtLink
+            >. Results vary by machine — run <code class="text-[10px]">node scripts/bench.mjs</code> locally for
+            accurate numbers.
+          </p>
+        </div>
+      </div>
+    </UContainer>
+  </div>
+</template>
diff --git a/docs/public/benchmarks.json b/docs/public/benchmarks.json
new file mode 100644
index 00000000..5d5fd9be
--- /dev/null
+++ b/docs/public/benchmarks.json
@@ -0,0 +1,492 @@
+{
+  "generated": "2026-06-04T02:15:31.529Z",
+  "runtime": "node 24.16.0 (arm64-darwin)",
+  "cpu": "Apple M4 Max",
+  "benchmarks": {
+    "comark-parse": [
+      {
+        "name": "parse",
+        "entries": [
+          {
+            "name": "markdown-it parse",
+            "avg": 22.82,
+            "unit": "µs",
+            "avgNs": 22820
+          },
+          {
+            "name": "markdown-exit parse",
+            "avg": 19.61,
+            "unit": "µs",
+            "avgNs": 19610
+          },
+          {
+            "name": "comark parse",
+            "avg": 37.42,
+            "unit": "µs",
+            "avgNs": 37420
+          },
+          {
+            "name": "comark parse no close",
+            "avg": 35.35,
+            "unit": "µs",
+            "avgNs": 35350
+          },
+          {
+            "name": "comark parse streaming",
+            "avg": 3.62,
+            "unit": "µs",
+            "avgNs": 3620
+          }
+        ]
+      }
+    ],
+    "comark-render": [
+      {
+        "name": "render",
+        "entries": [
+          {
+            "name": "markdown-it render",
+            "avg": 27.42,
+            "unit": "µs",
+            "avgNs": 27420
+          },
+          {
+            "name": "markdown-exit render",
+            "avg": 24.46,
+            "unit": "µs",
+            "avgNs": 24460
+          },
+          {
+            "name": "comark parse + renderHTML",
+            "avg": 74.9,
+            "unit": "µs",
+            "avgNs": 74900
+          },
+          {
+            "name": "comark parse no close",
+            "avg": 70.54,
+            "unit": "µs",
+            "avgNs": 70540
+          },
+          {
+            "name": "comark parse streaming",
+            "avg": 37.99,
+            "unit": "µs",
+            "avgNs": 37990
+          }
+        ]
+      }
+    ],
+    "plugin-emoji": [
+      {
+        "name": "emoji — short text",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 3.48,
+            "unit": "µs",
+            "avgNs": 3480
+          },
+          {
+            "name": "comark + emoji",
+            "avg": 2.44,
+            "unit": "µs",
+            "avgNs": 2440
+          },
+          {
+            "name": "markdown-it",
+            "avg": 1.88,
+            "unit": "µs",
+            "avgNs": 1880
+          },
+          {
+            "name": "markdown-it + emoji",
+            "avg": 1.97,
+            "unit": "µs",
+            "avgNs": 1970
+          },
+          {
+            "name": "markdown-exit",
+            "avg": 1.68,
+            "unit": "µs",
+            "avgNs": 1680
+          },
+          {
+            "name": "markdown-exit + emoji",
+            "avg": 1.77,
+            "unit": "µs",
+            "avgNs": 1770
+          },
+          {
+            "name": "remark",
+            "avg": 30.29,
+            "unit": "µs",
+            "avgNs": 30290
+          },
+          {
+            "name": "remark + emoji",
+            "avg": 31.62,
+            "unit": "µs",
+            "avgNs": 31620
+          }
+        ]
+      },
+      {
+        "name": "emoji — medium text",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 19.34,
+            "unit": "µs",
+            "avgNs": 19340
+          },
+          {
+            "name": "comark + emoji",
+            "avg": 16.32,
+            "unit": "µs",
+            "avgNs": 16320
+          },
+          {
+            "name": "markdown-it",
+            "avg": 11.78,
+            "unit": "µs",
+            "avgNs": 11780
+          },
+          {
+            "name": "markdown-it + emoji",
+            "avg": 12.09,
+            "unit": "µs",
+            "avgNs": 12090
+          },
+          {
+            "name": "markdown-exit",
+            "avg": 10.37,
+            "unit": "µs",
+            "avgNs": 10370
+          },
+          {
+            "name": "markdown-exit + emoji",
+            "avg": 10.9,
+            "unit": "µs",
+            "avgNs": 10900
+          },
+          {
+            "name": "remark",
+            "avg": 142.75,
+            "unit": "µs",
+            "avgNs": 142750
+          },
+          {
+            "name": "remark + emoji",
+            "avg": 151.47,
+            "unit": "µs",
+            "avgNs": 151470
+          }
+        ]
+      },
+      {
+        "name": "emoji — long text (50 sections)",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 559.26,
+            "unit": "µs",
+            "avgNs": 559260
+          },
+          {
+            "name": "comark + emoji",
+            "avg": 438.11,
+            "unit": "µs",
+            "avgNs": 438110
+          },
+          {
+            "name": "markdown-it",
+            "avg": 364.89,
+            "unit": "µs",
+            "avgNs": 364890
+          },
+          {
+            "name": "markdown-it + emoji",
+            "avg": 378.86,
+            "unit": "µs",
+            "avgNs": 378860
+          },
+          {
+            "name": "markdown-exit",
+            "avg": 326.09,
+            "unit": "µs",
+            "avgNs": 326090
+          },
+          {
+            "name": "markdown-exit + emoji",
+            "avg": 344.24,
+            "unit": "µs",
+            "avgNs": 344240
+          },
+          {
+            "name": "remark",
+            "avg": 4.63,
+            "unit": "ms",
+            "avgNs": 4630000
+          },
+          {
+            "name": "remark + emoji",
+            "avg": 4.96,
+            "unit": "ms",
+            "avgNs": 4960000
+          }
+        ]
+      }
+    ],
+    "plugin-highlight": [
+      {
+        "name": "highlight — short (2 blocks)",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 4.5,
+            "unit": "µs",
+            "avgNs": 4500
+          },
+          {
+            "name": "comark + highlight",
+            "avg": 170.33,
+            "unit": "µs",
+            "avgNs": 170330
+          },
+          {
+            "name": "markdown-it + shiki",
+            "avg": 173.02,
+            "unit": "µs",
+            "avgNs": 173020
+          },
+          {
+            "name": "markdown-exit + shiki",
+            "avg": 174.17,
+            "unit": "µs",
+            "avgNs": 174170
+          }
+        ]
+      },
+      {
+        "name": "highlight — medium (3 blocks)",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 7.7,
+            "unit": "µs",
+            "avgNs": 7700
+          },
+          {
+            "name": "comark + highlight",
+            "avg": 732.79,
+            "unit": "µs",
+            "avgNs": 732790
+          },
+          {
+            "name": "markdown-it + shiki",
+            "avg": 751.98,
+            "unit": "µs",
+            "avgNs": 751980
+          },
+          {
+            "name": "markdown-exit + shiki",
+            "avg": 762.79,
+            "unit": "µs",
+            "avgNs": 762790
+          }
+        ]
+      },
+      {
+        "name": "highlight — long (40 blocks)",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 47.44,
+            "unit": "µs",
+            "avgNs": 47440
+          },
+          {
+            "name": "comark + highlight",
+            "avg": 7.56,
+            "unit": "ms",
+            "avgNs": 7560000
+          },
+          {
+            "name": "markdown-it + shiki",
+            "avg": 7.65,
+            "unit": "ms",
+            "avgNs": 7650000
+          },
+          {
+            "name": "markdown-exit + shiki",
+            "avg": 7.58,
+            "unit": "ms",
+            "avgNs": 7580000
+          }
+        ]
+      }
+    ],
+    "plugin-punctuation": [
+      {
+        "name": "punctuation — short text",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 1.94,
+            "unit": "µs",
+            "avgNs": 1940
+          },
+          {
+            "name": "comark + punctuation",
+            "avg": 2.49,
+            "unit": "µs",
+            "avgNs": 2490
+          },
+          {
+            "name": "markdown-it",
+            "avg": 956.48,
+            "unit": "ns",
+            "avgNs": 956.48
+          },
+          {
+            "name": "markdown-it + typographer",
+            "avg": 2.37,
+            "unit": "µs",
+            "avgNs": 2370
+          },
+          {
+            "name": "markdown-exit",
+            "avg": 802.68,
+            "unit": "ns",
+            "avgNs": 802.68
+          },
+          {
+            "name": "markdown-exit + typographer",
+            "avg": 2.06,
+            "unit": "µs",
+            "avgNs": 2060
+          },
+          {
+            "name": "remark",
+            "avg": 29.14,
+            "unit": "µs",
+            "avgNs": 29140
+          },
+          {
+            "name": "remark + smartypants",
+            "avg": 56.29,
+            "unit": "µs",
+            "avgNs": 56290
+          }
+        ]
+      },
+      {
+        "name": "punctuation — medium text",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 8.48,
+            "unit": "µs",
+            "avgNs": 8480
+          },
+          {
+            "name": "comark + punctuation",
+            "avg": 10.93,
+            "unit": "µs",
+            "avgNs": 10930
+          },
+          {
+            "name": "markdown-it",
+            "avg": 5.89,
+            "unit": "µs",
+            "avgNs": 5890
+          },
+          {
+            "name": "markdown-it + typographer",
+            "avg": 11.6,
+            "unit": "µs",
+            "avgNs": 11600
+          },
+          {
+            "name": "markdown-exit",
+            "avg": 5.08,
+            "unit": "µs",
+            "avgNs": 5080
+          },
+          {
+            "name": "markdown-exit + typographer",
+            "avg": 10.54,
+            "unit": "µs",
+            "avgNs": 10540
+          },
+          {
+            "name": "remark",
+            "avg": 96.22,
+            "unit": "µs",
+            "avgNs": 96220
+          },
+          {
+            "name": "remark + smartypants",
+            "avg": 255.47,
+            "unit": "µs",
+            "avgNs": 255470
+          }
+        ]
+      },
+      {
+        "name": "punctuation — long text (50 sections)",
+        "entries": [
+          {
+            "name": "comark",
+            "avg": 424.01,
+            "unit": "µs",
+            "avgNs": 424010
+          },
+          {
+            "name": "comark + punctuation",
+            "avg": 525.64,
+            "unit": "µs",
+            "avgNs": 525640
+          },
+          {
+            "name": "markdown-it",
+            "avg": 264.75,
+            "unit": "µs",
+            "avgNs": 264750
+          },
+          {
+            "name": "markdown-it + typographer",
+            "avg": 487.09,
+            "unit": "µs",
+            "avgNs": 487090
+          },
+          {
+            "name": "markdown-exit",
+            "avg": 234.3,
+            "unit": "µs",
+            "avgNs": 234300
+          },
+          {
+            "name": "markdown-exit + typographer",
+            "avg": 444.92,
+            "unit": "µs",
+            "avgNs": 444920
+          },
+          {
+            "name": "remark",
+            "avg": 3.81,
+            "unit": "ms",
+            "avgNs": 3810000
+          },
+          {
+            "name": "remark + smartypants",
+            "avg": 11.11,
+            "unit": "ms",
+            "avgNs": 11110000
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/docs/server/api/benchmarks.get.ts b/docs/server/api/benchmarks.get.ts
new file mode 100644
index 00000000..5214ba1c
--- /dev/null
+++ b/docs/server/api/benchmarks.get.ts
@@ -0,0 +1,15 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+export default defineEventHandler(() => {
+  const filePath = join(process.cwd(), 'docs', 'public', 'benchmarks.json')
+
+  if (existsSync(filePath)) {
+    return JSON.parse(readFileSync(filePath, 'utf-8'))
+  }
+
+  throw createError({
+    statusCode: 404,
+    statusMessage: 'Benchmarks data not found. run: `node scripts/bench.mjs`',
+  })
+})
diff --git a/package.json b/package.json
index 514fab67..281c6902 100644
--- a/package.json
+++ b/package.json
@@ -52,17 +52,21 @@
     "comark": "workspace:*",
     "markdown-exit": "catalog:",
     "markdown-it": "catalog:",
+    "markdown-it-emoji": "^3.0.0",
     "mitata": "catalog:",
     "nuxt": "catalog:",
     "oxfmt": "catalog:",
     "oxlint": "catalog:",
     "playwright": "catalog:",
     "release-it": "catalog:",
+    "remark-emoji": "^5.0.2",
     "remark-gfm": "catalog:",
     "remark-mdc": "catalog:",
     "remark-parse": "catalog:",
     "remark-rehype": "catalog:",
+    "remark-smartypants": "^3.0.2",
     "scule": "catalog:",
+    "shiki": "catalog:",
     "tsx": "catalog:",
     "typescript": "catalog:",
     "unified": "catalog:"
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 2695322c..f61777bc 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -217,7 +217,7 @@ catalogs:
       specifier: ^1.3.0
       version: 1.3.0
     shiki:
-      specifier: ^4.0.0
+      specifier: ^4.1.0
       version: 4.1.0
     splitpanes:
       specifier: ^4.0.4
@@ -321,6 +321,9 @@ importers:
       markdown-it:
         specifier: 'catalog:'
         version: 14.2.0
+      markdown-it-emoji:
+        specifier: ^3.0.0
+        version: 3.0.0
       mitata:
         specifier: 'catalog:'
         version: 1.0.34
@@ -339,6 +342,9 @@ importers:
       release-it:
         specifier: 'catalog:'
         version: 19.2.4(@types/node@25.9.1)(magicast@0.5.3)
+      remark-emoji:
+        specifier: ^5.0.2
+        version: 5.0.2
       remark-gfm:
         specifier: 'catalog:'
         version: 4.0.1
@@ -351,9 +357,15 @@ importers:
       remark-rehype:
         specifier: 'catalog:'
         version: 11.1.2
+      remark-smartypants:
+        specifier: ^3.0.2
+        version: 3.0.2
       scule:
         specifier: 'catalog:'
         version: 1.3.0
+      shiki:
+        specifier: 'catalog:'
+        version: 4.1.0
       tsx:
         specifier: 'catalog:'
         version: 4.22.4
@@ -7680,6 +7692,9 @@ packages:
   markdown-exit@1.0.0-beta.9:
     resolution: {integrity: sha512-5tzrMKMF367amyBly131vm6eGuWRL2DjBqWaFmPzPbLyuxP0XOmyyyroOAIXuBAMF/3kZbbfqOxvW/SotqKqbQ==}
 
+  markdown-it-emoji@3.0.0:
+    resolution: {integrity: sha512-+rUD93bXHubA4arpEZO3q80so0qgoFJEKRkRbjKX8RTdca89v2kfyF+xR3i2sQTwql9tpPZPOQN5B+PunspXRg==}
+
   markdown-it-math@5.2.1:
     resolution: {integrity: sha512-0YJczaqvBxgOt13oKj/4HYs/34Y9FsHiTktsIBaWYqrE+k1JxmMSTxCcTezTVul0YjmhmCBDehK65vWxjzRbdg==}
     peerDependencies:
@@ -16945,6 +16960,8 @@ snapshots:
       punycode.js: 2.3.1
       uc.micro: 2.1.0
 
+  markdown-it-emoji@3.0.0: {}
+
   markdown-it-math@5.2.1: {}
 
   markdown-it@14.2.0:
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 8ef997e3..728c4f07 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -110,7 +110,7 @@ catalog:
   scule: ^1.3.0
 
   # Shared peer dependencies
-  shiki: ^4.0.0
+  shiki: ^4.1.0
   splitpanes: ^4.0.4
 
   # Svelte
diff --git a/scripts/bench.mjs b/scripts/bench.mjs
new file mode 100644
index 00000000..c3cd29a7
--- /dev/null
+++ b/scripts/bench.mjs
@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+/**
+ * Run all benchmarks and save results to docs/public/benchmarks.json
+ *
+ * Usage:
+ *   node scripts/bench.mjs           # run all benchmarks
+ *   node scripts/bench.mjs <filter>  # run only benchmarks matching "<filter>"
+ */
+
+import { execSync } from 'node:child_process'
+import { readdirSync, writeFileSync, mkdirSync, existsSync } from 'node:fs'
+import { join, basename } from 'node:path'
+
+const root = new URL('..', import.meta.url).pathname
+const benchDir = join(root, 'benchmarks')
+const outFile = join(root, 'docs', 'public', 'benchmarks.json')
+
+const filter = process.argv[2]
+
+// Discover benchmark files
+const files = readdirSync(benchDir)
+  .filter((f) => f.endsWith('.ts'))
+  .filter((f) => !filter || f.includes(filter))
+  .sort()
+
+if (files.length === 0) {
+  console.error(`No benchmark files found${filter ? ` matching "${filter}"` : ''}.`)
+  process.exit(1)
+}
+
+// Ensure output directory exists
+const outDir = join(root, 'docs', 'public')
+if (!existsSync(outDir)) {
+  mkdirSync(outDir, { recursive: true })
+}
+
+console.log(`Found ${files.length} benchmark(s):\n`)
+files.forEach((f) => console.log(`  - ${f}`))
+console.log()
+
+const results = {}
+const errors = []
+
+for (const file of files) {
+  const name = basename(file, '.ts')
+  console.log(`▶ Running ${file}...`)
+
+  try {
+    // Strip ANSI codes from output for clean text
+    const output = execSync(`npx tsx "${join(benchDir, file)}"`, {
+      cwd: root,
+      encoding: 'utf-8',
+      timeout: 5 * 60 * 1000, // 5 minutes per benchmark
+      env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    // Strip any remaining ANSI escape codes
+    const clean = output.replace(/\x1B\[[0-9;]*[a-z]/gi, '')
+
+    results[name] = clean
+    console.log(`  ✓ Done\n`)
+  } catch (err) {
+    const message = err.stderr?.toString() || err.message
+    errors.push({ file, message })
+    console.error(`  ✗ Failed: ${message.split('\n')[0]}\n`)
+  }
+}
+
+// Generate a combined JSON summary with extracted stats
+const summary = {
+  generated: new Date().toISOString(),
+  runtime: null,
+  cpu: null,
+  benchmarks: {},
+}
+
+for (const [name, output] of Object.entries(results)) {
+  // Extract runtime info from first benchmark
+  const cpuMatch = output.match(/cpu:\s*(.+)/)
+  const runtimeMatch = output.match(/runtime:\s*(.+)/)
+  if (cpuMatch) summary.cpu = cpuMatch[1].trim()
+  if (runtimeMatch) summary.runtime = runtimeMatch[1].trim()
+
+  // Extract benchmark groups and results
+  const groups = []
+  const lines = output.split('\n')
+
+  let currentGroup = null
+
+  for (const line of lines) {
+    // Group header: • group name
+    const groupMatch = line.match(/^•\s+(.+)$/)
+    if (groupMatch) {
+      currentGroup = { name: groupMatch[1], entries: [] }
+      groups.push(currentGroup)
+      continue
+    }
+
+    // Bench result: name    avg/iter
+    // Format: "name                     123.45 ns/iter ..."
+    if (currentGroup) {
+      const benchMatch = line.match(/^(\S.*?)\s{2,}(\d[\d,.]*)\s+(ns|µs|ms|s)\/iter/)
+      if (benchMatch) {
+        const benchName = benchMatch[1].trim()
+        const value = Number.parseFloat(benchMatch[2].replace(/,/g, ''))
+        const unit = benchMatch[3]
+
+        // Normalize to nanoseconds
+        const multipliers = { ns: 1, µs: 1e3, ms: 1e6, s: 1e9 }
+        const ns = value * (multipliers[unit] || 1)
+
+        currentGroup.entries.push({
+          name: benchName,
+          avg: value,
+          unit,
+          avgNs: ns,
+        })
+      }
+    }
+  }
+
+  summary.benchmarks[name] = groups
+}
+
+writeFileSync(outFile, JSON.stringify(summary, null, 2))
+console.log('─'.repeat(50))
+console.log(`\n✓ Results saved to docs/public/benchmarks.json`)
+
+if (errors.length > 0) {
+  console.log(`\n✗ ${errors.length} benchmark(s) failed:`)
+  errors.forEach((e) => console.log(`  - ${e.file}: ${e.message.split('\n')[0]}`))
+  process.exit(1)
+}
+
+console.log(`\n✓ All ${files.length} benchmarks completed successfully.`)