mkdnsite 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Andrew Goode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,211 @@
+# mkdnsite
+
+**Markdown for the web. HTML for humans, Markdown for agents.**
+
+mkdnsite turns a directory of Markdown files into a live website — with zero build step. The same URL serves beautifully rendered HTML to browsers and clean Markdown to AI agents, using standard HTTP content negotiation.
+
+```
+Cloudflare, Vercel, et al:   HTML → Markdown (for AI)
+mkdnsite:                    Markdown → HTML (for humans)
+
+Same content negotiation standard. Opposite direction.
+Markdown is the source of truth.
+```
+
+## Quick Start
+
+```bash
+bun add -g mkdnsite
+mkdir my-site && echo "# Hello World" > my-site/index.md
+mkdnsite ./my-site
+```
+
+```bash
+curl http://localhost:3000                              # HTML for humans
+curl -H "Accept: text/markdown" http://localhost:3000   # Markdown for agents
+curl http://localhost:3000/llms.txt                      # AI content index
+```
+
+Also runs on Node and Deno:
+
+```bash
+node src/cli.ts ./my-site
+deno run --allow-read --allow-net src/cli.ts ./my-site
+```
+
+## Features
+
+- **Zero build step** — runtime Markdown→HTML via React SSR
+- **Content negotiation** — `Accept: text/markdown` returns raw MD
+- **Beautiful by default** — shadcn/Radix-inspired typography with light/dark mode
+- **Theme toggle** — sun/moon button with animated circular reveal (View Transitions API)
+- **Syntax highlighting** — Shiki SSR with dual-theme support (light + dark)
+- **Math rendering** — KaTeX via `remark-math` + `rehype-katex` (SSR)
+- **GFM Alerts** — `[!NOTE]`, `[!TIP]`, `[!IMPORTANT]`, `[!WARNING]`, `[!CAUTION]`
+- **GitHub-Flavored Markdown** — tables, task lists, strikethrough, autolinks
+- **Collapsible sections** — `<details>` and `<summary>` with HTML sanitization
+- **Mermaid diagrams** — rendered client-side from fenced code blocks
+- **Copy-to-clipboard** — on all code blocks
+- **Pluggable rendering** — custom React components per element
+- **Auto `/llms.txt`** — AI agents discover your content
+- **`x-markdown-tokens` header** — Cloudflare-compatible token count
+- **`Content-Signal` header** — AI consent signaling
+- **YAML frontmatter** — title, description, ordering, tags, drafts
+- **Filesystem routing** — directory structure = URL structure
+- **Auto-navigation** — sidebar from file tree
+- **Portable** — runs on Bun, Node 22+, and Deno
+
+## Architecture
+
+```
+┌─────────────┐     ┌──────────────┐     ┌───────────────┐
+│   Request    │────▶│   Handler    │────▶│   Response    │
+│ Accept: ???  │     │ (portable)   │     │ HTML or MD    │
+└─────────────┘     └──────┬───────┘     └───────────────┘
+                           │
+              ┌────────────┼────────────┐
+              ▼            ▼            ▼
+        ┌──────────┐ ┌──────────┐ ┌──────────┐
+        │ Content  │ │ Renderer │ │ Negotiate│
+        │ Source   │ │ (React)  │ │          │
+        └──────────┘ └──────────┘ └──────────┘
+              │            │
+     ┌────────┼──┐   ┌────┴────┐
+     ▼        ▼  ▼   ▼         ▼
+  Local   GitHub R2  portable  bun-native
+  FS      API       (react-md) (Bun.md)
+```
+
+### Deployment Adapters
+
+mkdnsite ships adapter stubs for multiple platforms:
+
+| Adapter | Status | Content Source |
+|---------|--------|----------------|
+| Local (Bun/Node/Deno) | Working | Filesystem |
+| Cloudflare Workers | Stub | R2 / GitHub |
+| Vercel Edge | Stub | Blob / GitHub |
+| Netlify | Stub | TBD |
+| Fly.io | Stub | Filesystem (volumes) |
+
+### Theme Modes
+
+- **prose** (default): Beautiful typography via CSS, zero-config
+- **components**: Full React component overrides with your own styling
+
+## Configuration
+
+Create `mkdnsite.config.ts`:
+
+```typescript
+import type { MkdnSiteConfig } from 'mkdnsite'
+
+export default {
+  contentDir: './docs',
+  site: {
+    title: 'My Documentation',
+    url: 'https://docs.example.com'
+  },
+  theme: {
+    mode: 'prose',
+    showNav: true,
+    colorScheme: 'system',
+    syntaxTheme: 'github-light',
+    syntaxThemeDark: 'github-dark'
+  },
+  client: {
+    enabled: true,
+    themeToggle: true,
+    math: true,
+    mermaid: true,
+    copyButton: true
+  },
+  renderer: 'portable'
+} satisfies Partial<MkdnSiteConfig>
+```
+
+Or use CLI flags:
+
+```bash
+mkdnsite ./docs --port 8080 --title "My Docs"
+mkdnsite ./docs --color-scheme dark --no-theme-toggle
+mkdnsite ./docs --no-math --no-client-js
+mkdnsite ./docs --renderer bun-native
+```
+
+### CLI Options
+
+| Flag | Description | Default |
+|------|-------------|---------|
+| `-p, --port <n>` | Port to listen on | `3000` |
+| `--title <text>` | Site title | `mkdnsite` |
+| `--url <url>` | Base URL for absolute links | — |
+| `--static <dir>` | Static assets directory | — |
+| `--color-scheme <val>` | `system`, `light`, or `dark` | `system` |
+| `--theme-mode <mode>` | `prose` or `components` | `prose` |
+| `--renderer <engine>` | `portable` or `bun-native` | `portable` |
+| `--no-nav` | Disable navigation sidebar | — |
+| `--no-llms-txt` | Disable /llms.txt generation | — |
+| `--no-negotiate` | Disable content negotiation | — |
+| `--no-client-js` | Disable all client-side JavaScript | — |
+| `--no-theme-toggle` | Disable light/dark theme toggle | — |
+| `--no-math` | Disable KaTeX math rendering | — |
+
+## Content Negotiation
+
+Same pattern as Cloudflare Markdown for Agents and Vercel:
+
+| Client | Accept Header | Response |
+|--------|--------------|----------|
+| Browser | `text/html` | React SSR rendered page |
+| Claude Code | `text/markdown, text/html, */*` | Raw Markdown |
+| Cursor | `text/markdown;q=1.0, text/html;q=0.7` | Raw Markdown |
+| curl (default) | `*/*` | Rendered HTML |
+| `.md` URL suffix | — | Raw Markdown |
+
+## Programmatic Usage
+
+```typescript
+import { createHandler, resolveConfig, FilesystemSource } from 'mkdnsite'
+import { createRenderer } from 'mkdnsite'
+
+const config = resolveConfig({ site: { title: 'My Site' } })
+const renderer = await createRenderer({
+  syntaxTheme: 'github-light',
+  syntaxThemeDark: 'github-dark'
+})
+const handler = createHandler({
+  source: new FilesystemSource('./content'),
+  renderer,
+  config
+})
+
+// Use with any platform's serve API
+Bun.serve({ fetch: handler, port: 3000 })
+```
+
+## Roadmap
+
+- [x] Syntax highlighting via Shiki (server-side)
+- [x] Light/dark theme toggle with animation
+- [x] KaTeX math rendering (SSR)
+- [x] GFM alerts (NOTE, TIP, IMPORTANT, WARNING, CAUTION)
+- [x] HTML sanitization for safe raw HTML passthrough
+- [ ] Table of contents per page
+- [ ] Client-side search with pre-built index
+- [ ] GitHub content source (serve from repo)
+- [ ] Custom themes (CSS files or npm packages)
+- [ ] Hosted service at mkdn.io
+- [ ] RSS feed generation
+- [ ] OpenGraph meta tags
+- [ ] Human vs. AI traffic analytics
+
+## Links
+
+- **Documentation**: [mkdn.site](https://mkdn.site)
+- **Hosted service**: [mkdn.io](https://mkdn.io) (coming soon)
+- **Repository**: [github.com/mkdnsite/mkdnsite](https://github.com/mkdnsite/mkdnsite)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "mkdnsite",
+  "version": "0.0.1",
+  "description": "Markdown for the web. HTML for humans, Markdown for agents.",
+  "type": "module",
+  "main": "src/index.ts",
+  "bin": {
+    "mkdnsite": "src/cli.ts"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./adapters/cloudflare": "./src/adapters/cloudflare.ts",
+    "./adapters/vercel": "./src/adapters/vercel.ts",
+    "./adapters/netlify": "./src/adapters/netlify.ts",
+    "./adapters/fly": "./src/adapters/fly.ts"
+  },
+  "scripts": {
+    "dev": "bun run --watch src/cli.ts ./content",
+    "start": "bun run src/cli.ts",
+    "test": "bun test",
+    "lint": "ts-standard src/ test/",
+    "lint:fix": "ts-standard src/ test/ --fix",
+    "tsc": "tsc --noEmit"
+  },
+  "keywords": [
+    "markdown",
+    "server",
+    "content-negotiation",
+    "ai-agents",
+    "llms-txt",
+    "gfm",
+    "react",
+    "ssr",
+    "tailwind",
+    "bun"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mkdnsite/mkdnsite.git"
+  },
+  "homepage": "https://mkdn.site",
+  "license": "MIT",
+  "files": [
+    "src"
+  ],
+  "dependencies": {
+    "gray-matter": "^4.0.3",
+    "katex": "^0.16.38",
+    "lucide-react": "^0.577.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-markdown": "^9.0.0",
+    "rehype-katex": "^7.0.1",
+    "rehype-raw": "^7.0.0",
+    "rehype-sanitize": "^6.0.0",
+    "rehype-slug": "^6.0.0",
+    "remark-gfm": "^4.0.0",
+    "remark-github-blockquote-alert": "^2.0.1",
+    "remark-math": "^6.0.0",
+    "shiki": "^3.0.0"
+  },
+  "ts-standard": {
+    "project": "./tsconfig.json"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "ts-standard": "^12.0.2",
+    "typescript": "^5.7.0"
+  }
+}

package/src/adapters/cloudflare.ts

@@ -0,0 +1,85 @@
+import type { DeploymentAdapter } from './types.ts'
+import type { MkdnSiteConfig } from '../config/schema.ts'
+import type { ContentSource } from '../content/types.ts'
+import type { MarkdownRenderer } from '../render/types.ts'
+import { createRenderer } from '../render/types.ts'
+
+/**
+ * Cloudflare Workers deployment adapter.
+ *
+ * Uses R2 for content storage, KV for caching.
+ * Wildcard DNS routes (*.mkdn.io) for hosted service.
+ *
+ * Usage in a Worker:
+ *
+ * ```ts
+ * import { createHandler, resolveConfig } from 'mkdnsite'
+ * import { CloudflareAdapter } from 'mkdnsite/adapters/cloudflare'
+ *
+ * export default {
+ *   fetch (request: Request, env: Env): Promise<Response> {
+ *     const adapter = new CloudflareAdapter(env)
+ *     const config = resolveConfig({ site: { title: env.SITE_TITLE } })
+ *     const handler = createHandler({
+ *       source: adapter.createContentSource(config),
+ *       renderer: adapter.createRenderer(config),
+ *       config
+ *     })
+ *     return handler(request)
+ *   }
+ * }
+ * ```
+ */
+export class CloudflareAdapter implements DeploymentAdapter {
+  readonly name = 'cloudflare-workers'
+  private readonly env: CloudflareEnv
+
+  constructor (env: CloudflareEnv) {
+    this.env = env
+  }
+
+  createContentSource (_config: MkdnSiteConfig): ContentSource {
+    // TODO: Implement R2ContentSource
+    // return new R2ContentSource(this.env.CONTENT_BUCKET)
+    throw new Error(
+      'CloudflareAdapter.createContentSource() not yet implemented. ' +
+      'Provide an R2-backed ContentSource implementation.'
+    )
+  }
+
+  async createRenderer (_config: MkdnSiteConfig): Promise<MarkdownRenderer> {
+    // CF Workers don't have Bun.markdown, always use portable
+    return await createRenderer('portable')
+  }
+}
+
+/**
+ * Expected Cloudflare Worker environment bindings.
+ */
+export interface CloudflareEnv {
+  /** R2 bucket for markdown content */
+  CONTENT_BUCKET?: R2Bucket
+  /** KV namespace for caching */
+  CACHE_KV?: KVNamespace
+  /** Site title from env var */
+  SITE_TITLE?: string
+  /** Site URL from env var */
+  SITE_URL?: string
+}
+
+// Type stubs for CF runtime types (not available in non-CF environments)
+interface R2Bucket {
+  get: (key: string) => Promise<R2Object | null>
+  list: (options?: Record<string, unknown>) => Promise<{ objects: R2Object[] }>
+}
+
+interface R2Object {
+  key: string
+  uploaded: Date
+  text: () => Promise<string>
+}
+
+interface KVNamespace {
+  get: (key: string) => Promise<string | null>
+  put: (key: string, value: string, options?: Record<string, unknown>) => Promise<void>
+}

package/src/adapters/fly.ts

@@ -0,0 +1,22 @@
+import type { DeploymentAdapter } from './types.ts'
+import type { MkdnSiteConfig } from '../config/schema.ts'
+import type { ContentSource } from '../content/types.ts'
+import type { MarkdownRenderer } from '../render/types.ts'
+import { FilesystemSource } from '../content/filesystem.ts'
+import { createRenderer } from '../render/types.ts'
+
+/**
+ * Fly.io adapter.
+ * Uses filesystem source (persistent volumes on Fly).
+ */
+export class FlyAdapter implements DeploymentAdapter {
+  readonly name = 'fly'
+
+  createContentSource (config: MkdnSiteConfig): ContentSource {
+    return new FilesystemSource(config.contentDir)
+  }
+
+  async createRenderer (_config: MkdnSiteConfig): Promise<MarkdownRenderer> {
+    return await createRenderer('portable')
+  }
+}

package/src/adapters/local.ts

@@ -0,0 +1,153 @@
+import type { DeploymentAdapter } from './types.ts'
+import { detectRuntime } from './types.ts'
+import type { MkdnSiteConfig } from '../config/schema.ts'
+import type { ContentSource } from '../content/types.ts'
+import type { MarkdownRenderer } from '../render/types.ts'
+import { FilesystemSource } from '../content/filesystem.ts'
+import { createRenderer } from '../render/types.ts'
+
+export class LocalAdapter implements DeploymentAdapter {
+  readonly name: string
+  private rendererEngine: string = 'portable'
+
+  constructor () {
+    this.name = `local (${detectRuntime()})`
+  }
+
+  createContentSource (config: MkdnSiteConfig): ContentSource {
+    return new FilesystemSource(config.contentDir)
+  }
+
+  async createRenderer (config: MkdnSiteConfig): Promise<MarkdownRenderer> {
+    const renderer = await createRenderer({
+      engine: config.renderer,
+      syntaxTheme: config.theme.syntaxTheme,
+      syntaxThemeDark: config.theme.syntaxThemeDark,
+      math: config.client.math
+    })
+    this.rendererEngine = renderer.engine
+    return renderer
+  }
+
+  async start (
+    handler: (request: Request) => Promise<Response>,
+    config: MkdnSiteConfig
+  ): Promise<() => void> {
+    const runtime = detectRuntime()
+
+    if (runtime === 'bun') {
+      return this.startBun(handler, config)
+    }
+
+    if (runtime === 'deno') {
+      return this.startDeno(handler, config)
+    }
+
+    return await this.startNode(handler, config)
+  }
+
+  private startBun (
+    handler: (request: Request) => Promise<Response>,
+    config: MkdnSiteConfig
+  ): () => void {
+    const server = Bun.serve({
+      port: config.server.port,
+      hostname: config.server.hostname,
+      fetch: handler
+    })
+
+    this.printStartup(config, server.port ?? config.server.port)
+    return () => { void server.stop() }
+  }
+
+  private startDeno (
+    handler: (request: Request) => Promise<Response>,
+    config: MkdnSiteConfig
+  ): () => void {
+    const { port, hostname } = config.server
+
+    // Deno.serve is available globally in Deno
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const DenoNs = (globalThis as any).Deno
+    const server = DenoNs.serve({ port, hostname }, handler)
+
+    this.printStartup(config, port)
+    return () => { void server.shutdown() }
+  }
+
+  private async startNode (
+    handler: (request: Request) => Promise<Response>,
+    config: MkdnSiteConfig
+  ): Promise<() => void> {
+    const { port, hostname } = config.server
+    const { createServer } = await import('node:http')
+
+    const server = createServer((req, res) => {
+      const host = req.headers.host ?? `${hostname}:${String(port)}`
+      const url = new URL(req.url ?? '/', `http://${host}`)
+
+      const headers = new Headers()
+      for (const [key, value] of Object.entries(req.headers)) {
+        if (value != null) {
+          if (Array.isArray(value)) {
+            for (const v of value) headers.append(key, v)
+          } else {
+            headers.set(key, value)
+          }
+        }
+      }
+
+      const request = new Request(url.toString(), {
+        method: req.method,
+        headers
+      })
+
+      handler(request)
+        .then(async (response) => {
+          const resHeaders: Record<string, string> = {}
+          response.headers.forEach((value, key) => {
+            resHeaders[key] = value
+          })
+          res.writeHead(response.status, resHeaders)
+          const body = Buffer.from(await response.arrayBuffer())
+          res.end(body)
+        })
+        .catch((err) => {
+          console.error('mkdnsite: request error', err)
+          res.writeHead(500)
+          res.end('Internal Server Error')
+        })
+    })
+
+    await new Promise<void>((resolve) => {
+      server.listen(port, hostname, () => { resolve() })
+    })
+
+    this.printStartup(config, port)
+    return () => { server.close() }
+  }
+
+  private printStartup (config: MkdnSiteConfig, port: number): void {
+    const url = `http://localhost:${String(port)}`
+    console.log('')
+    console.log('  ┌──────────────────────────────────────────────┐')
+    console.log('  │                                              │')
+    console.log('  │   mkdnsite is running                       │')
+    console.log(`  │   ${url.padEnd(42)} │`)
+    console.log('  │                                              │')
+    console.log(`  │   Runtime: ${this.name.padEnd(32)} │`)
+    console.log(`  │   Content: ${config.contentDir.padEnd(32)} │`)
+    console.log(`  │   Renderer: ${this.rendererEngine.padEnd(30)} │`)
+    console.log(`  │   Theme mode: ${config.theme.mode.padEnd(28)} │`)
+    console.log(`  │   Client JS: ${(config.client.enabled ? 'on' : 'off').padEnd(29)} │`)
+    console.log(`  │   Content negotiation: ${(config.negotiation.enabled ? 'on' : 'off').padEnd(19)} │`)
+    console.log('  │                                              │')
+    console.log('  └──────────────────────────────────────────────┘')
+    console.log('')
+    console.log('  Try:')
+    console.log(`    curl ${url}`)
+    console.log(`    curl -H "Accept: text/markdown" ${url}`)
+    console.log(`    curl ${url}/llms.txt`)
+    console.log('')
+  }
+}

package/src/adapters/netlify.ts

@@ -0,0 +1,17 @@
+import type { DeploymentAdapter } from './types.ts'
+import type { MkdnSiteConfig } from '../config/schema.ts'
+import type { ContentSource } from '../content/types.ts'
+import type { MarkdownRenderer } from '../render/types.ts'
+import { createRenderer } from '../render/types.ts'
+
+export class NetlifyAdapter implements DeploymentAdapter {
+  readonly name = 'netlify'
+
+  createContentSource (_config: MkdnSiteConfig): ContentSource {
+    throw new Error('NetlifyAdapter.createContentSource() not yet implemented.')
+  }
+
+  async createRenderer (_config: MkdnSiteConfig): Promise<MarkdownRenderer> {
+    return await createRenderer('portable')
+  }
+}

package/src/adapters/types.ts

@@ -0,0 +1,54 @@
+import type { MkdnSiteConfig } from '../config/schema.ts'
+import type { ContentSource } from '../content/types.ts'
+import type { MarkdownRenderer } from '../render/types.ts'
+
+/**
+ * Deployment adapter interface.
+ *
+ * Each target deployment environment (Bun local, CF Workers,
+ * Vercel Edge, Netlify, Fly.io, etc.) implements this interface
+ * to provide the appropriate content source, renderer, and
+ * any environment-specific setup.
+ *
+ * The adapter is responsible for:
+ * 1. Creating the appropriate ContentSource for its environment
+ * 2. Creating the appropriate MarkdownRenderer
+ * 3. Providing the fetch handler in the format the platform expects
+ * 4. Any platform-specific initialization (e.g. binding to KV, R2, etc.)
+ */
+export interface DeploymentAdapter {
+  /** Human-readable name for logging */
+  readonly name: string
+
+  /** Create the content source for this environment */
+  createContentSource: (config: MkdnSiteConfig) => ContentSource
+
+  /** Create the markdown renderer for this environment */
+  createRenderer: (config: MkdnSiteConfig) => Promise<MarkdownRenderer>
+
+  /**
+   * Start the server (for adapters that manage their own server).
+   * Returns a cleanup function.
+   * For serverless adapters, this is a no-op.
+   */
+  start?: (
+    handler: (request: Request) => Promise<Response>,
+    config: MkdnSiteConfig
+  ) => Promise<(() => void) | undefined>
+}
+
+/**
+ * Detect the current runtime environment.
+ */
+export function detectRuntime (): 'bun' | 'cloudflare' | 'vercel' | 'netlify' | 'node' | 'deno' {
+  if (typeof Bun !== 'undefined') return 'bun'
+  if (typeof globalThis !== 'undefined') {
+    const g = globalThis as Record<string, unknown>
+    if (g.caches != null && g.MINIFLARE != null) return 'cloudflare'
+    if (g.Netlify != null) return 'netlify'
+    if (g.Deno != null) return 'deno'
+  }
+  // Check for Vercel Edge Runtime
+  if (process?.env?.VERCEL != null) return 'vercel'
+  return 'node'
+}

package/src/adapters/vercel.ts

@@ -0,0 +1,48 @@
+import type { DeploymentAdapter } from './types.ts'
+import type { MkdnSiteConfig } from '../config/schema.ts'
+import type { ContentSource } from '../content/types.ts'
+import type { MarkdownRenderer } from '../render/types.ts'
+import { createRenderer } from '../render/types.ts'
+
+/**
+ * Vercel Edge/Serverless deployment adapter.
+ *
+ * For Vercel, the handler is exported as a standard Edge Function.
+ * Content can come from Vercel Blob Storage or a connected GitHub repo.
+ *
+ * Usage in a Vercel Edge Function:
+ *
+ * ```ts
+ * // app/api/[...path]/route.ts
+ * import { createHandler, resolveConfig } from 'mkdnsite'
+ * import { VercelAdapter } from 'mkdnsite/adapters/vercel'
+ *
+ * const adapter = new VercelAdapter()
+ * const config = resolveConfig({
+ *   site: { title: 'My Docs' }
+ * })
+ *
+ * export const GET = createHandler({
+ *   source: adapter.createContentSource(config),
+ *   renderer: adapter.createRenderer(config),
+ *   config
+ * })
+ *
+ * export const runtime = 'edge'
+ * ```
+ */
+export class VercelAdapter implements DeploymentAdapter {
+  readonly name = 'vercel'
+
+  createContentSource (_config: MkdnSiteConfig): ContentSource {
+    // TODO: Implement Vercel Blob-backed or GitHub-backed source
+    throw new Error(
+      'VercelAdapter.createContentSource() not yet implemented. ' +
+      'Provide a Blob-backed or GitHub-backed ContentSource.'
+    )
+  }
+
+  async createRenderer (_config: MkdnSiteConfig): Promise<MarkdownRenderer> {
+    return await createRenderer('portable')
+  }
+}