vocs 2.0.13 → 2.0.15

package/src/internal/mcp-transport.ts

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto'
-import type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js'
+import { isJSONRPCRequest, type JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js'
 
 /**
  * SSE Server Transport for Web APIs (Request/Response).
@@ -67,31 +67,20 @@ export class WebSSEServerTransport {
    * Returns the response to send back.
    */
   async handlePostMessage(body: unknown): Promise<Response> {
-    console.log('[MCP:SSE] handlePostMessage', JSON.stringify(body))
-    if (!this._writer) {
-      console.log('[MCP:SSE] No writer - SSE connection not established')
-      return new Response('SSE connection not established', { status: 500 })
-    }
+    if (!this._writer) return new Response('SSE connection not established', { status: 500 })
 
     try {
-      const message = body as JSONRPCMessage
-      this.onmessage?.(message)
-      console.log('[MCP:SSE] Message dispatched, returning 202')
+      this.onmessage?.(body as JSONRPCMessage)
       return new Response('Accepted', { status: 202 })
     } catch (error) {
-      console.error('[MCP:SSE] Error handling message:', error)
       this.onerror?.(error as Error)
       return new Response(`Invalid message: ${String(error)}`, { status: 400 })
     }
   }
 
   async send(message: JSONRPCMessage): Promise<void> {
-    console.log('[MCP:SSE] send', JSON.stringify(message).slice(0, 200))
-    if (!this._writer) {
-      throw new Error('Not connected')
-    }
+    if (!this._writer) throw new Error('Not connected')
     await this._write(`event: message\ndata: ${JSON.stringify(message)}\n\n`)
-    console.log('[MCP:SSE] Message sent to SSE stream')
   }
 
   async close(): Promise<void> {
@@ -136,33 +125,37 @@ export class WebStreamableHTTPServerTransport {
    * Handle a POST request. Returns a Response (either SSE stream or JSON).
    */
   async handleRequest(body: unknown, useSSE = true): Promise<Response> {
-    console.log('[MCP:HTTP] handleRequest', { useSSE, body: JSON.stringify(body).slice(0, 200) })
-    const message = body as JSONRPCMessage
+    const messages = Array.isArray(body) ? (body as JSONRPCMessage[]) : [body as JSONRPCMessage]
 
-    if (!this.sessionId && 'method' in message && message.method === 'initialize') {
+    const isInitialize = messages.some(
+      (message) => 'method' in message && message.method === 'initialize',
+    )
+    if (!this.sessionId && isInitialize) {
       this.sessionId = this._options.sessionIdGenerator?.() ?? randomUUID()
-      console.log('[MCP:HTTP] Session initialized:', this.sessionId)
       this._options.onsessioninitialized?.(this.sessionId)
     }
 
+    // Notifications/responses get no JSON-RPC reply -- ack with 202 instead of hanging.
+    if (!messages.some(isJSONRPCRequest)) {
+      for (const message of messages) this.onmessage?.(message)
+      return new Response(null, {
+        status: 202,
+        headers: this.sessionId ? { 'mcp-session-id': this.sessionId } : {},
+      })
+    }
+
     if (useSSE) {
-      console.log('[MCP:HTTP] Using SSE response mode')
       const { readable, writable } = new TransformStream<Uint8Array, Uint8Array>()
       this._responseWriter = writable.getWriter()
 
       this._pendingResponse = async (response) => {
-        console.log(
-          '[MCP:HTTP] SSE pending response received',
-          JSON.stringify(response).slice(0, 200),
-        )
         await this._write(`event: message\ndata: ${JSON.stringify(response)}\n\n`)
         try {
           await this._responseWriter?.close()
         } catch {}
       }
 
-      this.onmessage?.(message)
-      console.log('[MCP:HTTP] Message dispatched, returning SSE stream')
+      for (const message of messages) this.onmessage?.(message)
 
       return new Response(readable, {
         headers: {
@@ -173,21 +166,15 @@ export class WebStreamableHTTPServerTransport {
       })
     }
 
-    console.log('[MCP:HTTP] Using JSON response mode')
     return new Promise((resolve) => {
       this._pendingResponse = (response) => {
-        console.log(
-          '[MCP:HTTP] JSON pending response received',
-          JSON.stringify(response).slice(0, 200),
-        )
         resolve(
           Response.json(response, {
             headers: this.sessionId ? { 'mcp-session-id': this.sessionId } : {},
           }),
         )
       }
-      this.onmessage?.(message)
-      console.log('[MCP:HTTP] Message dispatched, waiting for response')
+      for (const message of messages) this.onmessage?.(message)
     })
   }
 

package/src/internal/mdx.test.ts

@@ -1,13 +1,19 @@
+import type * as MdAst from 'mdast'
+import remarkFrontmatter from 'remark-frontmatter'
+import remarkParse from 'remark-parse'
 import ruby from 'shiki/langs/ruby.mjs'
+import { unified } from 'unified'
 import { describe, expect, it } from 'vitest'
 import * as Config from './config.js'
 import {
   getCompileOptions,
   remarkCodeTitle,
+  remarkDefaultFrontmatter,
   remarkFilename,
   remarkFileTree,
   remarkLangCommaAttrs,
   remarkRestoreUnknownTextDirectives,
+  remarkSubheading,
 } from './mdx.js'
 
 type CodeNode = {
@@ -62,6 +68,72 @@ function transformCodeNode(
   return tree.children[0] as CodeNode
 }
 
+describe('remarkDefaultFrontmatter', () => {
+  it('infers title and description from heading subtext with inline code', async () => {
+    const tree = await runRemark(
+      '# Common Package [How `packages/common` is structured, why it exists]',
+      [remarkDefaultFrontmatter],
+    )
+    const frontmatter = tree.children[0]
+
+    expect(frontmatter).toMatchObject({
+      type: 'yaml',
+      value:
+        'title: "Common Package"\ndescription: "How packages/common is structured, why it exists"',
+    })
+  })
+})
+
+describe('remarkSubheading', () => {
+  it('extracts heading subtext with inline markdown nodes', async () => {
+    const tree = await runRemark(
+      [
+        '---',
+        'title: Test',
+        '---',
+        '',
+        '# **Common** Package [How `packages/common` is *structured*]',
+      ].join('\n'),
+      [remarkFrontmatter, remarkSubheading],
+    )
+    const hgroup = tree.children[1] as MdAst.Paragraph
+    const heading = hgroup.children[0] as unknown as MdAst.Heading
+    const subheading = hgroup.children[1] as unknown as MdAst.Paragraph
+
+    expect(stripPositions(heading.children)).toEqual([
+      {
+        type: 'strong',
+        children: [{ type: 'text', value: 'Common' }],
+      },
+      { type: 'text', value: ' Package' },
+    ])
+    expect(stripPositions(subheading.children)).toEqual([
+      { type: 'text', value: 'How ' },
+      { type: 'inlineCode', value: 'packages/common' },
+      { type: 'text', value: ' is ' },
+      {
+        type: 'emphasis',
+        children: [{ type: 'text', value: 'structured' }],
+      },
+    ])
+  })
+})
+
+async function runRemark(markdown: string, plugins: unknown[]) {
+  const processor = unified().use(remarkParse)
+  for (const plugin of plugins) processor.use(plugin as never)
+  const tree = processor.parse(markdown) as MdAst.Root
+  await processor.run(tree)
+  return tree
+}
+
+function stripPositions(children: MdAst.PhrasingContent[]): unknown[] {
+  return children.map(({ position: _, ...child }) => {
+    if ('children' in child) return { ...child, children: stripPositions(child.children) }
+    return child
+  })
+}
+
 describe('remarkFilename', () => {
   it('scopes duplicate code-group filenames to their group', () => {
     const firstExample = {
@@ -223,6 +295,17 @@ describe('getCompileOptions', () => {
     expect(codeNode.lang).toBe('ts')
     expect(codeNode.meta).toBe('[example.ts]')
   })
+
+  it('threads user-configured remark plugins into the txt profile', () => {
+    function userRemarkPlugin() {}
+    const config = Config.define({
+      markdown: { remarkPlugins: [userRemarkPlugin] },
+      rootDir: process.cwd(),
+    })
+
+    expect(getCompileOptions('txt', config).remarkPlugins).toContain(userRemarkPlugin)
+    expect(getCompileOptions('react', config).remarkPlugins).toContain(userRemarkPlugin)
+  })
 })
 
 describe('remarkRestoreUnknownTextDirectives', () => {

package/src/internal/mdx.ts

@@ -213,6 +213,9 @@ export function getCompileOptions(
           remarkStripFrontmatter,
           remarkStripJs,
           remarkStripInlineCache,
+          // User plugins extend the parser (e.g. `remark-math`) so syntax
+          // recognized in the React build also parses for llms/search.
+          ...(markdown?.remarkPlugins ?? []),
         ],
       }
     if (type === 'react')
@@ -809,17 +812,15 @@ export function remarkDefaultFrontmatter() {
     const heading = (tree.children.find(
       (node) => node.type === 'heading' && (node as { depth: number }).depth === 1,
     ) ?? tree.children.find((node) => node.type === 'heading')) as
-      | { type: 'heading'; children: { type: string; value?: string }[] }
+      | { type: 'heading'; children: MdAst.PhrasingContent[] }
       | undefined
     if (!heading) return
 
-    // Extract text content
-    const textContent = heading.children.map((child) => child.value ?? '').join('')
-
-    // Parse title and description: "My Title [Description here]"
-    const match = textContent.match(/^(.+?)\s*\[(.+)\]$/)
-    const title = match?.[1]?.trim() ?? textContent.trim()
-    const description = match?.[2]?.trim()
+    const subheading = extractSubheading(heading.children)
+    const title = getPhrasingContentText(subheading?.headingChildren ?? heading.children).trim()
+    const description = subheading
+      ? getPhrasingContentText(subheading.subheadingChildren).trim()
+      : undefined
 
     // Build new frontmatter
     const newLines: string[] = []
@@ -1035,25 +1036,15 @@ export function remarkStripFrontmatter() {
  * Converts `# Title [Subheading text]` into a `<header>` with both title and subtitle.
  */
 export function remarkSubheading() {
-  const subheadingRegex = / \[(.*)\]$/
-
   return (tree: MdAst.Root) => {
     UnistUtil.visit(tree, 'heading', (node, index, parent) => {
       if (index === undefined || !parent) return
       if (node.depth !== 1) return
       if (node.children.length === 0) return
 
-      // Find child with subheading pattern
-      const textChild = node.children.find(
-        (child): child is MdAst.Text => child.type === 'text' && subheadingRegex.test(child.value),
-      )
-      if (!textChild) return
-
-      // Extract and remove subheading from text
-      const match = textChild.value.match(subheadingRegex)
-      if (!match) return
-      const subheading = match[1]
-      textChild.value = textChild.value.replace(match[0], '')
+      const subheading = extractSubheading(node.children)
+      if (!subheading) return
+      node.children = subheading.headingChildren
 
       // Build hgroup wrapper with h1 and optional subtitle (p)
       const hgroup = {
@@ -1061,12 +1052,12 @@ export function remarkSubheading() {
         data: { hName: 'hgroup' },
         children: [
           node as unknown as MdAst.PhrasingContent,
-          ...(subheading
+          ...(subheading.subheadingChildren.length > 0
             ? [
                 {
                   type: 'paragraph',
                   data: { hName: 'p' },
-                  children: [{ type: 'text', value: subheading }],
+                  children: subheading.subheadingChildren,
                 } as unknown as MdAst.PhrasingContent,
               ]
             : []),
@@ -1080,6 +1071,64 @@ export function remarkSubheading() {
   }
 }
 
+type Subheading = {
+  headingChildren: MdAst.PhrasingContent[]
+  subheadingChildren: MdAst.PhrasingContent[]
+}
+
+export function extractSubheading(children: MdAst.PhrasingContent[]): Subheading | undefined {
+  const lastChild = children[children.length - 1]
+  if (!isText(lastChild) || !lastChild.value.endsWith(']')) return
+
+  for (let index = children.length - 1; index >= 0; index--) {
+    const child = children[index]
+    if (!isText(child)) continue
+
+    const openIndex = child.value.lastIndexOf(' [')
+    if (openIndex === -1) continue
+
+    const headingChildren = clonePhrasingContent(children.slice(0, index))
+    const headingText = child.value.slice(0, openIndex)
+    if (headingText) headingChildren.push({ ...child, value: headingText })
+
+    const subheadingChildren = clonePhrasingContent(children.slice(index + 1))
+    const subheadingText = child.value.slice(openIndex + 2)
+    if (subheadingText) subheadingChildren.unshift({ ...child, value: subheadingText })
+
+    const finalChild = subheadingChildren[subheadingChildren.length - 1]
+    if (!isText(finalChild)) return
+    finalChild.value = finalChild.value.slice(0, -1)
+
+    return {
+      headingChildren,
+      subheadingChildren: subheadingChildren.filter(
+        (child) => !isText(child) || child.value.length > 0,
+      ),
+    }
+  }
+
+  return undefined
+}
+
+export function getPhrasingContentText(children: MdAst.PhrasingContent[]): string {
+  return children.map(getPhrasingNodeText).join('')
+}
+
+function clonePhrasingContent(children: MdAst.PhrasingContent[]) {
+  return children.map((child) => structuredClone(child))
+}
+
+function getPhrasingNodeText(child: MdAst.PhrasingContent): string {
+  if ('value' in child && typeof child.value === 'string') return child.value
+  if ('children' in child) return getPhrasingContentText(child.children)
+  if ('alt' in child && typeof child.alt === 'string') return child.alt
+  return ''
+}
+
+function isText(child: MdAst.PhrasingContent | undefined): child is MdAst.Text {
+  return child?.type === 'text'
+}
+
 const filenameRegex = /filename=["']([^"']+)["']/
 const titleFilenameRegex = /\[([./\w-]+\.(?:[cm]?[jt]sx?|json|sol|rs|toml|ya?ml|css|html|mdx?))\]/
 

package/src/internal/search.test.ts

@@ -1,3 +1,4 @@
+import type * as MdAst from 'mdast'
 import { describe, expect, it } from 'vitest'
 import * as Config from './config.js'
 import * as Search from './search.js'
@@ -746,6 +747,26 @@ Some content.
     `)
   })
 
+  it('handles title descriptions with inline code', () => {
+    const content = `
+# Common Package [How \`packages/common\` is structured, why it exists]
+
+Some content.
+`
+    expect(Search.extract(content, config).sections).toMatchInlineSnapshot(`
+      [
+        {
+          "anchor": "common-package",
+          "isPage": true,
+          "subtitle": "How packages/common is structured, why it exists",
+          "text": " Some content.",
+          "title": "Common Package",
+          "titles": [],
+        },
+      ]
+    `)
+  })
+
   it('includes JSX text content', () => {
     const content = `
 # Title
@@ -817,6 +838,25 @@ Some content here.
       ]
     `)
   })
+
+  it('applies user-configured remark plugins from config', () => {
+    function remarkUppercaseHeadings() {
+      return (tree: MdAst.Root) => {
+        for (const node of tree.children) {
+          if (node.type !== 'heading') continue
+          for (const child of node.children)
+            if (child.type === 'text') child.value = child.value.toUpperCase()
+        }
+      }
+    }
+
+    const customConfig = Config.define({
+      markdown: { remarkPlugins: [remarkUppercaseHeadings] },
+    })
+
+    const { sections } = Search.extract('# hello world\n\nSome text.', customConfig)
+    expect(sections[0]?.title).toBe('HELLO WORLD')
+  })
 })
 
 describe('Search fields and storeFields', () => {

package/src/internal/search.ts

@@ -14,6 +14,7 @@ import { unified } from 'unified'
 import * as UnistUtil from 'unist-util-visit'
 import * as yaml from 'yaml'
 import type * as Config from './config.js'
+import { extractSubheading, getPhrasingContentText } from './mdx.js'
 import * as Path from './path.js'
 import { searchFields, storeFields, tokenize } from './search.client.js'
 import * as Sidebar from './sidebar.js'
@@ -310,13 +311,16 @@ type Section = {
  * - `content`: raw markdown (sliced from source) for rendering in search UI
  * - `text`: stripped plain text (directives/JSX removed) for search indexing
  */
-export function extract(source: string, _config: Config.Config): extract.ReturnType {
+export function extract(source: string, config: Config.Config): extract.ReturnType {
   const remarkPlugins = [
     remarkFrontmatter,
     remarkDirective,
     remarkGfm,
     remarkStripJsx,
     remarkStripDirectives,
+    // User plugins extend the parser (e.g. `remark-math`) so syntax
+    // recognized in the React build also parses during indexing.
+    ...(config.markdown?.remarkPlugins ?? []),
   ]
 
   // Extract frontmatter with regex (avoids extra parse)
@@ -337,14 +341,17 @@ export function extract(source: string, _config: Config.Config): extract.ReturnT
   const headingPositions = tree.children
     .filter((node): node is MdAst.Heading => node.type === 'heading')
     .map((heading) => {
-      const rawTitle = mdastToString(heading).trim()
-      const subtitleMatch = rawTitle.match(/ \[(.+)\]$/)
+      const subheading = extractSubheading(heading.children)
+      const title = getPhrasingContentText(subheading?.headingChildren ?? heading.children).trim()
+      const subtitle = subheading
+        ? getPhrasingContentText(subheading.subheadingChildren).trim()
+        : ''
       return {
         depth: heading.depth,
         endOffset: heading.position?.end.offset ?? 0,
         startOffset: heading.position?.start.offset ?? 0,
-        subtitle: subtitleMatch?.[1] ?? '',
-        title: subtitleMatch ? rawTitle.replace(/ \[.+\]$/, '') : rawTitle,
+        subtitle,
+        title,
       }
     })
 

package/src/waku/internal/middleware/md-router.test.ts

@@ -137,4 +137,89 @@ describe('middleware', () => {
     expect(await response.text()).toBe('# Hello from disk')
     expect(readFile).toHaveBeenCalledOnce()
   })
+
+  it('passes static assets through for AI agents without resolving a twin', async () => {
+    process.env['NODE_ENV'] = 'production'
+
+    const { readFile } = await import('node:fs/promises')
+    const fetchSpy = vi.fn()
+    globalThis.fetch = fetchSpy
+
+    const response = await request('http://localhost/specs/v0.1/openapi.json', {
+      'user-agent': 'Mozilla/5.0 (compatible; ClaudeBot/1.0; +claudebot@anthropic.com)',
+    })
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get('content-type')).toContain('text/html')
+    expect(await response.text()).toBe('<p>ok</p>')
+    expect(readFile).not.toHaveBeenCalled()
+    expect(fetchSpy).not.toHaveBeenCalled()
+  })
+
+  it('passes static assets through for terminal user-agents', async () => {
+    process.env['NODE_ENV'] = 'production'
+
+    const { readFile } = await import('node:fs/promises')
+    const fetchSpy = vi.fn()
+    globalThis.fetch = fetchSpy
+
+    const response = await request('http://localhost/specs/v0.1/openapi.json', {
+      'user-agent': 'curl/8.7.1',
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.text()).toBe('<p>ok</p>')
+    expect(readFile).not.toHaveBeenCalled()
+    expect(fetchSpy).not.toHaveBeenCalled()
+  })
+
+  it('passes static assets through even when text/markdown is accepted', async () => {
+    process.env['NODE_ENV'] = 'production'
+
+    const { readFile } = await import('node:fs/promises')
+    const fetchSpy = vi.fn()
+    globalThis.fetch = fetchSpy
+
+    const response = await request('http://localhost/specs/openapi.json', {
+      accept: 'text/markdown',
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.text()).toBe('<p>ok</p>')
+    expect(readFile).not.toHaveBeenCalled()
+    expect(fetchSpy).not.toHaveBeenCalled()
+  })
+
+  it('passes generated markdown twins through without re-resolving', async () => {
+    process.env['NODE_ENV'] = 'production'
+
+    const { readFile } = await import('node:fs/promises')
+    const fetchSpy = vi.fn()
+    globalThis.fetch = fetchSpy
+
+    const response = await request('http://localhost/assets/md/docs.md', {
+      'user-agent': 'Mozilla/5.0 (compatible; GPTBot/1.0; +https://openai.com/gptbot)',
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.text()).toBe('<p>ok</p>')
+    expect(readFile).not.toHaveBeenCalled()
+    expect(fetchSpy).not.toHaveBeenCalled()
+  })
+
+  it('serves markdown for clean routes whose parent segments contain dots', async () => {
+    process.env['NODE_ENV'] = 'production'
+
+    const { readFile } = await import('node:fs/promises')
+    vi.mocked(readFile).mockResolvedValue('# Hello from disk')
+
+    const response = await request('http://localhost/docs/v2.0/intro', {
+      'user-agent': 'Mozilla/5.0 (compatible; GPTBot/1.0; +https://openai.com/gptbot)',
+    })
+
+    expect(response.status).toBe(200)
+    expect(response.headers.get('content-type')).toBe('text/markdown; charset=utf-8')
+    expect(await response.text()).toBe('# Hello from disk')
+    expect(readFile).toHaveBeenCalledOnce()
+  })
 })

package/src/waku/internal/middleware/md-router.ts

@@ -97,6 +97,10 @@ export function middleware(): MiddlewareHandler {
   return async (context, next) => {
     const url = new URL(context.req.url)
 
+    // Generated markdown twins are static output; routing them back through
+    // twin resolution would trigger a recursive self-fetch.
+    if (url.pathname.startsWith('/assets/md/')) return next()
+
     const userAgent = context.req.header('user-agent') ?? ''
     const isOgBot = ogBotUserAgents.some((agent) => userAgent.includes(agent))
     if (isOgBot) return next()
@@ -126,6 +130,12 @@ export function middleware(): MiddlewareHandler {
     }
 
     const isMarkdownRequest = url.pathname.endsWith('.md')
+
+    // Static assets (`.json`, `.svg`, `.png`, ...) have no markdown twin. Skip
+    // twin resolution so a disk miss never falls back to a slow self-fetch.
+    const filename = url.pathname.split('/').pop() ?? ''
+    if (!isMarkdownRequest && filename.includes('.')) return next()
+
     if (!isMarkdownRequest && (isSearchEngine || (!isAiAgent && !isTerminal && !acceptsMarkdown)))
       return next()
 
@@ -148,7 +158,7 @@ export function middleware(): MiddlewareHandler {
 
     context.res = new Response(text, {
       headers: {
-        'Content-Type': `${url.pathname.endsWith('.txt') ? 'text/plain' : 'text/markdown'}; charset=utf-8`,
+        'Content-Type': 'text/markdown; charset=utf-8',
       },
     })
     return

package/src/waku/internal/patches/adapters/node.ts

@@ -2,6 +2,7 @@ import path from 'node:path'
 import { serve } from '@hono/node-server'
 import { serveStatic } from '@hono/node-server/serve-static'
 import type { MiddlewareHandler } from 'hono'
+import { bodyLimit } from 'hono/body-limit'
 import { Hono } from 'hono/tiny'
 import { unstable_createServerEntryAdapter as createServerEntryAdapter } from 'waku/adapter-builders'
 import {
@@ -10,13 +11,22 @@ import {
 } from 'waku/internals'
 
 const { DIST_PUBLIC } = constants
-const { contextMiddleware, rscMiddleware, middlewareRunner } = honoMiddleware
+const { rscMiddleware, middlewareRunner } = honoMiddleware
 
-type MiddlewareModules = Record<string, () => Promise<{ default: () => MiddlewareHandler }>>
+const DEFAULT_BODY_LIMIT_MAX_SIZE = 100 * 1024 * 1024
+
+type MiddlewareModules = Record<
+  string,
+  () => Promise<{ default: (opts: { app: Hono }) => MiddlewareHandler }>
+>
 
 const adapter: typeof import('waku/adapters/node').default = createServerEntryAdapter(
   ({ processRequest, processBuild, config, isBuild, notFoundHtml }, options) => {
-    const { middlewareFns = [], middlewareModules = {} } = options || {}
+    const {
+      bodyLimit: bodyLimitOptions,
+      middlewareFns = [],
+      middlewareModules = {},
+    } = options || {}
     const typedMiddlewareModules = middlewareModules as MiddlewareModules
     const app = new Hono()
 
@@ -29,9 +39,12 @@ const adapter: typeof import('waku/adapters/node').default = createServerEntryAd
     // output before middleware in build mode, but Vocs needs mdRouter to run first
     // for partial-static clean URLs that negotiate `text/markdown`.
     if (isBuild && typedMiddlewareModules['mdRouter']) {
-      const mdRouterMiddleware = middlewareRunner({
-        mdRouter: typedMiddlewareModules['mdRouter'],
-      })
+      const mdRouterMiddleware = middlewareRunner(
+        {
+          mdRouter: typedMiddlewareModules['mdRouter'],
+        },
+        { app },
+      )
       app.use(`${config.basePath}*`, (context, next) => {
         const url = new URL(context.req.url)
         // Generated markdown assets are already static output. Passing them through
@@ -50,9 +63,10 @@ const adapter: typeof import('waku/adapters/node').default = createServerEntryAd
         }),
       )
 
-    app.use(contextMiddleware())
-    for (const middlewareFn of middlewareFns) app.use(middlewareFn())
-    app.use(middlewareRunner(typedMiddlewareModules))
+    if (bodyLimitOptions !== false)
+      app.use(bodyLimit(bodyLimitOptions ?? { maxSize: DEFAULT_BODY_LIMIT_MAX_SIZE }))
+    for (const middlewareFn of middlewareFns) app.use(middlewareFn({ app }))
+    app.use(middlewareRunner(typedMiddlewareModules, { app }))
     app.use(rscMiddleware({ processRequest }))
 
     return {